diff --git a/plugins/clang/tests/test_codecompletion.cpp b/plugins/clang/tests/test_codecompletion.cpp
index 865205d5bc..cf45a6c262 100644
--- a/plugins/clang/tests/test_codecompletion.cpp
+++ b/plugins/clang/tests/test_codecompletion.cpp
@@ -1,1411 +1,1410 @@
 /*
  * Copyright 2014  David Stevens <dgedstevens@gmail.com>
  * Copyright 2014  Kevin Funk <kfunk@kde.org>
  * Copyright 2015 Milian Wolff <mail@milianw.de>
  * Copyright 2015 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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 "test_codecompletion.h"
 #include <language/backgroundparser/backgroundparser.h>
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testfile.h>
 #include <tests/testproject.h>
 
 #include "duchain/parsesession.h"
 #include "util/clangtypes.h"
 
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 
 #include <language/codecompletion/codecompletiontesthelper.h>
 #include <language/duchain/types/functiontype.h>
 
 #include "codecompletion/completionhelper.h"
 #include "codecompletion/context.h"
 #include "codecompletion/includepathcompletioncontext.h"
 #include "../clangsettings/clangsettingsmanager.h"
 
 #include <KTextEditor/Editor>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #include <KConfigGroup>
 
 QTEST_MAIN(TestCodeCompletion)
 
 static const auto NoMacroOrBuiltin = ClangCodeCompletionContext::ContextFilters(
     ClangCodeCompletionContext::NoBuiltins | ClangCodeCompletionContext::NoMacros);
 
 using namespace KDevelop;
 
 using ClangCodeCompletionItemTester = CodeCompletionItemTester<ClangCodeCompletionContext>;
 
 struct CompletionItems {
     CompletionItems(){}
     CompletionItems(const KTextEditor::Cursor& position, const QStringList& completions, const QStringList& declarationItems = {})
         : position(position)
         , completions(completions)
         , declarationItems(declarationItems)
     {};
     KTextEditor::Cursor position;
     QStringList completions;
     QStringList declarationItems; ///< completion items that have associated declarations. Declarations with higher match quality at the top. @sa KTextEditor::CodeCompletionModel::MatchQuality
 };
 Q_DECLARE_TYPEINFO(CompletionItems, Q_MOVABLE_TYPE);
 Q_DECLARE_METATYPE(CompletionItems)
 
 
 struct CompletionPriorityItem
 {
     CompletionPriorityItem(const QString& name, int matchQuality = 0, int inheritanceDepth = 0, const QString& failMessage = {})
         : name(name)
         , failMessage(failMessage)
         , matchQuality(matchQuality)
         , inheritanceDepth(inheritanceDepth)
     {}
 
     QString name;
     QString failMessage;
     int matchQuality;
     int inheritanceDepth;
 };
 
 struct CompletionPriorityItems : public CompletionItems
 {
     CompletionPriorityItems(){}
     CompletionPriorityItems(const KTextEditor::Cursor& position, const QList<CompletionPriorityItem>& completions)
         : CompletionItems(position, {})
         , completions(completions)
     {};
 
     QList<CompletionPriorityItem> completions;
 };
 
 Q_DECLARE_TYPEINFO(CompletionPriorityItems, Q_MOVABLE_TYPE);
 Q_DECLARE_METATYPE(CompletionPriorityItems)
 
 namespace {
 
 struct NoopTestFunction
 {
     void operator()(const ClangCodeCompletionItemTester& /*tester*/) const
     {
     }
 };
 
 QString textForDocument(const QUrl& url, const KTextEditor::Cursor& position)
 {
     bool close = false;
 
     auto* doc = ICore::self()->documentController()->documentForUrl(url);
     if (!doc) {
         doc = ICore::self()->documentController()->openDocument(url);
         close = true;
     }
 
     auto text = doc->textDocument()->text({{0, 0}, position});
 
     if (close) {
         doc->close(IDocument::Discard);
     }
 
     return text;
 }
 
 QExplicitlySharedDataPointer<ClangCodeCompletionContext> createContext(const ReferencedTopDUContext& top,
                                                                        const ParseSessionData::Ptr& sessionData,
                                                                        const KTextEditor::Cursor position,
                                                                        const QString& code = {})
 {
     const auto url = top->url().toUrl();
     const auto text = code.isEmpty() ? textForDocument(url, position) : code;
     return QExplicitlySharedDataPointer<ClangCodeCompletionContext>{
         new ClangCodeCompletionContext(DUContextPointer(top), sessionData, url, position, text)};
 }
 
 template<typename CustomTestFunction = NoopTestFunction>
 void executeCompletionTest(const ReferencedTopDUContext& top, const CompletionItems& expectedCompletionItems,
                            const ClangCodeCompletionContext::ContextFilters& filters = NoMacroOrBuiltin,
                            CustomTestFunction customTestFunction = {})
 {
     DUChainReadLocker lock;
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
     lock.unlock();
     // TODO: We should not need to pass 'session' to the context, should just use the base class ctor
     auto context = createContext(top, sessionData, expectedCompletionItems.position);
     context->setFilters(filters);
     lock.lock();
 
     auto tester = ClangCodeCompletionItemTester(context);
 
     int previousMatchQuality = 10;
     for(const auto& declarationName : expectedCompletionItems.declarationItems){
         const auto declarationItem = tester.findItem(declarationName);
         QVERIFY(declarationItem);
         QVERIFY(declarationItem->declaration());
 
         auto matchQuality = tester.itemData(declarationItem, KTextEditor::CodeCompletionModel::Name, KTextEditor::CodeCompletionModel::MatchQuality).toInt();
         QVERIFY(matchQuality <= previousMatchQuality);
         previousMatchQuality = matchQuality;
     }
 
     tester.names.sort();
     QEXPECT_FAIL("look-ahead function primary type argument", "No API in LibClang to determine expected code completion type", Continue);
     QEXPECT_FAIL("look-ahead template parameter substitution", "No parameters substitution so far", Continue);
 #if CINDEX_VERSION_MINOR < 30
     QEXPECT_FAIL("look-ahead auto item", "Auto type, like many other types, is not exposed through LibClang. We assign DelayedType to it instead of IdentifiedType", Continue);
 #endif
     if (QTest::currentTestFunction() == QByteArrayLiteral("testImplementAfterEdit") && expectedCompletionItems.position.line() == 3) {
         QEXPECT_FAIL("", "TU is not properly updated after edit", Continue);
     }
     if (tester.names.size() != expectedCompletionItems.completions.size()) {
         qDebug() << "different results:\nactual:" << tester.names << "\nexpected:" << expectedCompletionItems.completions;
     }
     QCOMPARE(tester.names, expectedCompletionItems.completions);
 
     customTestFunction(tester);
 }
 
 template<typename CustomTestFunction = NoopTestFunction>
 void executeCompletionTest(const QString& code, const CompletionItems& expectedCompletionItems,
                            const ClangCodeCompletionContext::ContextFilters& filters = NoMacroOrBuiltin,
                            CustomTestFunction customTestFunction = {})
 {
     TestFile file(code, QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     executeCompletionTest(file.topContext(), expectedCompletionItems, filters, customTestFunction);
 }
 
 void executeCompletionPriorityTest(const QString& code, const CompletionPriorityItems& expectedCompletionItems,
                            const ClangCodeCompletionContext::ContextFilters& filters = NoMacroOrBuiltin)
 {
     TestFile file(code, QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
 
     // don't hold DUChain lock when constructing ClangCodeCompletionContext
     lock.unlock();
 
     auto context = createContext(top, sessionData, expectedCompletionItems.position);
     context->setFilters(filters);
 
     lock.lock();
     auto tester = ClangCodeCompletionItemTester(context);
 
     for(const auto& declaration : expectedCompletionItems.completions){
         const auto declarationItem = tester.findItem(declaration.name);
         QVERIFY(declarationItem);
         QVERIFY(declarationItem->declaration());
 
         auto matchQuality = tester.itemData(declarationItem, KTextEditor::CodeCompletionModel::Name, KTextEditor::CodeCompletionModel::MatchQuality).toInt();
         auto inheritanceDepth = declarationItem->inheritanceDepth();
 
         if(!declaration.failMessage.isEmpty()){
             QEXPECT_FAIL("", declaration.failMessage.toUtf8().constData(), Continue);
         }
         QVERIFY(matchQuality == declaration.matchQuality && inheritanceDepth == declaration.inheritanceDepth);
     }
 }
 
 void executeMemberAccessReplacerTest(const QString& code, const CompletionItems& expectedCompletionItems,
                                      const ClangCodeCompletionContext::ContextFilters& filters = NoMacroOrBuiltin)
 {
     TestFile file(code, QStringLiteral("cpp"));
 
     auto document = ICore::self()->documentController()->openDocument(file.url().toUrl());
     QVERIFY(document);
     ICore::self()->documentController()->activateDocument(document);
     auto view = ICore::self()->documentController()->activeTextDocumentView();
     Q_ASSERT(view);
     view->setCursorPosition(expectedCompletionItems.position);
 
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
 
     lock.unlock();
 
     auto context = createContext(top, sessionData, expectedCompletionItems.position, code);
 
     QApplication::processEvents();
     document->close(KDevelop::IDocument::Silent);
 
     // The previous ClangCodeCompletionContext call should replace member access.
     // That triggers an update request in the duchain which we are not interested in,
     // so let's stop that request.
     ICore::self()->languageController()->backgroundParser()->removeDocument(file.url());
 
     context = createContext(top, sessionData, expectedCompletionItems.position);
     context->setFilters(filters);
     lock.lock();
     auto tester = ClangCodeCompletionItemTester(context);
 
     tester.names.sort();
     QCOMPARE(tester.names, expectedCompletionItems.completions);
 }
 
 using IncludeTester = CodeCompletionItemTester<IncludePathCompletionContext>;
 
 QExplicitlySharedDataPointer<IncludePathCompletionContext> executeIncludePathCompletion(TestFile* file, const KTextEditor::Cursor& position)
 {
     if (!file->parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST)) {
         QTest::qFail("Failed to parse source file.", __FILE__, __LINE__);
         return {};
     }
 
     DUChainReadLocker lock;
     auto top = file->topContext();
     if (!top) {
         QTest::qFail("Failed to parse source file.", __FILE__, __LINE__);
         return {};
     }
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     if (!sessionData) {
         QTest::qFail("Failed to acquire parse session data.", __FILE__, __LINE__);
         return {};
     }
 
     DUContextPointer topPtr(top);
 
     lock.unlock();
 
     auto text = file->fileContents();
     int textLength = -1;
     if (position.isValid()) {
         textLength = 0;
         for (int i = 0; i < position.line(); ++i) {
             textLength = text.indexOf('\n', textLength) + 1;
         }
         textLength += position.column();
     }
     auto context = new IncludePathCompletionContext(topPtr, sessionData, file->url().toUrl(), position, text.mid(0, textLength));
     return QExplicitlySharedDataPointer<IncludePathCompletionContext>{context};
 }
 
 }
 
 void TestCodeCompletion::testClangCodeCompletion()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeCompletionTest(code, expectedItems);
 }
 
 void TestCodeCompletion::testClangCodeCompletion_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("assignment")
         << "int foo = 5; \nint bar = "
         << CompletionItems{{1,9}, {
             "bar",
             "foo",
         }, {"bar","foo"}};
     QTest::newRow("dotmemberaccess")
         << "class Foo { public: void foo() {} bool operator=(Foo &&) }; int main() { Foo f; \nf. "
         << CompletionItems{{1, 2}, {
             "foo",
             "operator="
         }, {"foo",  "operator="}};
     QTest::newRow("arrowmemberaccess")
         << "class Foo { public: void foo() {} }; int main() { Foo* f = new Foo; \nf-> }"
         << CompletionItems{{1, 3}, {
             "foo"
         }, {"foo"}};
     QTest::newRow("enum-case")
         << "enum Foo { foo, bar }; int main() { Foo f; switch (f) {\ncase "
         << CompletionItems{{1,4}, {
             "bar",
             "foo",
         }, {"foo", "bar"}};
     QTest::newRow("only-private")
         << "class SomeStruct { private: void priv() {} };\n"
            "int main() { SomeStruct s;\ns. "
         << CompletionItems{{2, 2}, {
         }};
     QTest::newRow("private-friend")
         << "class SomeStruct { private: void priv() {} friend int main(); };\n"
            "int main() { SomeStruct s;\ns. "
         << CompletionItems{{2, 2}, {
             "priv",
         }, {"priv"}};
     QTest::newRow("private-public")
         << "class SomeStruct { public: void pub() {} private: void priv() {} };\n"
            "int main() { SomeStruct s;\ns. "
         << CompletionItems{{2, 2}, {
             "pub",
         }, {"pub"}};
     QTest::newRow("protected-public")
         << "class SomeStruct { public: void pub() {} protected: void prot() {} };\n"
            "int main() { SomeStruct s;\ns. "
         << CompletionItems{{2, 2}, {
             "pub",
         }, {"pub"}};
     QTest::newRow("localVariable")
         << "int main() { int localVariable;\nloc "
         << CompletionItems{{1, 3},
             {"localVariable","main"},
             {"localVariable", "main"}
         };
     QTest::newRow("globalVariable")
         << "int globalVariable;\nint main() { \ngl "
         << CompletionItems{{2, 2},
             {"globalVariable","main"},
             {"globalVariable", "main"}
         };
     QTest::newRow("namespaceVariable")
         << "namespace NameSpace{int variable};\nint main() { \nNameSpace:: "
         << CompletionItems{{2, 11},
             {"variable"},
             {"variable"}
         };
     QTest::newRow("parentVariable")
         << "class A{public: int m_variable;};class B : public A{};\nint main() { B b;\nb. "
         << CompletionItems{{2, 2},
             {"m_variable"},
             {"m_variable"}
         };
     QTest::newRow("itemsPriority")
         << "class A; class B; void f(A); int main(){ A c; B b;f(\n} "
         << CompletionItems{{1, 0},
             {"A", "B", "b", "c", "f",
 #if CINDEX_VERSION_MINOR >= 30
              "f",
 #endif
                          "main"},
             {"c", "A", "b", "B"}
     };
     QTest::newRow("function-arguments")
         << "class Abc; int f(Abc){\n "
         << CompletionItems{{1, 0}, {
             "Abc",
             "f",
         }};
     QTest::newRow("look-ahead int")
         << "struct LookAhead { int intItem;}; int main() {LookAhead* pInstance; LookAhead instance; int i =\n }"
         << CompletionItems{{1, 0}, {
             "LookAhead", "i", "instance",
             "instance.intItem", "main",
             "pInstance", "pInstance->intItem",
         }};
     QTest::newRow("look-ahead class")
         << "class Class{}; struct LookAhead {Class classItem;}; int main() {LookAhead* pInstance; LookAhead instance; Class cl =\n }"
         << CompletionItems{{1, 0}, {
             "Class", "LookAhead", "cl",
             "instance", "instance.classItem",
             "main", "pInstance", "pInstance->classItem",
         }};
     QTest::newRow("look-ahead function argument")
         << "class Class{}; struct LookAhead {Class classItem;}; void function(Class cl);"
            "int main() {LookAhead* pInstance; LookAhead instance; function(\n }"
         << CompletionItems{{1, 0}, {
             "Class", "LookAhead", "function",
 #if CINDEX_VERSION_MINOR >= 30
             "function",
 #endif
             "instance", "instance.classItem",
             "main", "pInstance", "pInstance->classItem",
         }};
     QTest::newRow("look-ahead function primary type argument")
         << "struct LookAhead {double doubleItem;}; void function(double double);"
            "int main() {LookAhead* pInstance; LookAhead instance; function(\n }"
         << CompletionItems{{1, 0}, {
             "LookAhead", "function", "instance",
             "instance.doubleItem", "main",
             "pInstance", "pInstance->doubleItem",
         }};
     QTest::newRow("look-ahead typedef")
         << "typedef double DOUBLE; struct LookAhead {DOUBLE doubleItem;};"
            "int main() {LookAhead* pInstance; LookAhead instance; double i =\n "
         << CompletionItems{{1, 0}, {
             "DOUBLE", "LookAhead", "i",
             "instance", "instance.doubleItem",
             "main", "pInstance", "pInstance->doubleItem",
         }};
     QTest::newRow("look-ahead pointer")
         << "struct LookAhead {int* pInt;};"
            "int main() {LookAhead* pInstance; LookAhead instance; int* i =\n "
         << CompletionItems{{1, 0}, {
             "LookAhead", "i", "instance",
             "instance.pInt", "main",
             "pInstance", "pInstance->pInt",
         }};
     QTest::newRow("look-ahead template")
         << "template <typename T> struct LookAhead {int intItem;};"
            "int main() {LookAhead<int>* pInstance; LookAhead<int> instance; int i =\n "
         << CompletionItems{{1, 0}, {
             "LookAhead", "i", "instance",
             "instance.intItem", "main",
             "pInstance", "pInstance->intItem",
         }};
     QTest::newRow("look-ahead template parameter substitution")
         << "template <typename T> struct LookAhead {T itemT;};"
            "int main() {LookAhead<int>* pInstance; LookAhead<int> instance; int i =\n "
         << CompletionItems{{1, 0}, {
             "LookAhead", "i", "instance",
             "instance.itemT", "main",
             "pInstance", "pInstance->itemT",
         }};
     QTest::newRow("look-ahead item access")
         << "class Class { public: int publicInt; protected: int protectedInt; private: int privateInt;};"
            "int main() {Class cl; int i =\n "
         << CompletionItems{{1, 0}, {
             "Class", "cl",
             "cl.publicInt",
             "i", "main",
         }};
 
     QTest::newRow("look-ahead auto item")
         << "struct LookAhead { int intItem; };"
            "int main() {auto instance = LookAhead(); int i = \n "
         << CompletionItems{{1, 0}, {
             "LookAhead",
             "i",
             "instance",
             "instance.intItem",
             "main"
         }};
 
     QTest::newRow("variadic template recursive class")
         << R"(
 template <typename Head, typename ...Tail>
 struct my_class : Head, my_class<Tail...>
 {
     using base = Head;
 };)"
         << CompletionItems{{3, 17}, { "Head", "Tail", "my_class" }};
 }
 
 void TestCodeCompletion::testReplaceMemberAccess()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeMemberAccessReplacerTest(code, expectedItems);
 }
 
 void TestCodeCompletion::testReplaceMemberAccess_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("replace arrow to dot")
     <<  "struct Struct { void function(); };"
         "int main() { Struct s; \ns-> "
     << CompletionItems{{1, 3}, {
         "function"
     }};
 
     QTest::newRow("replace dot to arrow")
     <<  "struct Struct { void function(); };"
         "int main() { Struct* s; \ns.  "
     << CompletionItems{{1, 3}, {
         "function"
     }};
 
     QTest::newRow("no replacement needed")
     <<  "int main() { double a = \n0.  "
     << CompletionItems{{1, 2}, {
     }};
 }
 
 void TestCodeCompletion::testVirtualOverride()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeCompletionTest(code, expectedItems, ClangCodeCompletionContext::NoClangCompletion);
 }
 
 void TestCodeCompletion::testVirtualOverride_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("basic")
         <<  "class Foo { virtual void foo(); virtual void foo(char c); virtual char foo(char c, int i, double d); };\n"
             "class Bar : Foo \n{void foo(char c) override;\n}"
         << CompletionItems{{3, 1}, {"foo()", "foo(char c, int i, double d)"}};
 
     QTest::newRow("template")
         << "template<class T1, class T2> class Foo { virtual T2 foo(T1 a, T2 b, int i); virtual T2 overridden(T1 a); } ;\n"
            "class Bar : Foo<char, double> \n{double overridden(char a) override;\n}"
         << CompletionItems{{3, 1}, {"foo(char a, double b, int i)"}};
 
     QTest::newRow("nested-template")
         << "template<class T1, class T2> class Foo { virtual T2 foo(T1 a, T2 b, int i); virtual T2 overridden(T1 a, T2 b, int i); } ;\n"
            "template<class T1, class T2> class Baz { };\n"
            "class Bar : Foo<char, Baz<char, double>> \n{Baz<char, double> overridden(char a, Baz<char, double> b, int i) override;\n}"
         << CompletionItems{{4, 1}, {"foo(char a, Baz<char, double> b, int i)"}};
 
     QTest::newRow("multi")
         << "class Foo { virtual int foo(int i); virtual int overridden(int i); };\n"
            "class Baz { virtual char baz(char c); };\n"
            "class Bar : Foo, Baz \n{int overridden(int i) override;\n}"
         << CompletionItems{{4, 1}, {"baz(char c)", "foo(int i)"}};
 
     QTest::newRow("deep")
         << "class Foo { virtual int foo(int i); virtual int overridden(int i); };\n"
            "class Baz : Foo { };\n"
            "class Bar : Baz \n{int overridden(int i) override;\n}"
         << CompletionItems{{4, 1}, {"foo(int i)"}};
 
     QTest::newRow("repeated")
         << "class Foo { virtual int foo(int i); virtual int overridden(int i); };\n"
            "class Baz : Foo { int foo(int i) override; };\n"
            "class Bar : Baz \n{int overridden(int i) override;\n}"
         << CompletionItems{{4, 1}, {"foo(int i)"}};
 
     QTest::newRow("pure")
         << "class Foo { virtual void foo() = 0; virtual void overridden() = 0;};\n"
            "class Bar : Foo \n{void overridden() override;\n};"
         << CompletionItems{{3, 0}, {"foo() = 0"}};
 
     QTest::newRow("repeated-pure")
         << "class Foo { virtual void foo() = 0; virtual void overridden() = 0; };\n"
            "class Baz : Foo { void foo() override; };\n"
            "class Bar : Baz \n{void overridden() override;\n}"
         << CompletionItems{{4, 1}, {"foo()"}};
 
     QTest::newRow("const")
         << "class Foo { virtual void foo(const int b) const; virtual void overridden(const int b) const; }\n;"
            "class Bar : Foo \n{void overridden(const int b) const override;\n}"
         << CompletionItems{{3, 1}, {"foo(const int b) const"}};
 
     QTest::newRow("dont-override")
         << R"(class A {
                   virtual void something() = 0;
               };
               class B : public A
               {
               public:
                   void foo();
               };
               void B::foo() {}
         )" << CompletionItems{{8, 14}, {}};
 }
 
 void TestCodeCompletion::testImplement()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeCompletionTest(code, expectedItems, ClangCodeCompletionContext::NoClangCompletion);
 }
 
 void TestCodeCompletion::testImplement_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("basic")
         << "int foo(char c, int i); \n"
         << CompletionItems{{1, 0}, {"foo(char c, int i)"}};
 
     QTest::newRow("class")
         << "class Foo { \n"
            "int bar(char c, int i); \n\n"
            "}; \n"
         << CompletionItems{{2, 0}, {}};
 
     QTest::newRow("class2")
         << "class Foo { \n"
             "int bar(char c, int i); \n\n"
             "}; \n"
         << CompletionItems{{4, 0}, {"Foo::bar(char c, int i)"}};
 
     QTest::newRow("namespace")
         << "namespace Foo { \n"
            "int bar(char c, int i); \n\n"
            "}; \n"
         << CompletionItems{{2, 0}, {"bar(char c, int i)"}};
 
     QTest::newRow("anonymous-namespace")
         << R"(
                 namespace {
                     int bar(char c, int i);
                 };
             )"
         << CompletionItems{{3, 0}, {"bar(char c, int i)"}};
 
     QTest::newRow("anonymous-namespace2")
         << R"(
                 namespace {
                     int bar(char c, int i);
                 };
            )"
         << CompletionItems{{4, 0}, {}};
 
     QTest::newRow("namespace2")
         << "namespace Foo { \n"
            "int bar(char c, int i); \n\n"
            "}; \n"
         << CompletionItems{{4, 0}, {"Foo::bar(char c, int i)"}};
 
     QTest::newRow("two-namespace")
         << "namespace Foo { int bar(char c, int i); };\n"
            "namespace Foo {\n"
            "};\n"
         << CompletionItems{{2, 0}, {"bar(char c, int i)"}};
 
     QTest::newRow("destructor")
         << "class Foo { ~Foo(); }\n"
         << CompletionItems{{1, 0}, {"Foo::~Foo()"}};
 
     QTest::newRow("constructor")
         << "class Foo { \n"
                  "Foo(int i); \n"
                  "}; \n"
         << CompletionItems{{3, 1}, {"Foo::Foo(int i)"}};
 
     QTest::newRow("template")
         << "template<typename T> class Foo { T bar(T t); };\n"
         << CompletionItems{{1, 1}, {"Foo<T>::bar(T t)"}};
 
     QTest::newRow("specialized-template")
         << "template<typename T> class Foo { \n"
            "T bar(T t); \n"
            "}; \n"
            "template<typename T> T Foo<T>::bar(T t){} \n"
            "template<> class Foo<int> { \n"
            "int bar(int t); \n"
            "}\n"
         << CompletionItems{{6, 1}, {"Foo<int>::bar(int t)"}};
 
     QTest::newRow("nested-class")
         << "class Foo { \n"
            "class Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{3, 1}, {}};
 
     QTest::newRow("nested-class2")
         << "class Foo { \n"
            "class Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{5, 1}, {}};
 
     QTest::newRow("nested-class3")
         << "class Foo { \n"
            "class Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{7, 1}, {"Foo::Bar::baz(char c, int i)"}};
 
     QTest::newRow("nested-namespace")
         << "namespace Foo { \n"
            "namespace Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{3, 1}, {"baz(char c, int i)"}};
 
     QTest::newRow("nested-namespace2")
         << "namespace Foo { \n"
            "namespace Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{5, 1}, {"Bar::baz(char c, int i)"}};
 
     QTest::newRow("nested-namespace3")
         << "namespace Foo { \n"
            "namespace Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{7, 1}, {"Foo::Bar::baz(char c, int i)"}};
 
     QTest::newRow("partial-template")
         << "template<typename T> class Foo { \n"
            "template<typename U> class Bar;\n"
            "template<typename U> class Bar<U*> { void baz(T t, U u); }\n"
            "}\n"
         << CompletionItems{{5,1}, {"Foo<T>::Bar<U *>::baz(T t, U u)"}};
 
     QTest::newRow("variadic")
         << "int foo(...); int bar(int i, ...); \n"
         << CompletionItems{{1, 1}, {"bar(int i, ...)", "foo(...)"}};
 
     QTest::newRow("const")
         << "class Foo { int bar() const; };"
         << CompletionItems{{3, 1}, {"Foo::bar() const"}};
 
     QTest::newRow("multiple-methods")
         << "class Foo { int bar(); void foo(); char asdf() const; };"
         << CompletionItems{{1, 1}, {"Foo::asdf() const", "Foo::bar()", "Foo::foo()"}};
 
     // explicitly deleted/defaulted functions should not appear in the implements completion
     QTest::newRow("deleted-copy-ctor")
         << "struct S { S(); S(const S&) = /*some comment*/ delete; };"
         << CompletionItems{{1,1}, {"S::S()"}};
     QTest::newRow("deleted-overload-member")
         << "struct Foo {\n"
            "  int x();\n"
            "  int x(int) =delete;\n"
            "};\n"
         << CompletionItems{{5,1}, {"Foo::x()"}};
     QTest::newRow("deleted-overload-global")
         << "int x();\n"
            "int x(int)=  delete;\n"
         << CompletionItems{{2,1}, {"x()"}};
     QTest::newRow("defaulted-copy-ctor")
         << "struct S { S(); S(const S&) = default; };"
         << CompletionItems{{1,1}, {"S::S()"}};
     QTest::newRow("defaulted-dtor")
         << "struct Foo {\n"
            "  Foo();\n"
            "  ~Foo() =default;\n"
            "};\n"
         << CompletionItems{{5,1}, {"Foo::Foo()"}};
 
     QTest::newRow("bug355163")
         << R"(
                 #include <type_traits>
                 namespace test {
 
                 template<typename T, typename U>
                 struct IsSafeConversion : public std::is_same<T, typename std::common_type<T, U>::type>
                 {
 
                 };
 
                 } // namespace test
             )"
         << CompletionItems{{7,0}, {}};
 
     QTest::newRow("bug355954")
         << R"(
                 struct Hello {
                     struct Private;
                 };
 
                 struct Hello::Private {
                     void test();
                 };
             )"
         << CompletionItems{{8,0}, {"Hello::Private::test()"}};
 
     QTest::newRow("lineOfNextFunction")
         << "void foo();\nvoid bar() {}"
         << CompletionItems{{1,0}, {"foo()"}};
 
     QTest::newRow("pure")
         << R"(
                 struct Hello {
                     virtual void foo() = 0;
                     virtual void bar();
                 };
             )"
         << CompletionItems{{5, 0}, {"Hello::bar()"}};
 
     QTest::newRow("bug368544")
         << R"(
                 class Klass {
                 public:
                     template <typename T>
                     void func(int a, T x, int b) const;
                 };
             )"
         << CompletionItems{{6, 0}, {"Klass::func(int a, T x, int b) const"}};
 
 }
 
 void TestCodeCompletion::testImplementOtherFile()
 {
     TestFile header1(QStringLiteral("void foo();"), QStringLiteral("h"));
     QVERIFY(header1.parseAndWait());
     TestFile header2(QStringLiteral("void bar();"), QStringLiteral("h"));
     QVERIFY(header2.parseAndWait());
     TestFile impl(QString("#include \"%1\"\n"
                           "#include \"%2\"\n"
                           "void asdf();\n\n")
-                    .arg(header1.url().str())
-                    .arg(header2.url().str()),
+                    .arg(header1.url().str(), header2.url().str()),
                   QStringLiteral("cpp"), &header1);
 
     CompletionItems expectedItems{{3,1}, {"asdf()", "foo()"}};
     QVERIFY(impl.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     executeCompletionTest(impl.topContext(), expectedItems);
 }
 
 void TestCodeCompletion::testImplementAfterEdit()
 {
     TestFile header1(QStringLiteral("void foo();"), QStringLiteral("h"));
     QVERIFY(header1.parseAndWait());
     TestFile impl(QString("#include \"%1\"\n"
                           "void asdf() {}\nvoid bar() {}")
                     .arg(header1.url().str()),
                   QStringLiteral("cpp"), &header1);
 
     auto document = ICore::self()->documentController()->openDocument(impl.url().toUrl());
 
     QVERIFY(impl.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
 
     CompletionItems expectedItems{{2,0}, {"foo()"}};
     executeCompletionTest(impl.topContext(), expectedItems);
 
     document->textDocument()->insertText(expectedItems.position, QStringLiteral("\n"));
     expectedItems.position.setLine(3);
 
     executeCompletionTest(impl.topContext(), expectedItems);
 
     document->close(IDocument::Discard);
 }
 
 void TestCodeCompletion::testInvalidCompletions()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeCompletionTest(code, expectedItems);
 }
 
 void TestCodeCompletion::testInvalidCompletions_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("invalid-context-incomment")
         << "class Foo { int bar() const; };\n/*\n*/"
         << CompletionItems{{2, 0}, {}};
 }
 
 void TestCodeCompletion::testIncludePathCompletion_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<KTextEditor::Cursor>("cursor");
     QTest::addColumn<QString>("itemId");
     QTest::addColumn<QString>("result");
 
     QTest::newRow("global-1") << QStringLiteral("#include ") << KTextEditor::Cursor(0, 9)
                               << QStringLiteral("iostream") << QStringLiteral("#include <iostream>");
     QTest::newRow("global-2") << QStringLiteral("#include <") << KTextEditor::Cursor(0, 9)
                               << QStringLiteral("iostream") << QStringLiteral("#include <iostream>");
     QTest::newRow("global-3") << QStringLiteral("#include <") << KTextEditor::Cursor(0, 10)
                               << QStringLiteral("iostream") << QStringLiteral("#include <iostream>");
     QTest::newRow("global-4") << QStringLiteral("#  include <") << KTextEditor::Cursor(0, 12)
                               << QStringLiteral("iostream") << QStringLiteral("#  include <iostream>");
     QTest::newRow("global-5") << QStringLiteral("#  include   <") << KTextEditor::Cursor(0, 14)
                               << QStringLiteral("iostream") << QStringLiteral("#  include   <iostream>");
     QTest::newRow("global-6") << QStringLiteral("#  include   <> /* 1 */") << KTextEditor::Cursor(0, 14)
                               << QStringLiteral("iostream") << QStringLiteral("#  include   <iostream> /* 1 */");
     QTest::newRow("global-7") << QStringLiteral("#  include /* 1 */ <> /* 1 */") << KTextEditor::Cursor(0, 21)
                               << QStringLiteral("iostream") << QStringLiteral("#  include /* 1 */ <iostream> /* 1 */");
     QTest::newRow("global-8") << QStringLiteral("# /* 1 */ include /* 1 */ <> /* 1 */") << KTextEditor::Cursor(0, 28)
                               << QStringLiteral("iostream") << QStringLiteral("# /* 1 */ include /* 1 */ <iostream> /* 1 */");
     QTest::newRow("global-9") << QStringLiteral("#include <cstdint>") << KTextEditor::Cursor(0, 10)
                               << QStringLiteral("iostream") << QStringLiteral("#include <iostream>");
     QTest::newRow("global-10") << QStringLiteral("#include <cstdint>") << KTextEditor::Cursor(0, 14)
                               << QStringLiteral("cstdint") << QStringLiteral("#include <cstdint>");
     QTest::newRow("global-11") << QStringLiteral("#include <cstdint>") << KTextEditor::Cursor(0, 17)
                               << QStringLiteral("cstdint") << QStringLiteral("#include <cstdint>");
     QTest::newRow("local-0") << QStringLiteral("#include \"") << KTextEditor::Cursor(0, 10)
                               << QStringLiteral("foo/") << QStringLiteral("#include \"foo/\"");
     QTest::newRow("local-1") << QStringLiteral("#include \"foo/\"") << KTextEditor::Cursor(0, 14)
                               << QStringLiteral("bar/") << QStringLiteral("#include \"foo/bar/\"");
     QTest::newRow("local-2") << QStringLiteral("#include \"foo/") << KTextEditor::Cursor(0, 14)
                               << QStringLiteral("bar/") << QStringLiteral("#include \"foo/bar/\"");
     QTest::newRow("local-3") << QStringLiteral("# /* 1 */ include /* 1 */ \"\" /* 1 */") << KTextEditor::Cursor(0, 28)
                               << QStringLiteral("foo/") << QStringLiteral("# /* 1 */ include /* 1 */ \"foo/\" /* 1 */");
     QTest::newRow("local-4") << QStringLiteral("# /* 1 */ include /* 1 */ \"foo/\" /* 1 */") << KTextEditor::Cursor(0, 31)
                               << QStringLiteral("bar/") << QStringLiteral("# /* 1 */ include /* 1 */ \"foo/bar/\" /* 1 */");
     QTest::newRow("local-5") << QStringLiteral("#include \"foo/\"") << KTextEditor::Cursor(0, 10)
                               << QStringLiteral("foo/") << QStringLiteral("#include \"foo/\"");
     QTest::newRow("local-6") << QStringLiteral("#include \"foo/asdf\"") << KTextEditor::Cursor(0, 10)
                               << QStringLiteral("foo/") << QStringLiteral("#include \"foo/\"");
     QTest::newRow("local-7") << QStringLiteral("#include \"foo/asdf\"") << KTextEditor::Cursor(0, 14)
                               << QStringLiteral("bar/") << QStringLiteral("#include \"foo/bar/\"");
     QTest::newRow("dash-1") << QStringLiteral("#include \"") << KTextEditor::Cursor(0, 10)
                               << QStringLiteral("dash-file.h") << QStringLiteral("#include \"dash-file.h\"");
     QTest::newRow("dash-2") << QStringLiteral("#include \"dash-") << KTextEditor::Cursor(0, 15)
                               << QStringLiteral("dash-file.h") << QStringLiteral("#include \"dash-file.h\"");
     QTest::newRow("dash-4") << QStringLiteral("#include \"dash-file.h\"") << KTextEditor::Cursor(0, 13)
                               << QStringLiteral("dash-file.h") << QStringLiteral("#include \"dash-file.h\"");
     QTest::newRow("dash-5") << QStringLiteral("#include \"dash-file.h\"") << KTextEditor::Cursor(0, 14)
                               << QStringLiteral("dash-file.h") << QStringLiteral("#include \"dash-file.h\"");
     QTest::newRow("dash-6") << QStringLiteral("#include \"dash-file.h\"") << KTextEditor::Cursor(0, 15)
                               << QStringLiteral("dash-file.h") << QStringLiteral("#include \"dash-file.h\"");
 }
 
 void TestCodeCompletion::testIncludePathCompletion()
 {
     QFETCH(QString, code);
     QFETCH(KTextEditor::Cursor, cursor);
     QFETCH(QString, itemId);
     QFETCH(QString, result);
 
     QTemporaryDir tempDir;
     QDir dir(tempDir.path());
     QVERIFY(dir.mkpath("foo/bar/asdf"));
     TestFile file(code, QStringLiteral("cpp"), nullptr, tempDir.path());
     {
         QFile otherFile(tempDir.path() + "/dash-file.h");
         QVERIFY(otherFile.open(QIODevice::WriteOnly));
     }
     IncludeTester tester(executeIncludePathCompletion(&file, cursor));
     QVERIFY(tester.completionContext);
     QVERIFY(tester.completionContext->isValid());
 
     auto item = tester.findItem(itemId);
     QVERIFY(item);
 
     auto view = createView(file.url().toUrl(), this);
     QVERIFY(view.get());
     auto doc = view->document();
     item->execute(view.get(), KTextEditor::Range(cursor, cursor));
     QCOMPARE(doc->text(), result);
 
     const auto newCursor = view->cursorPosition();
     QCOMPARE(newCursor.line(), cursor.line());
     if (!itemId.endsWith('/')) {
         // file inserted, cursor should be at end of line
         QCOMPARE(newCursor.column(), doc->lineLength(cursor.line()));
     } else {
         // directory inserted, cursor should be before the " or >
         const auto cursorChar = doc->characterAt(newCursor);
         QVERIFY(cursorChar == '"' || cursorChar == '>');
     }
 }
 
 void TestCodeCompletion::testIncludePathCompletionLocal()
 {
     TestFile header(QStringLiteral("int foo() { return 42; }\n"), QStringLiteral("h"));
     TestFile impl(QStringLiteral("#include \""), QStringLiteral("cpp"), &header);
 
     IncludeTester tester(executeIncludePathCompletion(&impl, {0, 10}));
     QVERIFY(tester.names.contains(header.url().toUrl().fileName()));
     QVERIFY(tester.names.contains("iostream"));
 }
 
 void TestCodeCompletion::testOverloadedFunctions()
 {
     TestFile file(QStringLiteral("void f(); int f(int); void f(int, double){\n "), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
 
     lock.unlock();
 
     const auto context = createContext(top, sessionData, {1, 0});
     context->setFilters(NoMacroOrBuiltin);
     lock.lock();
     const auto tester = ClangCodeCompletionItemTester(context);
     QCOMPARE(tester.items.size(), 3);
     for (const auto& item : tester.items) {
         auto function = item->declaration()->type<FunctionType>();
         const QString display = item->declaration()->identifier().toString() + function->partToString(FunctionType::SignatureArguments);
         const QString itemDisplay = tester.itemData(item).toString() + tester.itemData(item, KTextEditor:: CodeCompletionModel::Arguments).toString();
         QCOMPARE(display, itemDisplay);
     }
 
     QVERIFY(tester.items[0]->declaration().data() != tester.items[1]->declaration().data());
     QVERIFY(tester.items[0]->declaration().data() != tester.items[2]->declaration().data());
     QVERIFY(tester.items[1]->declaration().data() != tester.items[2]->declaration().data());
 }
 
 void TestCodeCompletion::testCompletionPriority()
 {
     QFETCH(QString, code);
     QFETCH(CompletionPriorityItems, expectedItems);
 
     executeCompletionPriorityTest(code, expectedItems);
 }
 
 void TestCodeCompletion::testCompletionPriority_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionPriorityItems>("expectedItems");
 
     QTest::newRow("pointer")
         << "class A{}; class B{}; class C : public B{}; int main(){A* a; B* b; C* c; b =\n "
         << CompletionPriorityItems{{1,0}, {{"a", 0, 21}, {"b", 9, 0},
         {"c", 8, 0, QStringLiteral("Pointer to derived class is not added to the Best Matches group")}}};
 
     QTest::newRow("class")
         << "class A{}; class B{}; class C : public B{}; int main(){A a; B b; C c; b =\n "
         << CompletionPriorityItems{{1,0}, {{"a", 0, 21}, {"b", 9, 0},
         {"c", 8, 0, QStringLiteral("Derived class is not added to the Best Matches group")}}};
 
     QTest::newRow("primary-types")
         << "class A{}; int main(){A a; int b; bool c = \n "
         << CompletionPriorityItems{{1,0}, {{"a", 0, 34}, {"b", 8, 0}, {"c", 9, 0}}};
 
     QTest::newRow("reference")
         << "class A{}; class B{}; class C : public B{};"
            "int main(){A tmp; A& a = tmp; C tmp2; C& c = tmp2; B& b =\n ;}"
         << CompletionPriorityItems{{1,0}, {{"a", 0, 21}, {"b", 9, 0},
         {"c", 8, 0, QStringLiteral("Reference to derived class is not added to the Best Matches group")}}};
 
     QTest::newRow("typedef")
         << "struct A{}; struct B{}; typedef A AA; typedef B BB; void f(A p);"
            "int main(){ BB b; AA a; f(\n }"
         << CompletionPriorityItems{{1,0}, {{"a", 9, 0}, {"b", 0, 21}}};
 
     QTest::newRow("returnType")
         << "struct A{}; struct B{}; struct Test{A f();B g(); Test() { A a =\n }};"
         << CompletionPriorityItems{{1,0}, {{"f", 9, 0}, {"g", 0, 21}}};
 
     QTest::newRow("template")
         << "template <typename T> class Class{}; template <typename T> class Class2{};"
            "int main(){ Class<int> a; Class2<int> b =\n }"
         << CompletionPriorityItems{{1,0}, {{"b", 9, 0}, {"a", 0, 21}}};
 
     QTest::newRow("protected-access")
         << "class Base { protected: int m_protected; };"
            "class Derived: public Base {public: void g(){\n }};"
         << CompletionPriorityItems{{1,0}, {{"m_protected", 0, 37}}};
 
     QTest::newRow("protected-access2")
         << "class Base { protected: int m_protected; };"
            "class Derived: public Base {public: void f();};"
            "void Derived::f(){\n }"
         << CompletionPriorityItems{{1,0}, {{"m_protected", 0, 37}}};
 }
 
 void TestCodeCompletion::testVariableScope()
 {
     TestFile file(QStringLiteral("int var; \nvoid test(int var) {int tmp =\n }"), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
 
     lock.unlock();
 
     const auto context = createContext(top, sessionData, {2, 0});
     context->setFilters(NoMacroOrBuiltin);
     lock.lock();
     const auto tester = ClangCodeCompletionItemTester(context);
 
     QCOMPARE(tester.items.size(), 4);
     auto item = tester.findItem(QStringLiteral("var"));
     VERIFY(item);
     QCOMPARE(item->declaration()->range().start, CursorInRevision(1, 14));
 }
 
 struct HintItem
 {
     QString hint;
     bool hasDeclaration;
     bool operator==(const HintItem& rhs) const
     {
         return std::tie(hint, hasDeclaration) == std::tie(rhs.hint, rhs.hasDeclaration);
     }
     bool operator<(const HintItem& rhs) const
     {
         return std::tie(hint, hasDeclaration) < std::tie(rhs.hint, rhs.hasDeclaration);
     }
     QByteArray toString() const
     {
         return "HintItem(" + hint.toUtf8() + ", " + (hasDeclaration ? "true" : "false") + ')';
     }
 };
 Q_DECLARE_METATYPE(HintItem)
 using HintItemList = QVector<HintItem>;
 namespace QTest {
 template<>
 char *toString(const HintItem& hint)
 {
     return qstrdup(hint.toString());
 }
 template<>
 char *toString(const HintItemList& hints)
 {
     QByteArray ba = "HintItemList(";
     for (int i = 0, c = hints.size(); i < c; ++i) {
         ba += hints[i].toString();
         if (i == c - 1) {
             ba += ')';
         } else {
             ba += ", ";
         }
     }
     return qstrdup(ba.constData());
 }
 }
 
 void TestCodeCompletion::testArgumentHintCompletion()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
     QFETCH(HintItemList, hints);
 
     executeCompletionTest(code, expectedItems, NoMacroOrBuiltin, [&](const ClangCodeCompletionItemTester& tester) {
         HintItemList actualHints;
         for (const auto& item : tester.items) {
             if (item->argumentHintDepth() == 1) {
                 actualHints << HintItem{
                     tester.itemData(item).toString() + tester.itemData(item, KTextEditor:: CodeCompletionModel::Arguments).toString(),
                     item->declaration()
                 };
             }
         }
         std::sort(hints.begin(), hints.end());
         std::sort(actualHints.begin(), actualHints.end());
         QEXPECT_FAIL("member function", "clang_getCompletionParent returns nothing, thus decl lookup fails", Continue);
         QEXPECT_FAIL("namespaced function", "clang_getCompletionParent returns nothing, thus decl lookup fails", Continue);
         QEXPECT_FAIL("namespaced constructor", "clang_getCompletionParent returns nothing, thus decl lookup fails", Continue);
         QCOMPARE(actualHints, hints);
     });
 }
 
 void TestCodeCompletion::testArgumentHintCompletion_data()
 {
 #if CINDEX_VERSION_MINOR < 30
     QSKIP("You need at least LibClang 3.7");
 #endif
     qRegisterMetaType<HintItemList>("HintItemList");
 
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
     QTest::addColumn<HintItemList>("hints");
 
     QTest::newRow("global function")
         << "void foo(int);\n"
            "int main() { \nfoo( "
         << CompletionItems{{2,4}, {
             "foo", "foo",
             "main"
         }}
         << HintItemList{{"foo(int)", true}};
 
     QTest::newRow("namespaced function")
         << "namespace ns { void foo(int); }\n"
            "int main() { \nns::foo( "
         << CompletionItems{{2,4}, {
             "foo"
         }}
         << HintItemList{{"foo(int)", true}};
 
     QTest::newRow("member function")
         << "struct Struct{ void foo(int);}\n"
            "int main() {Struct s; \ns.foo( "
         << CompletionItems{{2,6}, {
             "Struct", "foo",
             "main", "s"
         }}
         << HintItemList{{"foo(int)", true}};
 
     QTest::newRow("template function")
         << "template <typename T> void foo(T);\n"
            "int main() { \nfoo( "
         << CompletionItems{{2,6}, {
             "foo", "foo",
             "main"
         }}
         << HintItemList{{"foo(T)", true}};
 
     QTest::newRow("overloaded functions")
         << "void foo(int); void foo(int, double)\n"
            "int main() { \nfoo( "
         << CompletionItems{{2,6}, {
             "foo", "foo", "foo", "foo",
             "main"
         }}
         << HintItemList{
             {"foo(int)", true},
             {"foo(int, double)", true}
         };
 
     QTest::newRow("overloaded functions2")
         << "void foo(int); void foo(int, double)\n"
            "int main() { foo(1,\n  "
         << CompletionItems{{2,1}, {
             "foo", "foo", "foo",
             "main"
         }}
         << HintItemList{{"foo(int, double)", true}};
 
     QTest::newRow("constructor")
         << "struct foo { foo(int); foo(int, double); }\n"
            "int main() { foo f(\n "
         << CompletionItems{{2,1}, {
             "f", "foo", "foo", "foo", "foo", "foo",
             "main"
         }}
         << HintItemList{
             {"foo(int)", true},
             {"foo(int, double)", true},
             {"foo(foo &&)", false},
             {"foo(const foo &)", false}
         };
 
     QTest::newRow("constructor2")
         << "struct foo { foo(int); foo(int, double); }\n"
            "int main() { foo f(1,\n "
         << CompletionItems{{2,1}, {
             "f", "foo", "foo",
             "main"
         }}
         << HintItemList{
             {"foo(int, double)", true}
         };
 
     QTest::newRow("namespaced constructor")
         << "namespace ns { struct foo { foo(int); foo(int, double); } }\n"
            "int main() { ns::foo f(\n "
         << CompletionItems{{2,1}, {
             "f", "foo", "foo", "foo", "foo",
             "main", "ns"
         }}
         << HintItemList{
             {"foo(int)", true},
             {"foo(int, double)", true},
             {"foo(ns::foo &&)", false},
             {"foo(const ns::foo &)", false}
         };
 }
 
 void TestCodeCompletion::testArgumentHintCompletionDefaultParameters()
 {
 #if CINDEX_VERSION_MINOR < 30
     QSKIP("You need at least LibClang 3.7");
 #endif
 
     TestFile file(QStringLiteral("void f(int i, int j = 0, double k =1){\nf( "), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
 
     lock.unlock();
 
     const auto context = createContext(top, sessionData, {1, 2});
     context->setFilters(NoMacroOrBuiltin);
     lock.lock();
     const auto tester = ClangCodeCompletionItemTester(context);
     QExplicitlySharedDataPointer<KDevelop::CompletionTreeItem> f;
 
     for (const auto& item : tester.items) {
         if (item->argumentHintDepth() == 1) {
             f = item;
             break;
         }
     }
 
     QVERIFY(f.data());
 
     const QString itemDisplay = tester.itemData(f).toString() + tester.itemData(f, KTextEditor:: CodeCompletionModel::Arguments).toString();
     QCOMPARE(itemDisplay, QStringLiteral("f(int i, int j = 0, double k = 1)"));
 }
 
 void TestCodeCompletion::testCompleteFunction()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
     QFETCH(QString, itemToExecute);
     QFETCH(QString, expectedCode);
 
     auto executeItem = [=] (const ClangCodeCompletionItemTester& tester) {
         auto item = tester.findItem(itemToExecute);
         QVERIFY(item);
         auto view = createView(tester.completionContext->duContext()->url().toUrl(), this);
         item->execute(view.get(), view->document()->wordRangeAt(expectedItems.position));
         QCOMPARE(view->document()->text(), expectedCode);
     };
     executeCompletionTest(code, expectedItems, NoMacroOrBuiltin, executeItem);
 }
 
 void TestCodeCompletion::testCompleteFunction_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
     QTest::addColumn<QString>("itemToExecute");
     QTest::addColumn<QString>("expectedCode");
 
     QTest::newRow("add-parens")
         << "int foo();\nint main() {\n\n}"
         << CompletionItems({2, 0}, {"foo", "main"})
         << "foo"
         << "int foo();\nint main() {\nfoo()\n}";
 
     QTest::newRow("keep-parens")
         << "int foo();\nint main() {\nfoo();\n}"
         << CompletionItems({2, 0}, {"foo", "main"})
         << "main"
         << "int foo();\nint main() {\nmain();\n}";
 
     QTest::newRow("bug375635")
         << "enum class Color {\nBlue, Green, Red, Yellow\n};\nvoid foo() {\nColor x;\nswitch (x) {\ncase : break;}\n}"
         << CompletionItems({6, 5}, {"Blue", "Green", "Red", "Yellow"})
         << "Yellow"
         << "enum class Color {\nBlue, Green, Red, Yellow\n};\nvoid foo() {\nColor x;\nswitch (x) {\ncase Color::Yellow: break;}\n}";
 
     QTest::newRow("bug368544")
         << "class Klass {\npublic:\ntemplate <typename T>\nvoid func(int a, T x, int b) const;\n};\n"
         << CompletionItems({5, 0}, {"Klass", "Klass::func(int a, T x, int b) const"})
         << "Klass::func(int a, T x, int b) const"
         << "class Klass {\npublic:\ntemplate <typename T>\nvoid func(int a, T x, int b) const;\n};\ntemplate<typename T> void Klass::func(int a, T x, int b) const\n{\n}\n";
 
     QTest::newRow("bug377397")
         << "template<typename T> class Foo {\nvoid bar();\n};\n"
         << CompletionItems({3, 0}, {"Foo", "Foo<T>::bar()"})
         << "Foo<T>::bar()"
         << "template<typename T> class Foo {\nvoid bar();\n};\ntemplate<typename T> void Foo<T>::bar()\n{\n}\n";
 
     QTest::newRow("template-template-parameter")
         << "template <template<class, int> class X, typename B>\nclass Test {\npublic:\nvoid bar(B a);\n};\n"
         << CompletionItems({5, 0}, {"Test", "Test<X, B>::bar(B a)"})
         << "Test<X, B>::bar(B a)"
         << "template <template<class, int> class X, typename B>\nclass Test {\npublic:\nvoid bar(B a);\n};\ntemplate<template<typename, int> class X, typename B> void Test<X, B>::bar(B a)\n{\n}\n";
 }
 
 void TestCodeCompletion::testIgnoreGccBuiltins()
 {
     // TODO: make it easier to change the compiler provider for testing purposes
     QTemporaryDir dir;
     auto project = new TestProject(Path(dir.path()), this);
     auto definesAndIncludesConfig = project->projectConfiguration()->group("CustomDefinesAndIncludes");
     auto pathConfig = definesAndIncludesConfig.group("ProjectPath0");
     pathConfig.writeEntry("Path", ".");
     pathConfig.group("Compiler").writeEntry("Name", "GCC");
     m_projectController->addProject(project);
 
     {
         TestFile file(QString(), QStringLiteral("cpp"), project, dir.path());
 
         QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
 
         executeCompletionTest(file.topContext(), {});
     }
 }
diff --git a/plugins/debuggercommon/tests/testhelper.cpp b/plugins/debuggercommon/tests/testhelper.cpp
index dcd41e9f59..7621180a9d 100644
--- a/plugins/debuggercommon/tests/testhelper.cpp
+++ b/plugins/debuggercommon/tests/testhelper.cpp
@@ -1,174 +1,174 @@
 /*
  * Common helpers for MI debugger unit tests
  * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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 "testhelper.h"
 
 #include "debuggers-tests-config.h"
 #include "midebugsession.h"
 
 #include <QApplication>
 #include <QDebug>
 #include <QDir>
 #include <QFileInfo>
 #include <QRegularExpression>
 #include <QTest>
 
 namespace KDevMI {
 
 QUrl findExecutable(const QString& name)
 {
     QString exeExtension;
 #ifdef Q_OS_WIN
     exeExtension = QStringLiteral(".exe");
 #endif
     QFileInfo info(QString::fromLocal8Bit(DEBUGGEE_BIN_DIR), name + exeExtension);
     Q_ASSERT_X(info.exists(), "findExecutable", info.filePath().toLocal8Bit());
     Q_ASSERT(info.isExecutable());
     return QUrl::fromLocalFile(info.canonicalFilePath());
 }
 
 QString findSourceFile(const QString& name)
 {
     return findFile(DEBUGGEE_SRC_DIR, name);
 }
 
 QString findFile(const char* dir, const QString& name)
 {
     QFileInfo info(QString::fromLocal8Bit(dir), name);
     Q_ASSERT_X(info.exists(), "findFile", info.filePath().toLocal8Bit());
 
     return info.canonicalFilePath();
 }
 
 bool isAttachForbidden(const char *file, int line)
 {
     // if on linux, ensure we can actually attach
     QFile canRun(QStringLiteral("/proc/sys/kernel/yama/ptrace_scope"));
     if (canRun.exists()) {
         if (!canRun.open(QIODevice::ReadOnly)) {
             QTest::qFail("Something is wrong: /proc/sys/kernel/yama/ptrace_scope exists but cannot be read", file, line);
             return true;
         }
         if (canRun.read(1).toInt() != 0) {
             QTest::qSkip("ptrace attaching not allowed, skipping test. To enable it, set /proc/sys/kernel/yama/ptrace_scope to 0.", file, line);
             return true;
         }
     }
 
     return false;
 }
 
 bool compareData(const QModelIndex& index, const QString& expected, const char *file, int line, bool useRE)
 {
     QString s = index.model()->data(index, Qt::DisplayRole).toString();
     bool matched = true;
     if (useRE) {
         QRegularExpression re(expected);
         matched = re.match(s).hasMatch();
     } else {
         matched = s == expected;
     }
     return QTest::qVerify(matched, "Comparsion of data", qPrintable(QString("'%0' didn't match expected '%1' in %2:%3")
-                                       .arg(s).arg(expected).arg(file).arg(line)),
+                                       .arg(s, expected, file).arg(line)),
                           file, line);
 }
 
 bool waitForAWhile(MIDebugSession *session, int ms, const char *file, int line)
 {
     QPointer<MIDebugSession> s(session); //session can get deleted in DebugController
     QTest::qWait(ms);
     if (!s) {
         QTest::qFail("Session ended while waiting", file, line);
         return false;
     }
     return true;
 }
 
 bool waitForState(MIDebugSession *session, KDevelop::IDebugSession::DebuggerState state,
                   const char *file, int line, bool waitForIdle)
 {
     QPointer<MIDebugSession> s(session); //session can get deleted in DebugController
     QTime stopWatch;
     stopWatch.start();
 
     // legacy behavior for tests that implicitly may require waiting for idle,
     // but which were written before waitForIdle was added
     waitForIdle = waitForIdle || state != MIDebugSession::EndedState;
 
     while (s && (s->state() != state
                 || (waitForIdle && s->debuggerStateIsOn(s_dbgBusy)))) {
         if (stopWatch.elapsed() > 10000) {
             qWarning() << "current state" << s->state() << "waiting for" << state;
             QTest::qFail(qPrintable(QString("Timeout before reaching state %0").arg(state)),
                          file, line);
             return false;
         }
         QTest::qWait(20);
     }
 
     // NOTE: don't wait anymore after leaving the loop. Waiting reenters event loop and
     // may change session state.
 
     if (!s && state != MIDebugSession::EndedState) {
         QTest::qFail(qPrintable(QString("Session ended before reaching state %0").arg(state)),
                         file, line);
         return false;
     }
 
     qDebug() << "Reached state " << state << " in " << file << ':' << line;
     return true;
 }
 
 TestWaiter::TestWaiter(MIDebugSession * session_, const char * condition_, const char * file_, int line_)
     : session(session_)
     , condition(condition_)
     , file(file_)
     , line(line_)
 {
     stopWatch.start();
 }
 
 bool TestWaiter::waitUnless(bool ok)
 {
     if (ok) {
         qDebug() << "Condition " << condition << " reached in " << file << ':' << line;
         return false;
     }
 
     if (stopWatch.elapsed() > 5000) {
         QTest::qFail(qPrintable(QString("Timeout before reaching condition %0").arg(condition)),
             file, line);
         return false;
     }
 
     QTest::qWait(100);
 
     if (!session) {
         QTest::qFail(qPrintable(QString("Session ended without reaching condition %0").arg(condition)),
             file, line);
         return false;
     }
 
     return true;
 }
 
 } // end of namespace KDevMI
diff --git a/plugins/gdb/unittests/test_gdb.cpp b/plugins/gdb/unittests/test_gdb.cpp
index a18d86c6ba..d83b8575be 100644
--- a/plugins/gdb/unittests/test_gdb.cpp
+++ b/plugins/gdb/unittests/test_gdb.cpp
@@ -1,2121 +1,2121 @@
 /*
    Copyright 2009 Niko Sams <niko.sams@gmail.com>
    Copyright 2013 Vlas Puhov <vlas.puhov@mail.ru>
 
    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.
 */
 
 #include "test_gdb.h"
 
 #include "debugsession.h"
 #include "gdbframestackmodel.h"
 #include "mi/micommand.h"
 #include "mi/milexer.h"
 #include "mi/miparser.h"
 #include "tests/debuggers-tests-config.h"
 #include "tests/testhelper.h"
 
 #include <execute/iexecuteplugin.h>
 #include <debugger/breakpoint/breakpoint.h>
 #include <debugger/breakpoint/breakpointmodel.h>
 #include <debugger/framestack/framestackmodel.h>
 #include <debugger/interfaces/ivariablecontroller.h>
 #include <debugger/variable/variablecollection.h>
 #include <interfaces/idebugcontroller.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <interfaces/iplugincontroller.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <shell/shellextension.h>
 #include <util/environmentprofilelist.h>
 
 #include <KIO/Global>
 #include <KProcess>
 #include <KSharedConfig>
 #include <KShell>
 
 #include <QApplication>
 #include <QDebug>
 #include <QDir>
 #include <QFileInfo>
 #include <QStandardPaths>
 #include <QSignalSpy>
 #include <QTest>
 #include <QTemporaryFile>
 
 #define SKIP_IF_ATTACH_FORBIDDEN() \
     do { \
         if (KDevMI::isAttachForbidden(__FILE__, __LINE__)) \
             return; \
     } while(0)
 
 using KDevelop::AutoTestShell;
 using KDevMI::findExecutable;
 using KDevMI::findSourceFile;
 using KDevMI::findFile;
 
 namespace KDevMI { namespace GDB {
 
 void GdbTest::initTestCase()
 {
     AutoTestShell::init();
     KDevelop::TestCore::initialize(KDevelop::Core::NoUi);
 
     m_iface = KDevelop::ICore::self()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IExecutePlugin"), QStringLiteral("kdevexecute"))->extension<IExecutePlugin>();
     Q_ASSERT(m_iface);
 }
 
 void GdbTest::cleanupTestCase()
 {
     KDevelop::TestCore::shutdown();
 }
 
 void GdbTest::init()
 {
     //remove all breakpoints - so we can set our own in the test
     KConfigGroup breakpoints = KSharedConfig::openConfig()->group("breakpoints");
     breakpoints.writeEntry("number", 0);
     breakpoints.sync();
 
     KDevelop::BreakpointModel* m = KDevelop::ICore::self()->debugController()->breakpointModel();
     m->removeRows(0, m->rowCount());
 
     KDevelop::VariableCollection *vc = KDevelop::ICore::self()->debugController()->variableCollection();
     for (int i=0; i < vc->watches()->childCount(); ++i) {
         delete vc->watches()->child(i);
     }
     vc->watches()->clear();
 }
 
 class WritableEnvironmentProfileList : public KDevelop::EnvironmentProfileList
 {
 public:
     explicit WritableEnvironmentProfileList(KConfig* config) : EnvironmentProfileList(config) {}
 
     using EnvironmentProfileList::variables;
     using EnvironmentProfileList::saveSettings;
     using EnvironmentProfileList::removeProfile;
 };
 
 class TestLaunchConfiguration : public KDevelop::ILaunchConfiguration
 {
 public:
     explicit TestLaunchConfiguration(const QUrl& executable = findExecutable(QStringLiteral("debuggee_debugee")),
                             const QUrl& workingDirectory = QUrl()) {
         qDebug() << "FIND" << executable;
         c = KSharedConfig::openConfig();
         c->deleteGroup("launch");
         cfg = c->group("launch");
         cfg.writeEntry("isExecutable", true);
         cfg.writeEntry("Executable", executable);
         cfg.writeEntry("Working Directory", workingDirectory);
     }
     const KConfigGroup config() const override { return cfg; }
     KConfigGroup config() override { return cfg; };
     QString name() const override { return QStringLiteral("Test-Launch"); }
     KDevelop::IProject* project() const override { return nullptr; }
     KDevelop::LaunchConfigurationType* type() const override { return nullptr; }
 
     KConfig* rootConfig() { return c.data(); }
 private:
     KConfigGroup cfg;
     KSharedConfigPtr c;
 };
 
 class TestFrameStackModel : public GdbFrameStackModel
 {
 public:
 
     explicit TestFrameStackModel(DebugSession* session)
         : GdbFrameStackModel(session), fetchFramesCalled(0), fetchThreadsCalled(0) {}
 
     int fetchFramesCalled;
     int fetchThreadsCalled;
     void fetchFrames(int threadNumber, int from, int to) override
     {
         fetchFramesCalled++;
         GdbFrameStackModel::fetchFrames(threadNumber, from, to);
     }
 
     void fetchThreads() override
     {
         fetchThreadsCalled++;
         GdbFrameStackModel::fetchThreads();
     }
 };
 
 class TestDebugSession : public DebugSession
 {
     Q_OBJECT
 public:
     TestDebugSession() : DebugSession()
     {
         setSourceInitFile(false);
         setAutoDisableASLR(false);
         m_frameStackModel = new TestFrameStackModel(this);
         KDevelop::ICore::self()->debugController()->addSession(this);
     }
 
     QUrl url() { return currentUrl(); }
     int line() { return currentLine(); }
 
     TestFrameStackModel* frameStackModel() const override
     {
         return m_frameStackModel;
     }
 
 private:
     TestFrameStackModel* m_frameStackModel;
 };
 
 class TestWaiter
 {
 public:
     TestWaiter(DebugSession * session_, const char * condition_, const char * file_, int line_)
         : session(session_)
         , condition(condition_)
         , file(file_)
         , line(line_)
     {
         stopWatch.start();
     }
 
     bool waitUnless(bool ok)
     {
         if (ok) {
             qDebug() << "Condition " << condition << " reached in " << file << ':' << line;
             return false;
         }
 
         if (stopWatch.elapsed() > 5000) {
             QTest::qFail(qPrintable(QString("Timeout before reaching condition %0").arg(condition)),
                 file, line);
             return false;
         }
 
         QTest::qWait(100);
 
         if (!session) {
             QTest::qFail(qPrintable(QString("Session ended without reaching condition %0").arg(condition)),
                 file, line);
             return false;
         }
 
         return true;
     }
 
 private:
     QTime stopWatch;
     QPointer<DebugSession> session;
     const char * condition;
     const char * file;
     int line;
 };
 
 #define WAIT_FOR_STATE(session, state) \
     do { if (!waitForState((session), (state), __FILE__, __LINE__)) return; } while (0)
 
 #define WAIT_FOR_STATE_AND_IDLE(session, state) \
     do { if (!waitForState((session), (state), __FILE__, __LINE__, true)) return; } while (0)
 
 #define WAIT_FOR(session, condition) \
     do { \
         TestWaiter w((session), #condition, __FILE__, __LINE__); \
         while (w.waitUnless((condition))) /* nothing */ ; \
     } while(0)
 
 #define COMPARE_DATA(index, expected) \
     do { if(!compareData((index), (expected), __FILE__, __LINE__)) return; } while (0)
 
 bool compareData(const QModelIndex& index, const QString& expected, const char *file, int line)
 {
     QString s = index.model()->data(index, Qt::DisplayRole).toString();
     if (s != expected) {
         QTest::qFail(qPrintable(QString("'%0' didn't match expected '%1' in %2:%3")
-                                .arg(s).arg(expected).arg(file).arg(line)),
+                                .arg(s, expected, file).arg(line)),
                      file, line);
         return false;
     }
     return true;
 }
 
 static const QString debugeeFileName = findSourceFile(QStringLiteral("debugee.cpp"));
 
 KDevelop::BreakpointModel* breakpoints()
 {
     return KDevelop::ICore::self()->debugController()->breakpointModel();
 }
 
 void GdbTest::testStdOut()
 {
     TestDebugSession *session = new TestDebugSession;
 
     QSignalSpy outputSpy(session, &TestDebugSession::inferiorStdoutLines);
 
     TestLaunchConfiguration cfg;
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, KDevelop::IDebugSession::EndedState);
 
     {
         QCOMPARE(outputSpy.count(), 1);
         QList<QVariant> arguments = outputSpy.takeFirst();
         QCOMPARE(arguments.count(), 1);
         QCOMPARE(arguments.first().toStringList(), QStringList() << "Hello, world!" << "Hello");
     }
 }
 
 void GdbTest::testEnvironmentSet()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeechoenv")));
 
     cfg.config().writeEntry("EnvironmentGroup", "GdbTestGroup");
 
     WritableEnvironmentProfileList envProfiles(cfg.rootConfig());
     envProfiles.removeProfile(QStringLiteral("GdbTestGroup"));
     auto &envs = envProfiles.variables(QStringLiteral("GdbTestGroup"));
     envs[QStringLiteral("VariableA")] = QStringLiteral("-A' \" complex --value");
     envs[QStringLiteral("VariableB")] = QStringLiteral("-B' \" complex --value");
     envProfiles.saveSettings(cfg.rootConfig());
 
     QSignalSpy outputSpy(session, &TestDebugSession::inferiorStdoutLines);
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, KDevelop::IDebugSession::EndedState);
 
     QVERIFY(outputSpy.count() > 0);
 
     QStringList outputLines;
     while (outputSpy.count() > 0) {
         QList<QVariant> arguments = outputSpy.takeFirst();
         for (const auto &item : arguments) {
             outputLines.append(item.toStringList());
         }
     }
     QCOMPARE(outputLines, QStringList() << "-A' \" complex --value"
                                        << "-B' \" complex --value");
 }
 
 void GdbTest::testBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(b->state(), KDevelop::Breakpoint::CleanState);
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
 }
 
 void GdbTest::testDisableBreakpoint()
 {
     //Description: We must stop only on the third breakpoint
 
     int firstBreakLine=28;
     int secondBreakLine=23;
     int thirdBreakLine=24;
     int fourthBreakLine=31;
 
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint *b;
 
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), firstBreakLine);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
 
 
     //this is needed to emulate debug from GUI. If we are in edit mode, the debugSession doesn't exist.
     KDevelop::ICore::self()->debugController()->breakpointModel()->blockSignals(true);
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), secondBreakLine);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
     //all disabled breakpoints were added
 
     KDevelop::Breakpoint * thirdBreak = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), thirdBreakLine);
     KDevelop::ICore::self()->debugController()->breakpointModel()->blockSignals(false);
 
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->currentLine(), thirdBreak->line());
 
     //disable existing breakpoint
     thirdBreak->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
 
     //add another disabled breakpoint
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), fourthBreakLine);
     QTest::qWait(300);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
 
     QTest::qWait(300);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testChangeLocationBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint *b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 27);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 27);
 
     QTest::qWait(100);
     b->setLine(28);
     QTest::qWait(100);
     session->run();
 
     QTest::qWait(100);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 28);
     QTest::qWait(500);
     breakpoints()->setData(breakpoints()->index(0, KDevelop::Breakpoint::LocationColumn), QString(debugeeFileName+":30"));
     QCOMPARE(b->line(), 29);
     QTest::qWait(100);
     QCOMPARE(b->line(), 29);
     session->run();
     QTest::qWait(100);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 29);
     session->run();
 
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testDeleteBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     QCOMPARE(breakpoints()->rowCount(), 0);
     //add breakpoint before startDebugging
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 21);
     QCOMPARE(breakpoints()->rowCount(), 1);
     breakpoints()->removeRow(0);
     QCOMPARE(breakpoints()->rowCount(), 0);
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 22);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     breakpoints()->removeRow(0);
     session->run();
 
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testPendingBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
 
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile(QStringLiteral("debugeeqt.cpp"))), 10);
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(b->state(), KDevelop::Breakpoint::PendingState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testUpdateBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     // breakpoint 1: real line 29: foo();
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
     QCOMPARE(breakpoints()->rowCount(), 1);
 
     session->startDebugging(&cfg, m_iface);
 
     // breakpoint 2: real line 32: const char *x = "Hello";
     //insert custom command as user might do it using GDB console
     session->addCommand(new MI::UserCommand(MI::NonMI, "break "+debugeeFileName+":32"));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState); // stop at breakpoint 1, with custom command handled
     QCOMPARE(session->currentLine(), 28);
 
     // check breakpoint 2 got picked up
     QCOMPARE(breakpoints()->rowCount(), 2);
     b = breakpoints()->breakpoint(1);
     QCOMPARE(b->url(), QUrl::fromLocalFile(debugeeFileName));
     QCOMPARE(b->line(), 31);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState); // stop at breakpoint 2
     QCOMPARE(session->currentLine(), 31);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testIgnoreHitsBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint * b1 = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 21);
     b1->setIgnoreHits(1);
 
     KDevelop::Breakpoint * b2 = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 22);
 
     session->startDebugging(&cfg, m_iface);
 
     //WAIT_FOR_STATE(session, DebugSession::PausedState);
     WAIT_FOR(session, session->state() == DebugSession::PausedState && b2->hitCount() == 1);
     b2->setIgnoreHits(1);
     session->run();
     //WAIT_FOR_STATE(session, DebugSession::PausedState);
     WAIT_FOR(session, session->state() == DebugSession::PausedState && b1->hitCount() == 1);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testConditionBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 39);
     b->setCondition(QStringLiteral("x[0] == 'H'"));
 
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 23);
     b->setCondition(QStringLiteral("i==2"));
 
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR(session, session->state() == DebugSession::PausedState && session->line() == 24);
     b->setCondition(QStringLiteral("i == 0"));
     QTest::qWait(100);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 23);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 39);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakOnWriteBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     breakpoints()->addWatchpoint(QStringLiteral("i"));
     QTest::qWait(100);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: ++i; int j = i;
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakOnWriteWithConditionBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     KDevelop::Breakpoint *b = breakpoints()->addWatchpoint(QStringLiteral("i"));
     b->setCondition(QStringLiteral("i==2"));
     QTest::qWait(100);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: ++i; int j = i;
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakOnReadBreakpoint()
 {
     /*
     test disabled because of gdb bug: http://sourceware.org/bugzilla/show_bug.cgi?id=10136
 
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint *b = breakpoints()->addReadWatchpoint("foo::i");
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 23);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
     */
 }
 
 void GdbTest::testBreakOnReadBreakpoint2()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     breakpoints()->addReadWatchpoint(QStringLiteral("i"));
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // ++i
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // int j = i
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     if(session->line() == 22) { // some GDB versions break 3 times on this line
         session->run();
         WAIT_FOR_STATE(session, DebugSession::PausedState);
     }
     QCOMPARE(session->line(), 24);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakOnAccessBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     breakpoints()->addAccessWatchpoint(QStringLiteral("i"));
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: ++i (read)
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: ++i (write)
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: int j = i (read)
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testInsertBreakpointWhileRunning()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeslow")));
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
     QTest::qWait(2000);
     qDebug() << "adding breakpoint";
     KDevelop::Breakpoint *b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 30); // ++i;
     QTest::qWait(500);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
     QCOMPARE(session->line(), 30); // ++i;
     b->setDeleted();
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testInsertBreakpointWhileRunningMultiple()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeslow")));
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
     QTest::qWait(2000);
     qDebug() << "adding breakpoint";
     KDevelop::Breakpoint *b1 = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 29); // static int i=0;
     KDevelop::Breakpoint *b2 = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 30); // ++i;
     QTest::qWait(500);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
     QCOMPARE(session->line(), 29); // static int i=0;
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
     QCOMPARE(session->line(), 30); // ++i;
     b1->setDeleted();
     b2->setDeleted();
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testInsertBreakpointFunctionName()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 27);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testManualBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 27);
 
     breakpoints()->removeRows(0, 1);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(breakpoints()->rowCount(), 0);
 
     session->addCommand(MI::NonMI, QStringLiteral("break debugee.cpp:23"));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(breakpoints()->rowCount(), 1);
 
     KDevelop::Breakpoint* b = breakpoints()->breakpoint(0);
     QCOMPARE(b->line(), 22);
 
     session->addCommand(MI::NonMI, QStringLiteral("disable 2"));
     session->addCommand(MI::NonMI, QStringLiteral("condition 2 i == 1"));
     session->addCommand(MI::NonMI, QStringLiteral("ignore 2 1"));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(b->enabled(), false);
     QCOMPARE(b->condition(), QString("i == 1"));
     QCOMPARE(b->ignoreHits(), 1);
 
     session->addCommand(MI::NonMI, QStringLiteral("delete 2"));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(breakpoints()->rowCount(), 0);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testShowStepInSource()
 {
     TestDebugSession *session = new TestDebugSession;
 
     QSignalSpy showStepInSourceSpy(session, &TestDebugSession::showStepInSource);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 29);
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     {
         QCOMPARE(showStepInSourceSpy.count(), 3);
         QList<QVariant> arguments = showStepInSourceSpy.takeFirst();
         QCOMPARE(arguments.first().toUrl(), QUrl::fromLocalFile(debugeeFileName));
         QCOMPARE(arguments.at(1).toInt(), 29);
 
         arguments = showStepInSourceSpy.takeFirst();
         QCOMPARE(arguments.first().toUrl(), QUrl::fromLocalFile(debugeeFileName));
         QCOMPARE(arguments.at(1).toInt(), 22);
 
         arguments = showStepInSourceSpy.takeFirst();
         QCOMPARE(arguments.first().toUrl(), QUrl::fromLocalFile(debugeeFileName));
         QCOMPARE(arguments.at(1).toInt(), 23);
     }
 }
 
 void GdbTest::testStack()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 21);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QModelIndex tIdx = stackModel->index(0,0);
     QCOMPARE(stackModel->rowCount(QModelIndex()), 1);
     QCOMPARE(stackModel->columnCount(QModelIndex()), 3);
     COMPARE_DATA(tIdx, "#1 at foo");
 
     QCOMPARE(stackModel->rowCount(tIdx), 2);
     QCOMPARE(stackModel->columnCount(tIdx), 3);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "foo");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), debugeeFileName+":23");
     COMPARE_DATA(stackModel->index(1, 0, tIdx), "1");
     COMPARE_DATA(stackModel->index(1, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(1, 2, tIdx), debugeeFileName+":29");
 
 
     session->stepOut();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     COMPARE_DATA(tIdx, "#1 at main");
     QCOMPARE(stackModel->rowCount(tIdx), 1);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), debugeeFileName+":30");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testStackFetchMore()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeerecursion")));
     QString fileName = findSourceFile(QStringLiteral("debugeerecursion.cpp"));
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 25);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->frameStackModel()->fetchFramesCalled, 1);
 
     QModelIndex tIdx = stackModel->index(0,0);
     QCOMPARE(stackModel->rowCount(QModelIndex()), 1);
     QCOMPARE(stackModel->columnCount(QModelIndex()), 3);
     COMPARE_DATA(tIdx, "#1 at foo");
 
     QCOMPARE(stackModel->rowCount(tIdx), 21);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "foo");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), fileName+":26");
     COMPARE_DATA(stackModel->index(1, 0, tIdx), "1");
     COMPARE_DATA(stackModel->index(1, 1, tIdx), "foo");
     COMPARE_DATA(stackModel->index(1, 2, tIdx), fileName+":24");
     COMPARE_DATA(stackModel->index(2, 0, tIdx), "2");
     COMPARE_DATA(stackModel->index(2, 1, tIdx), "foo");
     COMPARE_DATA(stackModel->index(2, 2, tIdx), fileName+":24");
     COMPARE_DATA(stackModel->index(19, 0, tIdx), "19");
     COMPARE_DATA(stackModel->index(20, 0, tIdx), "20");
 
     stackModel->fetchMoreFrames();
     QTest::qWait(200);
     QCOMPARE(stackModel->fetchFramesCalled, 2);
     QCOMPARE(stackModel->rowCount(tIdx), 41);
     COMPARE_DATA(stackModel->index(20, 0, tIdx), "20");
     COMPARE_DATA(stackModel->index(21, 0, tIdx), "21");
     COMPARE_DATA(stackModel->index(22, 0, tIdx), "22");
     COMPARE_DATA(stackModel->index(39, 0, tIdx), "39");
     COMPARE_DATA(stackModel->index(40, 0, tIdx), "40");
 
     stackModel->fetchMoreFrames();
     QTest::qWait(200);
     QCOMPARE(stackModel->fetchFramesCalled, 3);
     QCOMPARE(stackModel->rowCount(tIdx), 121);
     COMPARE_DATA(stackModel->index(40, 0, tIdx), "40");
     COMPARE_DATA(stackModel->index(41, 0, tIdx), "41");
     COMPARE_DATA(stackModel->index(42, 0, tIdx), "42");
     COMPARE_DATA(stackModel->index(119, 0, tIdx), "119");
     COMPARE_DATA(stackModel->index(120, 0, tIdx), "120");
 
     stackModel->fetchMoreFrames();
     QTest::qWait(200);
     QCOMPARE(stackModel->fetchFramesCalled, 4);
     QCOMPARE(stackModel->rowCount(tIdx), 299);
     COMPARE_DATA(stackModel->index(120, 0, tIdx), "120");
     COMPARE_DATA(stackModel->index(121, 0, tIdx), "121");
     COMPARE_DATA(stackModel->index(122, 0, tIdx), "122");
     COMPARE_DATA(stackModel->index(298, 0, tIdx), "298");
     COMPARE_DATA(stackModel->index(298, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(298, 2, tIdx), fileName+":30");
 
     stackModel->fetchMoreFrames(); //nothing to fetch, we are at the end
     QTest::qWait(200);
     QCOMPARE(stackModel->fetchFramesCalled, 4);
     QCOMPARE(stackModel->rowCount(tIdx), 299);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testStackDeactivateAndActive()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 21);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QModelIndex tIdx = stackModel->index(0,0);
 
     session->stepOut();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(200);
     COMPARE_DATA(tIdx, "#1 at main");
     QCOMPARE(stackModel->rowCount(tIdx), 1);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), debugeeFileName+":30");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testStackSwitchThread()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeethreads")));
     QString fileName = findSourceFile(QStringLiteral("debugeethreads.cpp"));
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 40); // t3.start();
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QVERIFY(stackModel->rowCount() > 2);
 
     QModelIndex tIdx = stackModel->index(0,0);
     COMPARE_DATA(tIdx, "#1 at main");
     QCOMPARE(stackModel->rowCount(tIdx), 1);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), fileName+":41"); // QThread::usleep(500000);
 
     tIdx = stackModel->index(1,0);
     QVERIFY(stackModel->data(tIdx).toString().startsWith("#2 at "));
     stackModel->setCurrentThread(2);
     QTest::qWait(200);
     int rows = stackModel->rowCount(tIdx);
     QVERIFY(rows > 3);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testAttach()
 {
     SKIP_IF_ATTACH_FORBIDDEN();
 #ifdef Q_OS_FREEBSD
     // Despite successful attach GDB MI spits out a error message "Can't allocate registers". This gets caught by KDevMI layer and gets interpreted as error.
     // Upstream PR: https://sourceware.org/bugzilla/show_bug.cgi?id=23464
     QSKIP("GDB on FreeBSD produces an unexpected error message, on which KDevelop chokes");
 #endif
 
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     KProcess debugeeProcess;
     debugeeProcess << QStringLiteral("nice") << findExecutable(QStringLiteral("debuggee_debugeeslow")).toLocalFile();
     debugeeProcess.start();
     QVERIFY(debugeeProcess.waitForStarted());
     QTest::qWait(100);
 
     TestDebugSession *session = new TestDebugSession;
     session->attachToProcess(debugeeProcess.pid());
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 39); // } after foo();
     QTest::qWait(100);
     session->run();
     QTest::qWait(2000);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     if (session->line() < 39 || session->line() < 40) {
         QCOMPARE(session->line(), 39);
     }
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testManualAttach()
 {
     SKIP_IF_ATTACH_FORBIDDEN();
 #ifdef Q_OS_FREEBSD
     // Despite successful attach GDB MI spits out a error message "Can't allocate registers". This gets caught by KDevMI layer and gets interpreted as error.
     // Upstream PR: https://sourceware.org/bugzilla/show_bug.cgi?id=23464
     QSKIP("GDB on FreeBSD produces an unexpected error message, on which KDevelop chokes");
 #endif
 
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     KProcess debugeeProcess;
     debugeeProcess << QStringLiteral("nice") << findExecutable(QStringLiteral("debuggee_debugeeslow")).toLocalFile();
     debugeeProcess.start();
     QVERIFY(debugeeProcess.waitForStarted());
 
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
     cfg.config().writeEntry(Config::RemoteGdbRunEntry,
                             QUrl::fromLocalFile(findFile(GDB_SRC_DIR,
                                                          QStringLiteral("unittests/gdb_script_empty"))));
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     session->addCommand(MI::NonMI, QStringLiteral("attach %0").arg(debugeeProcess.pid()));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     session->run();
     QTest::qWait(2000); // give the slow inferior some extra time to run
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testCoreFile()
 {
     QFileInfo f(QStringLiteral("core"));
     f.setCaching(false); // don't cache information
     if (f.exists()) {
         QVERIFY(QFile::remove(f.canonicalFilePath()));
     }
 
     KProcess debugeeProcess;
     debugeeProcess.setOutputChannelMode(KProcess::MergedChannels);
     debugeeProcess << QStringLiteral("bash") << QStringLiteral("-c")
                    << "ulimit -c unlimited; "
                       + findExecutable(QStringLiteral("debuggee_crash")).toLocalFile();
     debugeeProcess.start();
     debugeeProcess.waitForFinished();
     qDebug() << "Debuggee output:\n" << debugeeProcess.readAll();
 
     bool coreFileFound = f.exists();
     if (!coreFileFound) {
         // Try to use coredumpctl
         auto coredumpctl = QStandardPaths::findExecutable(QStringLiteral("coredumpctl"));
         if (!coredumpctl.isEmpty()) {
             KProcess::execute(coredumpctl, {"-1", "-o", f.absoluteFilePath(), "dump", "debuggee_crash"}, 5000);
             // coredumpctl seems to create an empty file "core" even if no cores can be delivered
             // (like when run inside docker containers as on KDE CI or with kernel.core_pattern=|/dev/null)
             // so also check for size != 0
             coreFileFound = f.exists() && (f.size() > 0);
         }
     }
     if (!coreFileFound)
         QSKIP("no core dump found, check your system configuration (see /proc/sys/kernel/core_pattern).", SkipSingle);
 
     TestDebugSession *session = new TestDebugSession;
     session->examineCoreFile(findExecutable(QStringLiteral("debuggee_crash")),
                              QUrl::fromLocalFile(f.canonicalFilePath()));
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     WAIT_FOR_STATE(session, DebugSession::StoppedState);
 
     QModelIndex tIdx = stackModel->index(0,0);
     QCOMPARE(stackModel->rowCount(QModelIndex()), 1);
     QCOMPARE(stackModel->columnCount(QModelIndex()), 3);
     COMPARE_DATA(tIdx, "#1 at foo");
 
     session->stopDebugger();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 
 KDevelop::VariableCollection *variableCollection()
 {
     return KDevelop::ICore::self()->debugController()->variableCollection();
 }
 
 void GdbTest::testVariablesLocals()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 22);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000);
 
     QCOMPARE(variableCollection()->rowCount(), 2);
     QModelIndex i = variableCollection()->index(1, 0);
     COMPARE_DATA(i, "Locals");
     QCOMPARE(variableCollection()->rowCount(i), 2);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "i");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "0");
     COMPARE_DATA(variableCollection()->index(1, 0, i), "j");
     // COMPARE_DATA(variableCollection()->index(1, 1, i), "1"); // j is not initialized yet
     session->run();
     QTest::qWait(1000);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "i");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
     COMPARE_DATA(variableCollection()->index(1, 0, i), "j");
     COMPARE_DATA(variableCollection()->index(1, 1, i), "1");
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesLocalsStruct()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000);
 
     QModelIndex i = variableCollection()->index(1, 0);
     QCOMPARE(variableCollection()->rowCount(i), 4);
 
     int structIndex = 0;
     for(int j=0; j<3; ++j) {
         if (variableCollection()->index(j, 0, i).data().toString() == QLatin1String("ts")) {
             structIndex = j;
         }
     }
 
     COMPARE_DATA(variableCollection()->index(structIndex, 0, i), "ts");
     COMPARE_DATA(variableCollection()->index(structIndex, 1, i), "{...}");
     QModelIndex ts = variableCollection()->index(structIndex, 0, i);
     COMPARE_DATA(variableCollection()->index(0, 0, ts), "...");
     variableCollection()->expanded(ts);
     QTest::qWait(100);
     COMPARE_DATA(variableCollection()->index(0, 0, ts), "a");
     COMPARE_DATA(variableCollection()->index(0, 1, ts), "0");
     COMPARE_DATA(variableCollection()->index(1, 0, ts), "b");
     COMPARE_DATA(variableCollection()->index(1, 1, ts), "1");
     COMPARE_DATA(variableCollection()->index(2, 0, ts), "c");
     COMPARE_DATA(variableCollection()->index(2, 1, ts), "2");
 
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000);
     COMPARE_DATA(variableCollection()->index(structIndex, 0, i), "ts");
     COMPARE_DATA(variableCollection()->index(structIndex, 1, i), "{...}");
     COMPARE_DATA(variableCollection()->index(0, 1, ts), "1");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesWatches()
 {
     TestDebugSession *session = new TestDebugSession;
     KDevelop::ICore::self()->debugController()->variableCollection()->variableWidgetShown();
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     variableCollection()->watches()->add(QStringLiteral("ts"));
     QTest::qWait(300);
 
     QModelIndex i = variableCollection()->index(0, 0);
     QCOMPARE(variableCollection()->rowCount(i), 1);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "ts");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "{...}");
     QModelIndex ts = variableCollection()->index(0, 0, i);
     COMPARE_DATA(variableCollection()->index(0, 0, ts), "...");
     variableCollection()->expanded(ts);
     QTest::qWait(100);
     COMPARE_DATA(variableCollection()->index(0, 0, ts), "a");
     COMPARE_DATA(variableCollection()->index(0, 1, ts), "0");
     COMPARE_DATA(variableCollection()->index(1, 0, ts), "b");
     COMPARE_DATA(variableCollection()->index(1, 1, ts), "1");
     COMPARE_DATA(variableCollection()->index(2, 0, ts), "c");
     COMPARE_DATA(variableCollection()->index(2, 1, ts), "2");
 
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(100);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "ts");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "{...}");
     COMPARE_DATA(variableCollection()->index(0, 1, ts), "1");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesWatchesQuotes()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
 
     TestLaunchConfiguration cfg;
 
     // the unquoted string (the actual content):               t\"t
     // quoted string (what we would write as a c string):     "t\\\"t"
     // written in source file:                             R"("t\\\"t")"
     const QString testString(QStringLiteral("t\\\"t")); // the actual content
     const QString quotedTestString(QStringLiteral(R"("t\\\"t")"));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     variableCollection()->watches()->add(quotedTestString); //just a constant string
     QTest::qWait(300);
 
     QModelIndex i = variableCollection()->index(0, 0);
     QCOMPARE(variableCollection()->rowCount(i), 1);
     COMPARE_DATA(variableCollection()->index(0, 0, i), quotedTestString);
     COMPARE_DATA(variableCollection()->index(0, 1, i), "[" + QString::number(testString.length() + 1) + "]");
 
     QModelIndex testStr = variableCollection()->index(0, 0, i);
     COMPARE_DATA(variableCollection()->index(0, 0, testStr), "...");
     variableCollection()->expanded(testStr);
     QTest::qWait(100);
     int len = testString.length();
     for (int ind = 0; ind < len; ind++)
     {
         COMPARE_DATA(variableCollection()->index(ind, 0, testStr), QString::number(ind));
         QChar c = testString.at(ind);
         QString value = QString::number(c.toLatin1()) + " '";
         if (c == '\\')
             value += QLatin1String("\\\\");
         else if (c == '\'')
             value += QLatin1String("\\'");
         else
             value += c;
         value += QLatin1String("'");
         COMPARE_DATA(variableCollection()->index(ind, 1, testStr), value);
     }
     COMPARE_DATA(variableCollection()->index(len, 0, testStr), QString::number(len));
     COMPARE_DATA(variableCollection()->index(len, 1, testStr), "0 '\\000'");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesWatchesTwoSessions()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     variableCollection()->watches()->add(QStringLiteral("ts"));
     QTest::qWait(300);
 
     QModelIndex ts = variableCollection()->index(0, 0, variableCollection()->index(0, 0));
     variableCollection()->expanded(ts);
     QTest::qWait(100);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     //check if variable is marked as out-of-scope
     QCOMPARE(variableCollection()->watches()->childCount(), 1);
     KDevelop::Variable* v = dynamic_cast<KDevelop::Variable*>(variableCollection()->watches()->child(0));
     QVERIFY(v);
     QVERIFY(!v->inScope());
     QCOMPARE(v->childCount(), 3);
     v = dynamic_cast<KDevelop::Variable*>(v->child(0));
     QVERIFY(!v->inScope());
 
     //start a second debug session
     session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(300);
 
     QCOMPARE(variableCollection()->watches()->childCount(), 1);
     ts = variableCollection()->index(0, 0, variableCollection()->index(0, 0));
     v = dynamic_cast<KDevelop::Variable*>(variableCollection()->watches()->child(0));
     QVERIFY(v);
     QVERIFY(v->inScope());
     QCOMPARE(v->childCount(), 3);
 
     v = dynamic_cast<KDevelop::Variable*>(v->child(0));
     QVERIFY(v->inScope());
     QCOMPARE(v->data(1, Qt::DisplayRole).toString(), QString::number(0));
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     //check if variable is marked as out-of-scope
     v = dynamic_cast<KDevelop::Variable*>(variableCollection()->watches()->child(0));
     QVERIFY(!v->inScope());
     QVERIFY(!dynamic_cast<KDevelop::Variable*>(v->child(0))->inScope());
 }
 
 void GdbTest::testVariablesStopDebugger()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     session->stopDebugger();
     QTest::qWait(300);
 }
 
 
 void GdbTest::testVariablesStartSecondSession()
 {
     QPointer<TestDebugSession> session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QPointer<TestDebugSession> session2 = new TestDebugSession;
     session2->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session2->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session2, DebugSession::PausedState);
 
     session2->run();
     WAIT_FOR_STATE(session2, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesSwitchFrame()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
 
     QModelIndex i = variableCollection()->index(1, 0);
     COMPARE_DATA(i, "Locals");
     QCOMPARE(variableCollection()->rowCount(i), 2);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "i");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
     COMPARE_DATA(variableCollection()->index(1, 0, i), "j");
 
     stackModel->setCurrentFrame(1);
     QTest::qWait(200);
 
     i = variableCollection()->index(1, 0);
     QCOMPARE(variableCollection()->rowCount(i), 4);
     COMPARE_DATA(variableCollection()->index(2, 0, i), "argc");
     COMPARE_DATA(variableCollection()->index(2, 1, i), "1");
     COMPARE_DATA(variableCollection()->index(3, 0, i), "argv");
 
     breakpoints()->removeRow(0);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesQuicklySwitchFrame()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
 
     QModelIndex i = variableCollection()->index(1, 0);
     COMPARE_DATA(i, "Locals");
     QCOMPARE(variableCollection()->rowCount(i), 2);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "i");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
     COMPARE_DATA(variableCollection()->index(1, 0, i), "j");
 
     stackModel->setCurrentFrame(1);
     QTest::qWait(300);
     stackModel->setCurrentFrame(0);
     QTest::qWait(1);
     stackModel->setCurrentFrame(1);
     QTest::qWait(1);
     stackModel->setCurrentFrame(0);
     QTest::qWait(1);
     stackModel->setCurrentFrame(1);
     QTest::qWait(500);
 
     i = variableCollection()->index(1, 0);
     QCOMPARE(variableCollection()->rowCount(i), 4);
     QStringList locs;
     for (int j = 0; j < variableCollection()->rowCount(i); ++j) {
         locs << variableCollection()->index(j, 0, i).data().toString();
     }
     QVERIFY(locs.contains("argc"));
     QVERIFY(locs.contains("argv"));
     QVERIFY(locs.contains("x"));
 
     breakpoints()->removeRow(0);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 
 void GdbTest::testSegfaultDebugee()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_crash")));
     QString fileName = findSourceFile(QStringLiteral("debugeecrash.cpp"));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 23);
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 23);
     session->run();
 
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     session->stopDebugger();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testSwitchFrameGdbConsole()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(stackModel->currentFrame(), 0);
     stackModel->setCurrentFrame(1);
     QCOMPARE(stackModel->currentFrame(), 1);
     QTest::qWait(500);
     QCOMPARE(stackModel->currentFrame(), 1);
 
     session->addUserCommand(QStringLiteral("print x"));
     QTest::qWait(500);
     //currentFrame must not reset to 0; Bug 222882
     QCOMPARE(stackModel->currentFrame(), 1);
 
 }
 
 //Bug 201771
 void GdbTest::testInsertAndRemoveBreakpointWhileRunning()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeslow")));
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
     QTest::qWait(2000);
     qDebug() << "adding breakpoint";
     KDevelop::Breakpoint *b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 30); // ++i;
     b->setDeleted();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 //Bug 274390
 void GdbTest::testCommandOrderFastStepping()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeqt")));
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
     QVERIFY(session->startDebugging(&cfg, m_iface));
     for(int i=0; i<20; i++) {
         session->stepInto();
     }
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testPickupManuallyInsertedBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
     QVERIFY(session->startDebugging(&cfg, m_iface));
     session->addCommand(MI::NonMI, QStringLiteral("break debugee.cpp:32"));
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000); //wait for breakpoints update
     QCOMPARE(breakpoints()->breakpoints().count(), 2);
     QCOMPARE(breakpoints()->rowCount(), 2);
     KDevelop::Breakpoint *b = breakpoints()->breakpoint(1);
     QVERIFY(b);
     QCOMPARE(b->line(), 31); //we start with 0, gdb with 1
     QCOMPARE(b->url().fileName(), QString("debugee.cpp"));
 }
 
 //Bug 270970
 void GdbTest::testPickupManuallyInsertedBreakpointOnlyOnce()
 {
     TestDebugSession *session = new TestDebugSession;
 
     //inject here, so it behaves similar like a command from .gdbinit
     QTemporaryFile configScript;
     configScript.open();
     configScript.write(QStringLiteral("file %0\n").arg(findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile()).toLocal8Bit());
     configScript.write("break debugee.cpp:32\n");
     configScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbConfigEntry, QUrl::fromLocalFile(configScript.fileName()));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(QStringLiteral("debugee.cpp")), 31);
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(breakpoints()->breakpoints().count(), 1);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testPickupCatchThrowOnlyOnce()
 {
     QTemporaryFile configScript;
     configScript.open();
     configScript.write("catch throw\n");
     configScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbConfigEntry, QUrl::fromLocalFile(configScript.fileName()));
 
 
     for (int i = 0; i < 2; ++i) {
         TestDebugSession* session = new TestDebugSession;
         QVERIFY(session->startDebugging(&cfg, m_iface));
         WAIT_FOR_STATE(session, DebugSession::EndedState);
     }
 
     QCOMPARE(breakpoints()->rowCount(), 1); //one from kdevelop, one from runScript
 }
 
 void GdbTest::testRunGdbScript()
 {
     TestDebugSession *session = new TestDebugSession;
 
     QTemporaryFile runScript;
     runScript.open();
 
     runScript.write("file " + KShell::quoteArg(findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile()).toUtf8() + "\n");
     runScript.write("break main\n");
     runScript.write("run\n");
     runScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbRunEntry, QUrl::fromLocalFile(runScript.fileName()));
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 27);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testRemoteDebug()
 {
     const QString gdbserverExecutable = QStandardPaths::findExecutable(QStringLiteral("gdbserver"));
     if (gdbserverExecutable.isEmpty()) {
         QSKIP("Skipping, gdbserver not available", SkipSingle);
     }
 
     TestDebugSession *session = new TestDebugSession;
 
     QTemporaryFile shellScript(QDir::currentPath()+"/shellscript");
     shellScript.open();
     shellScript.write("gdbserver localhost:2345 " + findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toUtf8() + "\n");
     shellScript.close();
     shellScript.setPermissions(shellScript.permissions() | QFile::ExeUser);
     QFile::copy(shellScript.fileName(), shellScript.fileName()+"-copy"); //to avoid "Text file busy" on executing (why?)
 
     QTemporaryFile runScript(QDir::currentPath()+"/runscript");
     runScript.open();
     runScript.write("file " + findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toUtf8() + "\n");
     runScript.write("target remote localhost:2345\n");
     runScript.write("break debugee.cpp:30\n");
     runScript.write("continue\n");
     runScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbShellEntry, QUrl::fromLocalFile((shellScript.fileName()+"-copy")));
     grp.writeEntry(Config::RemoteGdbRunEntry, QUrl::fromLocalFile(runScript.fileName()));
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 29);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     QFile::remove(shellScript.fileName()+"-copy");
 }
 
 void GdbTest::testRemoteDebugInsertBreakpoint()
 {
     const QString gdbserverExecutable = QStandardPaths::findExecutable(QStringLiteral("gdbserver"));
     if (gdbserverExecutable.isEmpty()) {
         QSKIP("Skipping, gdbserver not available", SkipSingle);
     }
 
     TestDebugSession *session = new TestDebugSession;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 29);
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 35);
 
     QTemporaryFile shellScript(QDir::currentPath()+"/shellscript");
     shellScript.open();
     shellScript.write("gdbserver localhost:2345 " + findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toUtf8() + "\n");
     shellScript.close();
     shellScript.setPermissions(shellScript.permissions() | QFile::ExeUser);
     QFile::copy(shellScript.fileName(), shellScript.fileName()+"-copy"); //to avoid "Text file busy" on executing (why?)
 
     QTemporaryFile runScript(QDir::currentPath()+"/runscript");
     runScript.open();
     runScript.write("file " + findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toUtf8() + '\n');
     runScript.write("target remote localhost:2345\n");
     runScript.write("break debugee.cpp:30\n");
     runScript.write("continue\n");
     runScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbShellEntry, QUrl::fromLocalFile(shellScript.fileName()+"-copy"));
     grp.writeEntry(Config::RemoteGdbRunEntry, QUrl::fromLocalFile(runScript.fileName()));
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 29);
 
     QCOMPARE(breakpoints()->breakpoints().count(), 2); //one from kdevelop, one from runScript
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 35);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     QFile::remove(shellScript.fileName()+"-copy");
 }
 
 
 void GdbTest::testRemoteDebugInsertBreakpointPickupOnlyOnce()
 {
     const QString gdbserverExecutable = QStandardPaths::findExecutable(QStringLiteral("gdbserver"));
     if (gdbserverExecutable.isEmpty()) {
         QSKIP("Skipping, gdbserver not available", SkipSingle);
     }
 
     TestDebugSession *session = new TestDebugSession;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 35);
 
     QTemporaryFile shellScript(QDir::currentPath()+"/shellscript");
     shellScript.open();
     shellScript.write("gdbserver localhost:2345 "+findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toLatin1()+"\n");
     shellScript.close();
     shellScript.setPermissions(shellScript.permissions() | QFile::ExeUser);
     QFile::copy(shellScript.fileName(), shellScript.fileName()+"-copy"); //to avoid "Text file busy" on executing (why?)
 
     QTemporaryFile runScript(QDir::currentPath()+"/runscript");
     runScript.open();
     runScript.write("file "+findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toLatin1()+"\n");
     runScript.write("target remote localhost:2345\n");
     runScript.write("break debugee.cpp:30\n");
     runScript.write("continue\n");
     runScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbShellEntry, QUrl::fromLocalFile((shellScript.fileName()+"-copy")));
     grp.writeEntry(Config::RemoteGdbRunEntry, QUrl::fromLocalFile(runScript.fileName()));
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 29);
 
     QCOMPARE(breakpoints()->breakpoints().count(), 2); //one from kdevelop, one from runScript
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 35);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     //************************** second session
     session = new TestDebugSession;
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 29);
 
     QCOMPARE(breakpoints()->breakpoints().count(), 2); //one from kdevelop, one from runScript
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 35);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     QFile::remove(shellScript.fileName()+"-copy");
 }
 
 void GdbTest::testBreakpointWithSpaceInPath()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeespace")));
     KConfigGroup grp = cfg.config();
     QString fileName = findSourceFile(QStringLiteral("debugee space.cpp"));
 
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 20);
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 20);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakpointDisabledOnStart()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28)
         ->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 29);
     KDevelop::Breakpoint* b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 31);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 29);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Checked);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 31);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testCatchpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeexception")));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile(QStringLiteral("debugeeexception.cpp"))), 29);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000);
     TestFrameStackModel* fsModel = session->frameStackModel();
     QCOMPARE(fsModel->currentFrame(), 0);
     QCOMPARE(session->line(), 29);
 
     session->addCommand(MI::NonMI, QStringLiteral("catch throw"));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QTest::qWait(1000);
 
     const QVector<KDevelop::FrameStackModel::FrameItem> frames = fsModel->frames(fsModel->currentThread());
     QVERIFY(frames.size() >= 2);
     // frame 0 is somewhere inside libstdc++
     QCOMPARE(frames[1].file, QUrl::fromLocalFile(findSourceFile("debugeeexception.cpp")));
     QCOMPARE(frames[1].line, 22);
 
     QCOMPARE(breakpoints()->rowCount(),2);
     QVERIFY(!breakpoints()->breakpoint(0)->location().isEmpty());
     QVERIFY(!breakpoints()->breakpoint(1)->location().isEmpty());
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testThreadAndFrameInfo()
 {
     // Check if --thread is added to user commands
 
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeethreads")));
     QString fileName = findSourceFile(QStringLiteral("debugeethreads.cpp"));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QSignalSpy outputSpy(session, &TestDebugSession::debuggerUserCommandOutput);
 
     session->addCommand(new MI::UserCommand(MI::ThreadInfo, QString()));
     session->addCommand(new MI::UserCommand(MI::StackListLocals, QStringLiteral("0")));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState); // wait for command finish
 
     // outputs should be
     // 1. -thread-info
     // 2. ^done for thread-info
     // 3. -stack-list-locals
     // 4. ^done for -stack-list-locals
     QCOMPARE(outputSpy.count(), 4);
     QVERIFY(outputSpy.at(2).at(0).toString().contains(QLatin1String("--thread 1")));
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::parseBug304730()
 {
     MI::FileSymbol file;
     file.contents = QByteArray("^done,bkpt={"
         "number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"<MULTIPLE>\",times=\"0\","
         "original-location=\"/media/portable/Projects/BDSInpainting/PatchMatch/PatchMatch.hpp:231\"},"
         "{number=\"1.1\",enabled=\"y\",addr=\"0x081d84aa\","
         "func=\"PatchMatch<itk::Image<itk::CovariantVector<unsigned char, 3u>, 2u> >"
         "::Propagation<ForwardPropagationNeighbors>(ForwardPropagationNeighbors)\","
         "file=\"/media/portable/Projects/BDSInpainting/Drivers/../PatchMatch/PatchMatch.hpp\","
         "fullname=\"/media/portable/Projects/BDSInpainting/PatchMatch/PatchMatch.hpp\",line=\"231\"},"
         "{number=\"1.2\",enabled=\"y\",addr=\"0x081d8ae2\","
         "func=\"PatchMatch<itk::Image<itk::CovariantVector<unsigned char, 3u>, 2u> >"
         "::Propagation<BackwardPropagationNeighbors>(BackwardPropagationNeighbors)\","
         "file=\"/media/portable/Projects/BDSInpainting/Drivers/../PatchMatch/PatchMatch.hpp\","
         "fullname=\"/media/portable/Projects/BDSInpainting/PatchMatch/PatchMatch.hpp\",line=\"231\"},"
         "{number=\"1.3\",enabled=\"y\",addr=\"0x081d911a\","
         "func=\"PatchMatch<itk::Image<itk::CovariantVector<unsigned char, 3u>, 2u> >"
         "::Propagation<AllowedPropagationNeighbors>(AllowedPropagationNeighbors)\","
         "file=\"/media/portable/Projects/BDSInpainting/Drivers/../PatchMatch/PatchMatch.hpp\","
         "fullname=\"/media/portable/Projects/BDSInpainting/PatchMatch/PatchMatch.hpp\",line=\"231\"}");
 
     MI::MIParser parser;
 
     std::unique_ptr<MI::Record> record(parser.parse(&file));
     QVERIFY(record.get() != nullptr);
 }
 
 void GdbTest::testMultipleLocationsBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeemultilocbreakpoint")));
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("aPlusB"));
 
     //TODO check if the additional location breakpoint is added
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 19);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 23);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBug301287()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     variableCollection()->watches()->add(QStringLiteral("argc"));
     QTest::qWait(300);
 
     QModelIndex i = variableCollection()->index(0, 0);
     QCOMPARE(variableCollection()->rowCount(i), 1);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "argc");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     //start second debug session (same cfg)
     session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QTest::qWait(300);
 
     i = variableCollection()->index(0, 0);
     QCOMPARE(variableCollection()->rowCount(i), 1);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "argc");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testMultipleBreakpoint()
 {
         TestDebugSession *session = new TestDebugSession;
 
         //there'll be about 3-4 breakpoints, but we treat it like one.
         TestLaunchConfiguration c(findExecutable(QStringLiteral("debuggee_debugeemultiplebreakpoint")));
         KDevelop::Breakpoint *b = breakpoints()->addCodeBreakpoint(QStringLiteral("debugeemultiplebreakpoint.cpp:52"));
         session->startDebugging(&c, m_iface);
         WAIT_FOR_STATE(session, DebugSession::PausedState);
         QCOMPARE(breakpoints()->breakpoints().count(), 1);
 
         b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
         session->run();
         WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testRegularExpressionBreakpoint()
 {
         TestDebugSession *session = new TestDebugSession;
 
         TestLaunchConfiguration c(findExecutable(QStringLiteral("debuggee_debugeemultilocbreakpoint")));
         breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
         session->startDebugging(&c, m_iface);
         WAIT_FOR_STATE(session, DebugSession::PausedState);
         session->addCommand(MI::NonMI, QStringLiteral("rbreak .*aPl.*B"));
         QTest::qWait(100);
         session->run();
         WAIT_FOR_STATE(session, DebugSession::PausedState);
         QCOMPARE(breakpoints()->breakpoints().count(), 3);
 
         session->addCommand(MI::BreakDelete, QString());
         session->run();
         WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testChangeBreakpointWhileRunning() {
 
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration c(findExecutable(QStringLiteral("debuggee_debugeeslow")));
     KDevelop::Breakpoint* b = breakpoints()->addCodeBreakpoint(QStringLiteral("debugeeslow.cpp:30"));
     session->startDebugging(&c, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QVERIFY(session->currentLine() >= 29 && session->currentLine() <= 31 );
     session->run();
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
     //to make one loop
     QTest::qWait(2000);
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
 
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Checked);
     QTest::qWait(100);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
     session->run();
     QTest::qWait(100);
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testDebugInExternalTerminal()
 {
     TestLaunchConfiguration cfg;
 
     foreach (const QString & console, QStringList() << "konsole" << "xterm" << "xfce4-terminal" << "gnome-terminal") {
 
         TestDebugSession* session = nullptr;
         if (QStandardPaths::findExecutable(console).isEmpty()) {
             continue;
         }
 
         session = new TestDebugSession();
 
         cfg.config().writeEntry("External Terminal"/*ExecutePlugin::terminalEntry*/, console);
         cfg.config().writeEntry("Use External Terminal"/*ExecutePlugin::useTerminalEntry*/, true);
 
         KDevelop::Breakpoint* b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
 
         session->startDebugging(&cfg, m_iface);
         WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
         QCOMPARE(b->state(), KDevelop::Breakpoint::CleanState);
         session->stepInto();
         WAIT_FOR_STATE(session, DebugSession::PausedState);
         session->run();
         WAIT_FOR_STATE(session, DebugSession::EndedState);
     }
 }
 
 // see: https://bugs.kde.org/show_bug.cgi?id=339231
 void GdbTest::testPathWithSpace()
 {
     TestDebugSession* session = new TestDebugSession;
 
     auto debugee = findExecutable(QStringLiteral("path with space/debuggee_spacedebugee"));
     TestLaunchConfiguration c(debugee, KIO::upUrl(debugee));
     KDevelop::Breakpoint* b = breakpoints()->addCodeBreakpoint(QStringLiteral("spacedebugee.cpp:30"));
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
     session->startDebugging(&c, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(b->state(), KDevelop::Breakpoint::CleanState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 bool GdbTest::waitForState(DebugSession *session, DebugSession::DebuggerState state,
                             const char *file, int line, bool waitForIdle)
 {
     QPointer<MIDebugSession> s(session); //session can get deleted in DebugController
     QTime stopWatch;
     stopWatch.start();
 
     // legacy behavior for tests that implicitly may require waiting for idle,
     // but which were written before waitForIdle was added
     waitForIdle = waitForIdle || state != MIDebugSession::EndedState;
 
     while (s && (s->state() != state || (waitForIdle && s->debuggerStateIsOn(s_dbgBusy)))) {
         if (stopWatch.elapsed() > 5000) {
             qWarning() << "current state" << s->state() << "waiting for" << state;
             QTest::qFail(qPrintable(QString("Timeout before reaching state %0").arg(state)),
                          file, line);
             return false;
         }
         QTest::qWait(20);
     }
 
     // NOTE: don't wait anymore after leaving the loop. Waiting re-enters event loop and
     // may change session state.
 
     if (!s && state != MIDebugSession::EndedState) {
         QTest::qFail(qPrintable(QString("Session ended before reaching state %0").arg(state)),
                      file, line);
         return false;
     }
 
     qDebug() << "Reached state " << state << " in " << file << ':' << line;
     return true;
 }
 } // end of namespace GDB
 } // end of namespace KDevMI
 
 QTEST_MAIN(KDevMI::GDB::GdbTest)
 
 
 #include "test_gdb.moc"
 #include "moc_test_gdb.cpp"
 
diff --git a/plugins/qmakemanager/parser/qmake.g b/plugins/qmakemanager/parser/qmake.g
index b5c40959c9..9c057c3437 100644
--- a/plugins/qmakemanager/parser/qmake.g
+++ b/plugins/qmakemanager/parser/qmake.g
@@ -1,246 +1,245 @@
 -------------------------------------------------------------------------------
 -- This file is part of the QMake parser in KDevelop4
 -- Copyright (c) 2007 Andreas Pakulat <apaku@gmx.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, write to the Free Software
 -- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 -- 02110-1301, USA.
 -------------------------------------------------------------------------------
 
 -----------------------------------------------------------
 -- Global  declarations
 -----------------------------------------------------------
 
 
 [:
 
 namespace QMake
 {
     class Lexer;
 }
 
 #include <QString>
 
 :]
 
 %parser_declaration_header "QtCore/QString"
 
 
 ------------------------------------------------------------
 -- Parser class members
 ------------------------------------------------------------
 
 %parserclass (public declaration)
 [:
     /**
      * Transform the raw input into tokens.
      * When this method returns, the parser's token stream has been filled
      * and any parse_*() method can be called.
      */
     void tokenize( const QString& contents );
 
     enum ProblemType {
         Error,
         Warning,
         Info
     };
     void reportProblem( Parser::ProblemType type, const QString& message );
 
     QString tokenText(qint64 begin, qint64 end) const;
 
     void setDebug( bool debug );
 
 :]
 
 %parserclass (private declaration)
 [:
     QString m_contents;
     bool m_debug;
 :]
 -----------------------------------------------------------
 -- List of defined tokens
 -----------------------------------------------------------
 
 %token LBRACE("lbrace"), RBRACE("rbrace"), LPAREN("lparen"),RPAREN("rparen") ;;
 
 %token PLUSEQ("pluseq"),EQUAL("equal"),MINUSEQ("minuseq"),STAREQ("stareq"),
        TILDEEQ("tildeeq") ;;
 
 %token COLON("colon"), COMMA("comma"), CONT("cont"), EXCLAM("exclam"),
        NEWLINE("newline"), OR("or") ;;
 
 %token IDENTIFIER("identifier"), VALUE("value") ;;
 
 -- token that makes the parser fail in any case:
 %token INVALID ("invalid token") ;;
 
 -- The actual grammar starts here.
 
    ( #statements=statement )*
 -> project ;;
 
    ( id=IDENTIFIER ( var=variableAssignment | scope=scope )
             [:
                 (*yynode)->isNewline = false;
                 (*yynode)->isExclam = false;
             :]
    ) | ( EXCLAM id=IDENTIFIER scope=scope
             [:
                (*yynode)->isNewline = false;
                (*yynode)->isExclam = true;
             :]
     ) | NEWLINE
             [:
                 (*yynode)->isNewline = true;
                 (*yynode)->isExclam = false;
             :]
 -> statement [ member variable isNewline: bool;
           member variable isExclam: bool; ] ;;
 
    functionArguments=functionArguments ( scopeBody=scopeBody | orOperator=orOperator scopeBody=scopeBody | 0 )
    | ( orOperator=orOperator | 0 ) scopeBody=scopeBody
 -> scope ;;
 
    ( OR #item=item )+
 -> orOperator ;;
 
    id=IDENTIFIER ( functionArguments=functionArguments | 0 )
 -> item ;;
 
    op=op ( values=valueList ( NEWLINE | 0 ) | NEWLINE | 0 )
 -> variableAssignment ;;
 
    optoken=PLUSEQ | optoken=MINUSEQ | optoken=STAREQ | optoken=EQUAL | optoken=TILDEEQ
 -> op ;;
 
    ( #list=value | CONT NEWLINE )+
 -> valueList ;;
 
    value=VALUE
 -> value ;;
 
    LPAREN args=argumentList RPAREN
 -> functionArguments ;;
 
    ( ( #args=value | CONT NEWLINE ) ( ( COMMA | CONT NEWLINE ) #args=value )* | 0 )
 -> argumentList ;;
 
     LBRACE ( NEWLINE | 0 ) ( #statements=statement )* RBRACE | COLON #statements=statement
 -> scopeBody ;;
 
 -----------------------------------------------------------------
 -- Code segments copied to the implementation (.cpp) file.
 -- If existent, kdevelop-pg's current syntax requires this block
 -- to occur at the end of the file.
 -----------------------------------------------------------------
 
 [:
 #include "qmakelexer.h"
 #include <QString>
 #include <debug.h>
 
 namespace QMake
 {
 
 void Parser::tokenize( const QString& contents )
 {
     m_contents = contents;
     QMake::Lexer lexer( this, contents );
     int kind = Parser::Token_EOF;
 
     do
     {
         kind = lexer.nextTokenKind();
 
         if ( !kind ) // when the lexer returns 0, the end of file is reached
             kind = Parser::Token_EOF;
 
         Parser::Token &t = this->tokenStream->push();
         t.kind = kind;
         if( t.kind == Parser::Token_EOF )
         {
             t.begin = -1;
             t.end = -1;
         }else
         {
             t.begin = lexer.tokenBegin();
             t.end = lexer.tokenEnd();
         }
 
         if( m_debug )
         {
             qCDebug(KDEV_QMAKE) << kind << "(" << t.begin << "," << t.end << ")::" << tokenText(t.begin, t.end);
         }
 
     }
     while ( kind != Parser::Token_EOF );
 
     this->yylex(); // produce the look ahead token
 }
 
 QString Parser::tokenText( qint64 begin, qint64 end ) const
 {
     return m_contents.mid((int)begin, (int)end-begin+1);
 }
 
 void Parser::reportProblem( Parser::ProblemType type, const QString& message )
 {
     if (type == Error)
         qCDebug(KDEV_QMAKE) << "** ERROR:" << message;
     else if (type == Warning)
         qCDebug(KDEV_QMAKE) << "** WARNING:" << message;
     else if (type == Info)
         qCDebug(KDEV_QMAKE) << "** Info:" << message;
 }
 
 
 // custom error recovery
 void Parser::expectedToken(int /*expected*/, qint64 /*where*/, const QString& name)
 {
     reportProblem(
         Parser::Error,
         QStringLiteral("Expected token \"%1\"").arg(name));
 }
 
 void Parser::expectedSymbol(int /*expected_symbol*/, const QString& name)
 {
     qint64 line;
     qint64 col;
     size_t index = tokenStream->index()-1;
     Token &token = tokenStream->at(index);
     qCDebug(KDEV_QMAKE) << "token starts at:" << token.begin;
     qCDebug(KDEV_QMAKE) << "index is:" << index;
     tokenStream->startPosition(index, &line, &col);
     QString tokenValue = tokenText(token.begin, token.end);
     reportProblem(
         Parser::Error,
         QStringLiteral("Expected symbol \"%1\" (current token: \"%2\" [%3] at line: %4 col: %5)")
-            .arg(name)
-            .arg(token.kind != 0 ? tokenValue : QStringLiteral("EOF"))
+            .arg(name, token.kind != 0 ? tokenValue : QStringLiteral("EOF"))
             .arg(token.kind)
             .arg(line)
             .arg(col));
 }
 
 void Parser::setDebug( bool debug )
 {
     m_debug = debug;
 }
 
 } // end of namespace QMake
 
 :]
 
 -- kate: space-indent on; indent-width 4; tab-width 4; replace-tabs on; auto-insert-doxygen on
 
diff --git a/plugins/qmakemanager/tests/test_qmakeproject.cpp b/plugins/qmakemanager/tests/test_qmakeproject.cpp
index bb70ee0170..7096ac6647 100644
--- a/plugins/qmakemanager/tests/test_qmakeproject.cpp
+++ b/plugins/qmakemanager/tests/test_qmakeproject.cpp
@@ -1,145 +1,145 @@
 /* KDevelop QMake Support
  *
  * Copyright 2011 Julien Desgats <julien.desgats@gmail.com>
  *
  * 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, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 
 #include "test_qmakeproject.h"
 #include "../qmakeconfig.h"
 #include "qmaketestconfig.h"
 
 #include <shell/core.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/interfaces/iprojectbuilder.h>
 #include <project/projectmodel.h>
 #include <serialization/indexedstring.h>
 
 #include <QFileInfo>
 #include <QTest>
 #include <QSignalSpy>
 #include <KConfigGroup>
 #include <KJob>
 
 QTEST_MAIN(TestQMakeProject)
 
 using namespace KDevelop;
 
 TestQMakeProject::TestQMakeProject(QObject* parent)
     : QObject(parent)
 {
     qRegisterMetaType<IProject*>();
 }
 
 TestQMakeProject::~TestQMakeProject()
 {
 }
 
 void TestQMakeProject::initTestCase()
 {
     AutoTestShell::init({ "KDevQMakeManager", "KDevQMakeBuilder", "KDevMakeBuilder", "KDevStandardOutputView" });
     TestCore::initialize();
 }
 
 void TestQMakeProject::cleanupTestCase()
 {
     Core::self()->cleanup();
 }
 
 void TestQMakeProject::testBuildDirectory_data()
 {
     QTest::addColumn<QString>("projectName"); // name of the project (both directory and .kde4 file)
     QTest::addColumn<QString>("target"); // directory to compile from project root
     QTest::addColumn<QString>("expected"); // expected build directory from build dir
 
     QTest::newRow("Basic Project") << "basic_project"
                                    << ""
                                    << "";
     QTest::newRow("Subdirs Project (root)") << "subdirs_project"
                                             << ""
                                             << "";
     QTest::newRow("Subdirs Project (dir_a)") << "subdirs_project"
                                              << "dir_a"
                                              << "dir_a";
 }
 
 void TestQMakeProject::testBuildDirectory()
 {
     QFETCH(QString, projectName);
     QFETCH(QString, target);
     QFETCH(QString, expected);
 
     const QString buildDir = QStringLiteral("/tmp/some/path"); // some dummy directory to build (nothing will be built anyway)
 
     foreach (IProject* p, ICore::self()->projectController()->projects()) {
         ICore::self()->projectController()->closeProject(p);
     }
 
     // setup project config, to avoid build dir chooser dialog popping up
     {
         // note: all checks from QMakeProjectManager::projectNeedsConfiguration must be satisfied
         const QString fileName
-            = QStringLiteral("%1/%2/.kdev4/%3.kdev4").arg(QMAKE_TESTS_PROJECTS_DIR).arg(projectName).arg(projectName);
+            = QStringLiteral("%1/%2/.kdev4/%2.kdev4").arg(QMAKE_TESTS_PROJECTS_DIR, projectName);
 
         KConfig cfg(fileName);
         KConfigGroup group(&cfg, QMakeConfig::CONFIG_GROUP);
 
         group.writeEntry(QMakeConfig::BUILD_FOLDER, buildDir);
         group.writeEntry(QMakeConfig::QMAKE_EXECUTABLE, QMAKE_TESTS_QMAKE_EXECUTABLE);
         group.sync();
 
         /// create subgroup for one build dir
         KConfigGroup buildDirGroup = KConfigGroup(&cfg, QMakeConfig::CONFIG_GROUP).group(buildDir);
         buildDirGroup.writeEntry(QMakeConfig::QMAKE_EXECUTABLE, QMAKE_TESTS_QMAKE_EXECUTABLE);
         buildDirGroup.sync();
 
         QVERIFY(QFileInfo::exists(fileName));
     }
 
     // opens project with kdevelop
     const QUrl projectUrl = QUrl::fromLocalFile(
-        QStringLiteral("%1/%2/%3.kdev4").arg(QMAKE_TESTS_PROJECTS_DIR).arg(projectName).arg(projectName));
+        QStringLiteral("%1/%2/%2.kdev4").arg(QMAKE_TESTS_PROJECTS_DIR, projectName));
     ICore::self()->projectController()->openProject(projectUrl);
 
     // wait for loading finished
     QSignalSpy spy(ICore::self()->projectController(), SIGNAL(projectOpened(KDevelop::IProject*)));
     bool gotSignal = spy.wait(30000);
     QVERIFY2(gotSignal, "Timeout while waiting for opened signal");
 
     IProject* project = ICore::self()->projectController()->findProjectByName(projectName);
 
     // adds expected directory to our base path
     Path expectedPath(Path(buildDir), expected);
 
     // path for files to build
-    Path buildUrl(QStringLiteral("%1/%2/%3").arg(QMAKE_TESTS_PROJECTS_DIR).arg(projectName).arg(target));
+    Path buildUrl(QStringLiteral("%1/%2/%3").arg(QMAKE_TESTS_PROJECTS_DIR, projectName, target));
     QList<ProjectFolderItem*> buildItems = project->foldersForPath(IndexedString(buildUrl.pathOrUrl()));
     QCOMPARE(buildItems.size(), 1);
     IBuildSystemManager* buildManager = project->buildSystemManager();
     const auto buildFolder = buildItems.first();
 
     const Path actual = buildManager->buildDirectory(buildFolder);
 
     QCOMPARE(actual, expectedPath);
 
     auto buildJob = buildManager->builder()->configure(project);
     QVERIFY(buildJob->exec());
 }
diff --git a/plugins/qmljs/3rdparty/qtcreator-libs/qmljs/qmljsbundle.cpp b/plugins/qmljs/3rdparty/qtcreator-libs/qmljs/qmljsbundle.cpp
index d326da7b10..856c24cf32 100644
--- a/plugins/qmljs/3rdparty/qtcreator-libs/qmljs/qmljsbundle.cpp
+++ b/plugins/qmljs/3rdparty/qtcreator-libs/qmljs/qmljsbundle.cpp
@@ -1,320 +1,320 @@
 /****************************************************************************
 **
 ** Copyright (C) 2015 The Qt Company Ltd.
 ** Contact: http://www.qt.io/licensing
 **
 ** This file is part of Qt Creator.
 **
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company.  For licensing terms and
 ** conditions see http://www.qt.io/terms-conditions.  For further information
 ** use the contact form at http://www.qt.io/contact-us.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 2.1 or version 3 as published by the Free
 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
 ** LICENSE.LGPLv3 included in the packaging of this file.  Please review the
 ** following information to ensure the GNU Lesser General Public License
 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, The Qt Company gives you certain additional
 ** rights.  These rights are described in The Qt Company LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ****************************************************************************/
 
 #include "qmljsbundle.h"
 
 #include <utils/json.h>
 
 #include <QString>
 #include <QFile>
 #include <QTextStream>
 #include <QHash>
 
 namespace QmlJS {
 typedef PersistentTrie::Trie Trie;
 
 QmlBundle::QmlBundle(const QmlBundle &o)
     : m_name(o.m_name), m_searchPaths(o.searchPaths()), m_installPaths(o.installPaths()),
       m_supportedImports(o.m_supportedImports), m_implicitImports(o.m_implicitImports)
 { }
 
 QmlBundle::QmlBundle()
 { }
 
 QmlBundle::QmlBundle(const QString &bundleName, const Trie &searchPaths,
                      const Trie &installPaths, const Trie &supportedImports,
                      const Trie &implicitImports)
     : m_name(bundleName), m_searchPaths(searchPaths), m_installPaths(installPaths),
       m_supportedImports(supportedImports), m_implicitImports(implicitImports)
 { }
 
 
 QString QmlBundle::name() const
 {
     return m_name;
 }
 
 Trie QmlBundle::installPaths() const
 {
     return m_installPaths;
 }
 
 Trie QmlBundle::searchPaths() const
 {
     return m_searchPaths;
 }
 
 Trie QmlBundle::implicitImports() const
 {
     return m_implicitImports;
 }
 
 
 Trie QmlBundle::supportedImports() const
 {
     return m_supportedImports;
 }
 
 
 void QmlBundle::merge(const QmlBundle &o)
 {
     *this = mergeF(o);
 }
 
 
 void QmlBundle::intersect(const QmlBundle &o)
 {
     *this = intersectF(o);
 }
 
 
 QmlBundle QmlBundle::mergeF(const QmlBundle &o) const
 {
-    return QmlBundle(QString::fromLatin1("(%1)||(%2)").arg(name()).arg(o.name()),
+    return QmlBundle(QString::fromLatin1("(%1)||(%2)").arg(name(), o.name()),
                      searchPaths().mergeF(o.searchPaths()),
                      installPaths().mergeF(o.installPaths()),
                      supportedImports().mergeF(o.supportedImports()),
                      implicitImports().mergeF(o.implicitImports()));
 }
 
 QmlBundle QmlBundle::intersectF(const QmlBundle &o) const
 {
-    return QmlBundle(QString::fromLatin1("(%1)&&(%2)").arg(name()).arg(o.name()),
+    return QmlBundle(QString::fromLatin1("(%1)&&(%2)").arg(name(), o.name()),
                      searchPaths().mergeF(o.searchPaths()),
                      installPaths().mergeF(o.installPaths()),
                      supportedImports().intersectF(o.supportedImports()),
                      implicitImports().mergeF(o.implicitImports()));
 }
 
 bool QmlBundle::isEmpty() const
 {
     return m_implicitImports.isEmpty() && m_installPaths.isEmpty()
             && m_searchPaths.isEmpty() && m_supportedImports.isEmpty();
 }
 
 void QmlBundle::replaceVars(const QHash<QString, QString> &replacements)
 {
     m_implicitImports.replace(replacements);
     m_installPaths.replace(replacements);
     m_searchPaths.replace(replacements);
     m_supportedImports.replace(replacements);
 }
 
 QmlBundle QmlBundle::replaceVarsF(const QHash<QString, QString> &replacements) const
 {
     QmlBundle res(*this);
     res.replaceVars(replacements);
     return res;
 }
 
 bool QmlBundle::writeTo(const QString &path) const
 {
     QFile f(path);
     if (!f.open(QIODevice::WriteOnly | QIODevice::Text))
         return false;
     QTextStream stream(&f);
     return writeTo(stream);
 }
 
 bool QmlBundle::operator==(const QmlBundle &o) const
 {
     return o.implicitImports() == implicitImports()
             && o.installPaths() == installPaths()
             && o.supportedImports() == supportedImports(); // name is not considered
 }
 
 bool QmlBundle::operator!=(const QmlBundle &o) const
 {
     return !((*this) == o);
 }
 
 void QmlBundle::printEscaped(QTextStream &s, const QString &str)
 {
     s << QLatin1Char('"');
     QString::const_iterator i = str.constBegin(), iLast = str.constBegin(),
             iEnd = str.constEnd();
     while (i != iEnd) {
         if ((*i) != QLatin1Char('"')) {
             s << QStringRef(&str, static_cast<int>(iLast - str.constBegin())
                             , static_cast<int>(i - iLast) ).toString()
               << QLatin1Char('\\');
             iLast = i;
         }
         ++i;
     }
     s << QStringRef(&str, static_cast<int>(iLast - str.constBegin())
                     , static_cast<int>(i - iLast) ).toString();
 }
 
 void QmlBundle::writeTrie(QTextStream &stream, const Trie &t, const QString &indent) {
     stream << QLatin1Char('[');
     bool firstLine = true;
     foreach (const QString &i, t.stringList()) {
         if (firstLine)
             firstLine = false;
         else
             stream << QLatin1Char(',');
         stream << QLatin1String("\n") << indent << QLatin1String("    ");
         printEscaped(stream, i);
     }
     stream << QLatin1Char(']');
 }
 
 bool QmlBundle::writeTo(QTextStream &stream, const QString &indent) const
 {
     QString innerIndent = QString::fromLatin1("    ").append(indent);
     stream << indent << QLatin1String("{\n")
            << indent << QLatin1String("    \"name\": ");
     printEscaped(stream, name());
     stream << QLatin1String(",\n")
            << indent << QLatin1String("    \"searchPaths\": ");
     writeTrie(stream, searchPaths(), innerIndent);
     stream << QLatin1String(",\n")
            << indent << QLatin1String("    \"installPaths\": ");
     writeTrie(stream, installPaths(), innerIndent);
     stream << QLatin1String(",\n")
            << indent << QLatin1String("    \"supportedImports\": ");
     writeTrie(stream, supportedImports(), innerIndent);
     stream << QLatin1String(",\n")
            << QLatin1String("    \"implicitImports\": ");
     writeTrie(stream, implicitImports(), innerIndent);
     stream << QLatin1String("\n")
            << indent << QLatin1Char('}');
     return true;
 }
 
 QString QmlBundle::toString(const QString &indent)
 {
     QString res;
     QTextStream s(&res);
     writeTo(s, indent);
     return res;
 }
 
 QStringList QmlBundle::maybeReadTrie(Trie &trie, Utils::JsonObjectValue *config,
                                  const QString &path, const QString &propertyName, bool required)
 {
     QStringList res;
     if (!config->hasMember(propertyName)) {
         if (required)
             res << QString::fromLatin1("Missing required property \"%1\" from %2").arg(propertyName,
                                                                                        path);
         return res;
     }
     Utils::JsonValue *imp0 = config->member(propertyName);
     Utils::JsonArrayValue *imp = ((imp0 != 0) ? imp0->toArray() : 0);
     if (imp != 0) {
         foreach (Utils::JsonValue *v, imp->elements()) {
             Utils::JsonStringValue *impStr = ((v != 0) ? v->toString() : 0);
             if (impStr != 0) {
                 trie.insert(impStr->value());
             } else {
                 res.append(QString::fromLatin1("Expected all elements of array in property \"%1\" "
                                                "to be strings in QmlBundle at %2.")
                            .arg(propertyName, path));
                 break;
             }
         }
     } else {
         res.append(QString::fromLatin1("Expected string array in property \"%1\" in QmlBundle at %2.")
                    .arg(propertyName, path));
     }
     return res;
 }
 
 bool QmlBundle::readFrom(QString path, QStringList *errors)
 {
     Utils::JsonMemoryPool pool;
 
     using namespace Utils;
     QFile f(path);
     if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
         if (errors)
             (*errors) << QString::fromLatin1("Could not open file at %1 .").arg(path);
         return false;
     }
     JsonObjectValue *config = JsonValue::create(QString::fromUtf8(f.readAll()), &pool)->toObject();
     if (config == 0) {
         if (errors)
             (*errors) << QString::fromLatin1("Could not parse json object in file at %1 .").arg(path);
         return false;
     }
     QStringList errs;
     if (config->hasMember(QLatin1String("name"))) {
         JsonValue *n0 = config->member(QLatin1String("name"));
         JsonStringValue *n = ((n0 != 0) ? n0->toString() : 0);
         if (n != 0)
             m_name = n->value();
         else
             errs.append(QString::fromLatin1("Property \"name\" in QmlBundle at %1 is expected "
                                              "to be a string.").arg(path));
     } else {
         errs.append(QString::fromLatin1("Missing required property \"name\" in QmlBundle "
                                          "at %1 .").arg(path));
     }
     errs << maybeReadTrie(m_searchPaths, config, path, QLatin1String("searchPaths"));
     errs << maybeReadTrie(m_installPaths, config, path, QLatin1String("installPaths"));
     errs << maybeReadTrie(m_supportedImports, config, path, QLatin1String("supportedImports")
                              , true);
     errs << maybeReadTrie(m_implicitImports, config, path, QLatin1String("implicitImports"));
     if (errors)
         (*errors) << errs;
     return errs.isEmpty();
 }
 
 QmlBundle QmlLanguageBundles::bundleForLanguage(Dialect l) const
 {
     if (m_bundles.contains(l))
         return m_bundles.value(l);
     return QmlBundle();
 }
 
 void QmlLanguageBundles::mergeBundleForLanguage(Dialect l, const QmlBundle &bundle)
 {
     if (bundle.isEmpty())
         return;
     if (m_bundles.contains(l))
         m_bundles[l].merge(bundle);
     else
         m_bundles.insert(l,bundle);
 }
 
 QList<Dialect> QmlLanguageBundles::languages() const
 {
     return m_bundles.keys();
 }
 
 void QmlLanguageBundles::mergeLanguageBundles(const QmlLanguageBundles &o)
 {
     foreach (Dialect l, o.languages())
         mergeBundleForLanguage(l, o.bundleForLanguage(l));
 }
 
 } // end namespace QmlJS