diff --git a/outputview/outputfilteringstrategies.cpp b/outputview/outputfilteringstrategies.cpp
index 59712d1f82..a328563d35 100644
--- a/outputview/outputfilteringstrategies.cpp
+++ b/outputview/outputfilteringstrategies.cpp
@@ -1,457 +1,457 @@
 /*
     This file is part of KDevelop
     Copyright (C) 2012  Morten Danielsen Volden mvolden2@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, see <http://www.gnu.org/licenses/>.
 */
 
 #include "outputfilteringstrategies.h"
 #include "outputformats.h"
 #include "filtereditem.h"
 #include <util/path.h>
 
 #include <KLocalizedString>
 
 #include <QFileInfo>
 
 #include <algorithm>
 
 namespace KDevelop
 {
 void initializeFilteredItem(FilteredItem& item, const ErrorFormat& filter, const QRegularExpressionMatch& match)
 {
     item.lineNo = match.captured( filter.lineGroup ).toInt() - 1;
     item.columnNo = filter.columnNumber(match);
 }
 
 
 template<typename ErrorFormats>
 FilteredItem match(const ErrorFormats& errorFormats, const QString& line)
 {
     FilteredItem item(line);
     for( const ErrorFormat& curErrFilter : errorFormats ) {
         const auto match = curErrFilter.expression.match(line);
         if( match.hasMatch() ) {
             initializeFilteredItem(item, curErrFilter, match);
             item.url = QUrl::fromUserInput(match.captured( curErrFilter.fileGroup ));
 
             item.type = FilteredItem::ErrorItem;
 
             // Make the item clickable if it comes with the necessary file & line number information
             if (curErrFilter.fileGroup > 0 && curErrFilter.lineGroup > 0) {
                 item.isActivatable = true;
             }
             break;
         }
     }
     return item;
 }
 
 /// --- No filter strategy ---
 
 NoFilterStrategy::NoFilterStrategy()
 {
 }
 
 FilteredItem NoFilterStrategy::actionInLine(const QString& line)
 {
     return FilteredItem( line );
 }
 
 FilteredItem NoFilterStrategy::errorInLine(const QString& line)
 {
     return FilteredItem( line );
 }
 
 /// --- Compiler error filter strategy ---
 
 /// Impl. of CompilerFilterStrategy.
 struct CompilerFilterStrategyPrivate
 {
     CompilerFilterStrategyPrivate(const QUrl& buildDir);
     Path pathForFile( const QString& ) const;
     bool isMultiLineCase(const ErrorFormat& curErrFilter) const;
     void putDirAtEnd(const Path& pathToInsert);
 
     QVector<Path> m_currentDirs;
     Path m_buildDir;
 
     using PositionMap = QHash<Path, int>;
     PositionMap m_positionInCurrentDirs;
 };
 
 CompilerFilterStrategyPrivate::CompilerFilterStrategyPrivate(const QUrl& buildDir)
     : m_buildDir(buildDir)
 {
 }
 
 Path CompilerFilterStrategyPrivate::pathForFile(const QString& filename) const
 {
     QFileInfo fi( filename );
     Path currentPath;
     if( fi.isRelative() ) {
         if( m_currentDirs.isEmpty() ) {
             return Path(m_buildDir, filename );
         }
 
         auto it = m_currentDirs.constEnd() - 1;
         do {
             currentPath = Path(*it, filename);
         } while( (it-- !=  m_currentDirs.constBegin()) && !QFileInfo::exists(currentPath.toLocalFile()) );
 
         return currentPath;
     } else {
         currentPath = Path(filename);
     }
     return currentPath;
 }
 
 bool CompilerFilterStrategyPrivate::isMultiLineCase(const KDevelop::ErrorFormat& curErrFilter) const
 {
     if(curErrFilter.compiler == QLatin1String("gfortran") || curErrFilter.compiler == QLatin1String("cmake")) {
         return true;
     }
     return false;
 }
 
 void CompilerFilterStrategyPrivate::putDirAtEnd(const Path& pathToInsert)
 {
     CompilerFilterStrategyPrivate::PositionMap::iterator it = m_positionInCurrentDirs.find( pathToInsert );
     // Encountered new build directory?
     if (it == m_positionInCurrentDirs.end()) {
         m_currentDirs.push_back( pathToInsert );
         m_positionInCurrentDirs.insert( pathToInsert, m_currentDirs.size() - 1 );
     } else {
         // Build dir already in currentDirs, but move it to back of currentDirs list
         // (this gives us most-recently-used semantics in pathForFile)
         std::rotate(m_currentDirs.begin() + it.value(), m_currentDirs.begin() + it.value() + 1, m_currentDirs.end() );
         it.value() = m_currentDirs.size() - 1;
     }
 }
 
 CompilerFilterStrategy::CompilerFilterStrategy(const QUrl& buildDir)
 : d(new CompilerFilterStrategyPrivate( buildDir ))
 {
 }
 
 CompilerFilterStrategy::~CompilerFilterStrategy()
 {
     delete d;
 }
 
 QVector<QString> CompilerFilterStrategy::getCurrentDirs()
 {
     QVector<QString> ret;
     ret.reserve(d->m_currentDirs.size());
     foreach (const auto& path, d->m_currentDirs) {
         ret << path.pathOrUrl();
     }
     return ret;
 }
 
 FilteredItem CompilerFilterStrategy::actionInLine(const QString& line)
 {
     // A list of filters for possible compiler, linker, and make actions
     static const ActionFormat ACTION_FILTERS[] = {
         ActionFormat( 2,
                       QStringLiteral("(?:^|[^=])\\b(gcc|CC|cc|distcc|c\\+\\+|g\\+\\+|clang(?:\\+\\+)|mpicc|icc|icpc)\\s+.*-c.*[/ '\\\\]+(\\w+\\.(?:cpp|CPP|c|C|cxx|CXX|cs|java|hpf|f|F|f90|F90|f95|F95))")),
         //moc and uic
         ActionFormat( 2, QStringLiteral("/(moc|uic)\\b.*\\s-o\\s([^\\s;]+)")),
         //libtool linking
         ActionFormat( QStringLiteral("libtool"), QStringLiteral("/bin/sh\\s.*libtool.*--mode=link\\s.*\\s-o\\s([^\\s;]+)"), 1 ),
         //unsermake
         ActionFormat( 1, QStringLiteral("^compiling (.*)") ),
         ActionFormat( 2, QStringLiteral("^generating (.*)") ),
         ActionFormat( 2, QStringLiteral("(gcc|cc|c\\+\\+|g\\+\\+|clang(?:\\+\\+)|mpicc|icc|icpc)\\S* (?:\\S* )*-o ([^\\s;]+)")),
         ActionFormat( 2, QStringLiteral("^linking (.*)") ),
         //cmake
         ActionFormat( 1, QStringLiteral("\\[.+%\\] Built target (.*)") ),
         ActionFormat( QStringLiteral("cmake"),
                       QStringLiteral("\\[.+%\\] Building .* object (.*)"), 1 ),
         ActionFormat( 1, QStringLiteral("\\[.+%\\] Generating (.*)") ),
         ActionFormat( 1, QStringLiteral("^Linking (.*)") ),
         ActionFormat( QStringLiteral("cmake"),
                       QStringLiteral("(-- Configuring (done|incomplete)|-- Found|-- Adding|-- Enabling)"), -1 ),
         ActionFormat( 1, QStringLiteral("-- Installing (.*)") ),
         //libtool install
         ActionFormat( {},
                       QStringLiteral("/(?:bin/sh\\s.*mkinstalldirs).*\\s([^\\s;]+)"), 1 ),
         ActionFormat( {},
                       QStringLiteral("/(?:usr/bin/install|bin/sh\\s.*mkinstalldirs|bin/sh\\s.*libtool.*--mode=install).*\\s([^\\s;]+)"), 1 ),
         //dcop
         ActionFormat( QStringLiteral("dcopidl"),
                       QStringLiteral("dcopidl .* > ([^\\s;]+)"), 1 ),
         ActionFormat( QStringLiteral("dcopidl2cpp"),
                       QStringLiteral("dcopidl2cpp (?:\\S* )*([^\\s;]+)"), 1 ),
         // match against Entering directory to update current build dir
         ActionFormat( QStringLiteral("cd"),
                       QStringLiteral("make\\[\\d+\\]: Entering directory (\\`|\\')(.+)'"), 2),
         // waf and scons use the same basic convention as make
         ActionFormat( QStringLiteral("cd"),
                       QStringLiteral("(Waf|scons): Entering directory (\\`|\\')(.+)'"), 3)
     };
 
     FilteredItem item(line);
     for (const auto& curActFilter : ACTION_FILTERS) {
         const auto match = curActFilter.expression.match(line);
         if( match.hasMatch() ) {
             item.type = FilteredItem::ActionItem;
 
             if( curActFilter.tool == QLatin1String("cd") ) {
                 const Path path(match.captured(curActFilter.fileGroup));
                 d->m_currentDirs.push_back( path );
                 d->m_positionInCurrentDirs.insert( path , d->m_currentDirs.size() - 1 );
             }
 
             // Special case for cmake: we parse the "Compiling <objectfile>" expression
             // and use it to find out about the build paths encountered during a build.
             // They are later searched by pathForFile to find source files corresponding to
             // compiler errors.
             // Note: CMake objectfile has the format: "/path/to/four/CMakeFiles/file.o"
             if ( curActFilter.fileGroup != -1 && curActFilter.tool == QLatin1String("cmake") && line.contains(QStringLiteral("Building"))) {
                 const auto objectFile = match.captured(curActFilter.fileGroup);
                 const auto dir = objectFile.section(QStringLiteral("CMakeFiles/"), 0, 0);
                 d->putDirAtEnd(Path(d->m_buildDir, dir));
             }
             break;
         }
     }
     return item;
 }
 
 FilteredItem CompilerFilterStrategy::errorInLine(const QString& line)
 {
     // All the possible string that indicate an error if we via Regex have been able to
     // extract file and linenumber from a given outputline
     // TODO: This seems clumsy -- and requires another scan of the line.
     // Merge this information into ErrorFormat? --Kevin
     using Indicator = QPair<QString, FilteredItem::FilteredOutputItemType>;
     static const Indicator INDICATORS[] = {
         // ld
         Indicator(QStringLiteral("undefined reference"), FilteredItem::ErrorItem),
         Indicator(QStringLiteral("undefined symbol"), FilteredItem::ErrorItem),
         Indicator(QStringLiteral("ld: cannot find"), FilteredItem::ErrorItem),
         Indicator(QStringLiteral("no such file"), FilteredItem::ErrorItem),
         // gcc
         Indicator(QStringLiteral("error"), FilteredItem::ErrorItem),
         // generic
         Indicator(QStringLiteral("warning"), FilteredItem::WarningItem),
         Indicator(QStringLiteral("info"), FilteredItem::InformationItem),
         Indicator(QStringLiteral("note"), FilteredItem::InformationItem),
     };
 
     // A list of filters for possible compiler, linker, and make errors
     static const ErrorFormat ERROR_FILTERS[] = {
 #ifdef Q_OS_WIN
         // MSVC
         ErrorFormat( QStringLiteral("^([a-zA-Z]:\\\\.+)\\(([1-9][0-9]*)\\): ((?:error|warning) .+\\:).*$"), 1, 2, 3 ),
 #endif
         // GCC - another case, eg. for #include "pixmap.xpm" which does not exists
         ErrorFormat( QStringLiteral("^([^:\\t]+):([0-9]+):([0-9]+):([^0-9]+)"), 1, 2, 4, 3 ),
         // ant
         ErrorFormat( QStringLiteral("\\[javac\\][\\s]+([^:\\t]+):([0-9]+): (warning: .*|error: .*)"), 1, 2, 3, QStringLiteral("javac")),
         // GCC
         ErrorFormat( QStringLiteral("^([^:\\t]+):([0-9]+):([^0-9]+)"), 1, 2, 3 ),
         // GCC
-        ErrorFormat( QStringLiteral("^(In file included from |[ ]+from )([^: \\t]+):([0-9]+)(:|,)(|[0-9]+)"), 2, 3, 5 ),
+        ErrorFormat( QStringLiteral("^(In file included from |[ ]+from )([^:\\t]+):([0-9]+)(:|,)(|[0-9]+)"), 2, 3, 5 ),
         // ICC
-        ErrorFormat( QStringLiteral("^([^: \\t]+)\\(([0-9]+)\\):([^0-9]+)"), 1, 2, 3, QStringLiteral("intel") ),
+        ErrorFormat( QStringLiteral("^([^:\\t]+)\\(([0-9]+)\\):([^0-9]+)"), 1, 2, 3, QStringLiteral("intel") ),
         //libtool link
         ErrorFormat( QStringLiteral("^(libtool):( link):( warning): "), 0, 0, 0 ),
         // make
         ErrorFormat( QStringLiteral("No rule to make target"), 0, 0, 0 ),
         // cmake
-        ErrorFormat( QStringLiteral("^([^: \\t]+):([0-9]+):"), 1, 2, 0, QStringLiteral("cmake") ),
+        ErrorFormat( QStringLiteral("^([^:\\t]+):([0-9]+):"), 1, 2, 0, QStringLiteral("cmake") ),
         // cmake
         ErrorFormat( QStringLiteral("CMake (Error|Warning) (|\\([a-zA-Z]+\\) )(in|at) ([^:]+):($|[0-9]+)"), 4, 5, 1, QStringLiteral("cmake") ),
         // cmake/automoc
         // example: AUTOMOC: error: /foo/bar.cpp The file includes (...),
         // example: AUTOMOC: error: /foo/bar.cpp: The file includes (...)
         // note: ':' after file name isn't always appended, see http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=317d8498aa02c9f486bf5071963bb2034777cdd6
         // example: AUTOGEN: error: /foo/bar.cpp: The file includes (...)
         // note: AUTOMOC got renamed to AUTOGEN at some point
         ErrorFormat( QStringLiteral("^(AUTOMOC|AUTOGEN): error: ([^:]+):? (The file .*)$"), 2, 0, 0 ),
         // via qt4_automoc
         // example: automoc4: The file "/foo/bar.cpp" includes the moc file "bar1.moc", but ...
         ErrorFormat( QStringLiteral("^automoc4: The file \"([^\"]+)\" includes the moc file"), 1, 0, 0 ),
         // Fortran
         ErrorFormat( QStringLiteral("\"(.*)\", line ([0-9]+):(.*)"), 1, 2, 3 ),
         // GFortran
         ErrorFormat( QStringLiteral("^(.*):([0-9]+)\\.([0-9]+):(.*)"), 1, 2, 4, QStringLiteral("gfortran"), 3 ),
         // Jade
-        ErrorFormat( QStringLiteral("^[a-zA-Z]+:([^: \\t]+):([0-9]+):[0-9]+:[a-zA-Z]:(.*)"), 1, 2, 3 ),
+        ErrorFormat( QStringLiteral("^[a-zA-Z]+:([^:\\t]+):([0-9]+):[0-9]+:[a-zA-Z]:(.*)"), 1, 2, 3 ),
         // ifort
         ErrorFormat( QStringLiteral("^fortcom: (.*): (.*), line ([0-9]+):(.*)"), 2, 3, 1, QStringLiteral("intel") ),
         // PGI
         ErrorFormat( QStringLiteral("PGF9(.*)-(.*)-(.*)-(.*) \\((.*): ([0-9]+)\\)"), 5, 6, 4, QStringLiteral("pgi") ),
         // PGI (2)
         ErrorFormat( QStringLiteral("PGF9(.*)-(.*)-(.*)-Symbol, (.*) \\((.*)\\)"), 5, 5, 4, QStringLiteral("pgi") ),
     };
 
     FilteredItem item(line);
     for (const auto& curErrFilter : ERROR_FILTERS) {
         const auto match = curErrFilter.expression.match(line);
         if( match.hasMatch() && !( line.contains( QLatin1String("Each undeclared identifier is reported only once") )
                                || line.contains( QLatin1String("for each function it appears in.") ) ) )
         {
             if(curErrFilter.fileGroup > 0) {
                 if( curErrFilter.compiler == QLatin1String("cmake") ) { // Unfortunately we cannot know if an error or an action comes first in cmake, and therefore we need to do this
                     if( d->m_currentDirs.empty() ) {
                         d->putDirAtEnd( d->m_buildDir.parent() );
                     }
                 }
                 item.url = d->pathForFile( match.captured( curErrFilter.fileGroup ) ).toUrl();
             }
             initializeFilteredItem(item, curErrFilter, match);
 
             const QString txt = match.captured(curErrFilter.textGroup);
 
             // Find the indicator which happens most early.
             int earliestIndicatorIdx = txt.length();
             for (const auto& curIndicator : INDICATORS) {
                 int curIndicatorIdx = txt.indexOf(curIndicator.first, 0, Qt::CaseInsensitive);
                 if((curIndicatorIdx >= 0) && (earliestIndicatorIdx > curIndicatorIdx)) {
                     earliestIndicatorIdx = curIndicatorIdx;
                     item.type = curIndicator.second;
                 }
             }
 
             // Make the item clickable if it comes with the necessary file information
             if (item.url.isValid()) {
                 item.isActivatable = true;
                 if(item.type == FilteredItem::InvalidItem) {
                     // If there are no error indicators in the line
                     // maybe this is a multiline case
                     if(d->isMultiLineCase(curErrFilter)) {
                         item.type = FilteredItem::ErrorItem;
                     } else {
                         // Okay so we couldn't find anything to indicate an error, but we have file and lineGroup
                         // Lets keep this item clickable and indicate this to the user.
                         item.type = FilteredItem::InformationItem;
                     }
                 }
             }
             break;
         }
     }
     return item;
 }
 
 
 /// --- Script error filter strategy ---
 
 ScriptErrorFilterStrategy::ScriptErrorFilterStrategy()
 {
 }
 
 FilteredItem ScriptErrorFilterStrategy::actionInLine(const QString& line)
 {
     return FilteredItem(line);
 }
 
 FilteredItem ScriptErrorFilterStrategy::errorInLine(const QString& line)
 {
     // A list of filters for possible Python and PHP errors
     static const ErrorFormat SCRIPT_ERROR_FILTERS[] = {
         ErrorFormat( QStringLiteral("^  File \"(.*)\", line ([0-9]+)(.*$|, in(.*)$)"), 1, 2, -1 ),
         ErrorFormat( QStringLiteral("^.*(/.*):([0-9]+).*$"), 1, 2, -1 ),
         ErrorFormat( QStringLiteral("^.* in (/.*) on line ([0-9]+).*$"), 1, 2, -1 )
     };
 
     return match(SCRIPT_ERROR_FILTERS, line);
 }
 
 /// --- Native application error filter strategy ---
 
 NativeAppErrorFilterStrategy::NativeAppErrorFilterStrategy()
 {
 }
 
 FilteredItem NativeAppErrorFilterStrategy::actionInLine(const QString& line)
 {
     return FilteredItem(line);
 }
 
 FilteredItem NativeAppErrorFilterStrategy::errorInLine(const QString& line)
 {
     static const ErrorFormat NATIVE_APPLICATION_ERROR_FILTERS[] = {
         // BEGIN: C++
 
         // a.out: test.cpp:5: int main(): Assertion `false' failed.
         ErrorFormat(QStringLiteral("^.+: (.+):([1-9][0-9]*): .*: Assertion `.*' failed\\.$"), 1, 2, -1),
 
         // END: C++
 
         // BEGIN: Qt
 
         // Note: Scan the whole line for catching Qt runtime warnings (-> no ^$)
         // Reasoning: With QT_MESSAGE_PATTERN you can configure the output to your desire,
         // which means the output could be arbitrarily prefixed or suffixed with other content
 
         // QObject::connect related errors, also see err_method_notfound() in qobject.cpp
         // QObject::connect: No such slot Foo::bar() in /foo/bar.cpp:313
         ErrorFormat(QStringLiteral("QObject::connect: (?:No such|Parentheses expected,) (?:slot|signal) [^ ]* in (.*):([0-9]+)"), 1, 2, -1),
         // ASSERT: "errors().isEmpty()" in file /foo/bar.cpp, line 49
         ErrorFormat(QStringLiteral("ASSERT: \"(.*)\" in file (.*), line ([0-9]+)"), 2, 3, -1),
         // Catch:
         // FAIL!  : FooTest::testBar() Compared pointers are not the same
         //    Actual   ...
         //    Expected ...
         //    Loc: [/foo/bar.cpp(33)]
         //
         // Do *not* catch:
         //    ...
         //    Loc: [Unknown file(0)]
         ErrorFormat(QStringLiteral("   Loc: \\[(.*)\\(([1-9][0-9]*)\\)\\]"), 1, 2, -1),
 
         // file:///path/to/foo.qml:7:1: Bar is not a type
         // file:///path/to/foo.qml:49:5: QML Row: Binding loop detected for property "height"
         ErrorFormat(QStringLiteral("(file:\\/\\/(?:[^:]+)):([1-9][0-9]*):([1-9][0-9]*): (.*) (?:is not a type|is ambiguous|is instantiated recursively|Binding loop detected)"), 1, 2, -1, 3),
 
         // file:///path/to/foo.qml:52: TypeError: Cannot read property 'height' of null
         ErrorFormat(QStringLiteral("(file:\\/\\/(?:[^:]+)):([1-9][0-9]*): ([a-zA-Z]+)Error"), 1, 2, -1),
 
         // END: Qt
     };
 
     return match(NATIVE_APPLICATION_ERROR_FILTERS, line);
 }
 
 /// --- Static Analysis filter strategy ---
 
 StaticAnalysisFilterStrategy::StaticAnalysisFilterStrategy()
 {
 }
 
 FilteredItem StaticAnalysisFilterStrategy::actionInLine(const QString& line)
 {
     return FilteredItem(line);
 }
 
 FilteredItem StaticAnalysisFilterStrategy::errorInLine(const QString& line)
 {
     // A list of filters for static analysis tools (krazy2, cppcheck)
     static const ErrorFormat STATIC_ANALYSIS_FILTERS[] = {
         // CppCheck
         ErrorFormat( QStringLiteral("^\\[(.*):([0-9]+)\\]:(.*)"), 1, 2, 3 ),
         // krazy2
         ErrorFormat( QStringLiteral("^\\t([^:]+).*line#([0-9]+).*"), 1, 2, -1 ),
         // krazy2 without line info
         ErrorFormat( QStringLiteral("^\\t(.*): missing license"), 1, -1, -1 )
     };
 
     return match(STATIC_ANALYSIS_FILTERS, line);
 }
 
 }
diff --git a/outputview/tests/test_filteringstrategy.cpp b/outputview/tests/test_filteringstrategy.cpp
index 492a4b6cde..16b00a8194 100644
--- a/outputview/tests/test_filteringstrategy.cpp
+++ b/outputview/tests/test_filteringstrategy.cpp
@@ -1,497 +1,535 @@
 /*
     This file is part of KDevelop
     Copyright 2012 Milian Wolff <mail@milianw.de>
     Copyright (C) 2012  Morten Danielsen Volden mvolden2@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, see <http://www.gnu.org/licenses/>.
 */
 #include "test_filteringstrategy.h"
 #include "testlinebuilderfunctions.h"
 
 #include <outputview/outputfilteringstrategies.h>
 #include <outputview/filtereditem.h>
 #include <language/interfaces/quickopenfilter.h>
 
 using namespace KDevelop;
 
 QTEST_GUILESS_MAIN(TestFilteringStrategy)
 
 namespace QTest {
 
 template<>
 inline char* toString(const FilteredItem::FilteredOutputItemType& type)
 {
     switch (type) {
         case FilteredItem::ActionItem:
             return qstrdup("ActionItem");
         case FilteredItem::CustomItem:
             return qstrdup("CustomItem");
         case FilteredItem::ErrorItem:
             return qstrdup("ErrorItem");
         case FilteredItem::InformationItem:
             return qstrdup("InformationItem");
         case FilteredItem::InvalidItem:
             return qstrdup("InvalidItem");
         case FilteredItem::StandardItem:
             return qstrdup("StandardItem");
         case FilteredItem::WarningItem:
             return qstrdup("WarningItem");
     }
     return qstrdup("unknown");
 }
 
+inline QTestData& newRowForPathType(const char *dataTag, TestPathType pathType)
+{
+    if (pathType == UnixFilePathWithSpaces) {
+        return QTest::newRow(QString(QLatin1String(dataTag)+QLatin1String("-ws")).toUtf8().constData());
+    }
+    return QTest::newRow(dataTag);
+}
+
 }
 
 void TestFilteringStrategy::testNoFilterStrategy_data()
 {
     QTest::addColumn<QString>("line");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expected");
 
     QTest::newRow("cppcheck-info-line")
     << buildCppCheckInformationLine() << FilteredItem::InvalidItem;
-    QTest::newRow("cppcheck-error-line")
-    << buildCppCheckErrorLine() << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-line")
-    << buildCompilerLine() << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-error-line")
-    << buildCompilerErrorLine() << FilteredItem::InvalidItem;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("cppcheck-error-line", pathType)
+        << buildCppCheckErrorLine(pathType) << FilteredItem::InvalidItem;
+        QTest::newRowForPathType("compiler-line", pathType)
+        << buildCompilerLine(pathType) << FilteredItem::InvalidItem;
+        QTest::newRowForPathType("compiler-error-line", pathType)
+        << buildCompilerErrorLine(pathType) << FilteredItem::InvalidItem;
+    }
     QTest::newRow("compiler-action-line")
     << buildCompilerActionLine() << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-information-line")
-    << buildCompilerInformationLine() << FilteredItem::InvalidItem;
-    QTest::newRow("python-error-line")
-    << buildPythonErrorLine() << FilteredItem::InvalidItem;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("compiler-information-line", pathType)
+        << buildCompilerInformationLine(pathType) << FilteredItem::InvalidItem;
+        QTest::newRowForPathType("python-error-line", pathType)
+        << buildPythonErrorLine(pathType) << FilteredItem::InvalidItem;
+    }
 }
 
 void TestFilteringStrategy::testNoFilterStrategy()
 {
     QFETCH(QString, line);
     QFETCH(FilteredItem::FilteredOutputItemType, expected);
     NoFilterStrategy testee;
     FilteredItem item1 = testee.errorInLine(line);
     QCOMPARE(item1.type, expected);
     item1 = testee.actionInLine(line);
     QCOMPARE(item1.type, expected);
 }
 
 void TestFilteringStrategy::testCompilerFilterStrategy_data()
 {
     QTest::addColumn<QString>("line");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expectedError");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expectedAction");
+    QTest::addColumn<TestPathType>("pathType");
 
     QTest::newRow("cppcheck-info-line")
-    << buildCppCheckInformationLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("cppcheck-error-line")
-    << buildCppCheckErrorLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-line")
-    << buildCompilerLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-error-line")
-    << buildCompilerErrorLine() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-information-line")
-    << buildCompilerInformationLine() << FilteredItem::InformationItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-information-line2")
-    << buildInfileIncludedFromFirstLine() << FilteredItem::InformationItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-information-line3")
-    << buildInfileIncludedFromSecondLine() << FilteredItem::InformationItem << FilteredItem::InvalidItem;
+    << buildCppCheckInformationLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("cppcheck-error-line", pathType)
+        << buildCppCheckErrorLine(pathType) << FilteredItem::InvalidItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("compiler-line", pathType)
+        << buildCompilerLine(pathType) << FilteredItem::InvalidItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("compiler-error-line", pathType)
+        << buildCompilerErrorLine(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("compiler-information-line", pathType)
+        << buildCompilerInformationLine(pathType) << FilteredItem::InformationItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("compiler-information-line2", pathType)
+        << buildInfileIncludedFromFirstLine(pathType) << FilteredItem::InformationItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("compiler-information-line3", pathType)
+        << buildInfileIncludedFromSecondLine(pathType) << FilteredItem::InformationItem << FilteredItem::InvalidItem << pathType;
+    }
     QTest::newRow("cmake-error-line1")
-    << "CMake Error at CMakeLists.txt:2 (cmake_minimum_required):" << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
+    << "CMake Error at CMakeLists.txt:2 (cmake_minimum_required):" << FilteredItem::ErrorItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
     QTest::newRow("cmake-error-multiline1")
-    << "CMake Error: Error in cmake code at" << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("cmake-error-multiline2")
-    << buildCmakeConfigureMultiLine() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
+    << "CMake Error: Error in cmake code at" << FilteredItem::InvalidItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("cmake-error-multiline2", pathType)
+        << buildCmakeConfigureMultiLine(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem << pathType;
+    }
     QTest::newRow("cmake-warning-line")
-    << "CMake Warning (dev) in CMakeLists.txt:" << FilteredItem::WarningItem << FilteredItem::InvalidItem;
+    << "CMake Warning (dev) in CMakeLists.txt:" << FilteredItem::WarningItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
     QTest::newRow("cmake-automoc-error")
-    << "AUTOMOC: error: /foo/bar.cpp The file includes the moc file \"moc_bar1.cpp\"" << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
+    << "AUTOMOC: error: /foo/bar.cpp The file includes the moc file \"moc_bar1.cpp\"" << FilteredItem::ErrorItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
     QTest::newRow("cmake-automoc4-error")
-    << "automoc4: The file \"/foo/bar.cpp\" includes the moc file \"bar1.moc\"" << FilteredItem::InformationItem << FilteredItem::InvalidItem;
+    << "automoc4: The file \"/foo/bar.cpp\" includes the moc file \"bar1.moc\"" << FilteredItem::InformationItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
     QTest::newRow("cmake-autogen-error")
-    << "AUTOGEN: error: /foo/bar.cpp The file includes the moc file \"moc_bar1.cpp\"" << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
+    << "AUTOGEN: error: /foo/bar.cpp The file includes the moc file \"moc_bar1.cpp\"" << FilteredItem::ErrorItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
     QTest::newRow("linker-action-line")
-    << "linking testCustombuild (g++)" << FilteredItem::InvalidItem << FilteredItem::ActionItem;
-    QTest::newRow("linker-error-line")
-    << buildLinkerErrorLine() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
-    QTest::newRow("python-error-line")
-    << buildPythonErrorLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
+    << "linking testCustombuild (g++)" << FilteredItem::InvalidItem << FilteredItem::ActionItem << UnixFilePathNoSpaces;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("linker-error-line", pathType)
+        << buildLinkerErrorLine(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("python-error-line", pathType)
+        << buildPythonErrorLine(pathType) << FilteredItem::InvalidItem << FilteredItem::InvalidItem << pathType;
+    }
 }
 
 void TestFilteringStrategy::testCompilerFilterStrategy()
 {
     QFETCH(QString, line);
     QFETCH(FilteredItem::FilteredOutputItemType, expectedError);
     QFETCH(FilteredItem::FilteredOutputItemType, expectedAction);
-    QUrl projecturl = QUrl::fromLocalFile( projectPath() );
+    QFETCH(TestPathType, pathType);
+
+    QUrl projecturl = QUrl::fromLocalFile( projectPath(pathType) );
     CompilerFilterStrategy testee(projecturl);
     FilteredItem item1 = testee.errorInLine(line);
     QCOMPARE(item1.type, expectedError);
     item1 = testee.actionInLine(line);
     QCOMPARE(item1.type, expectedAction);
 }
 
 void TestFilteringStrategy::testCompilerFilterstrategyMultipleKeywords_data()
 {
     QTest::addColumn<QString>("line");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expectedError");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expectedAction");
 
     QTest::newRow("warning-containing-error-word")
     << "RingBuffer.cpp:64:6: warning: unused parameter ‘errorItem’ [-Wunused-parameter]"
     << FilteredItem::WarningItem << FilteredItem::InvalidItem;
     QTest::newRow("error-containing-info-word")
     << "NodeSet.hpp:89:27: error: ‘Info’ was not declared in this scope"
     << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
     QTest::newRow("warning-in-filename-containing-error-word")
     << "ErrorHandling.cpp:100:56: warning: unused parameter ‘item’ [-Wunused-parameter]"
     << FilteredItem::WarningItem << FilteredItem::InvalidItem;
     QTest::newRow("error-in-filename-containing-warning-word")
     << "WarningHandling.cpp:100:56: error: ‘Item’ was not declared in this scope"
     << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
 }
 
 void TestFilteringStrategy::testCompilerFilterstrategyMultipleKeywords()
 {
     QFETCH(QString, line);
     QFETCH(FilteredItem::FilteredOutputItemType, expectedError);
     QFETCH(FilteredItem::FilteredOutputItemType, expectedAction);
     QUrl projecturl = QUrl::fromLocalFile( projectPath() );
     CompilerFilterStrategy testee(projecturl);
     FilteredItem item1 = testee.errorInLine(line);
     QCOMPARE(item1.type, expectedError);
     item1 = testee.actionInLine(line);
     QCOMPARE(item1.type, expectedAction);
 }
 
 void TestFilteringStrategy::testScriptErrorFilterStrategy_data()
 {
     QTest::addColumn<QString>("line");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expectedError");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expectedAction");
 
     QTest::newRow("cppcheck-info-line")
     << buildCppCheckInformationLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("cppcheck-error-line")
-    << buildCppCheckErrorLine() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-line")
-    << buildCompilerLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-error-line")
-    << buildCompilerErrorLine() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("cppcheck-error-line", pathType)
+        << buildCppCheckErrorLine(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
+        QTest::newRowForPathType("compiler-line", pathType)
+        << buildCompilerLine(pathType) << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
+        QTest::newRowForPathType("compiler-error-line", pathType)
+        << buildCompilerErrorLine(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
+    }
     QTest::newRow("compiler-action-line")
     << "linking testCustombuild (g++)" << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("python-error-line")
-    << buildPythonErrorLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("python-error-line", pathType)
+        << buildPythonErrorLine(pathType) << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
+    }
 }
 
 void TestFilteringStrategy::testScriptErrorFilterStrategy()
 {
     QFETCH(QString, line);
     QFETCH(FilteredItem::FilteredOutputItemType, expectedError);
     QFETCH(FilteredItem::FilteredOutputItemType, expectedAction);
     ScriptErrorFilterStrategy testee;
     FilteredItem item1 = testee.errorInLine(line);
     QCOMPARE(item1.type, expectedError);
     item1 = testee.actionInLine(line);
     QCOMPARE(item1.type, expectedAction);
 }
 
 void TestFilteringStrategy::testNativeAppErrorFilterStrategy_data()
 {
     QTest::addColumn<QString>("line");
     QTest::addColumn<QString>("file");
     QTest::addColumn<int>("lineNo");
     QTest::addColumn<int>("column");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("itemtype");
 
     // BEGIN: C++
     QTest::newRow("cassert")
         << "a.out: /foo/bar/test.cpp:5: int main(): Assertion `false' failed."
         << "/foo/bar/test.cpp"
         << 4 << 0 << FilteredItem::ErrorItem;
     // END: C++
 
     // BEGIN: Qt
     // TODO: qt-connect-* and friends shouldn't be error items but warnings items instead
     // this needs refactoring in outputfilteringstrategies, though...
     QTest::newRow("qt-connect-nosuch-slot")
         << "QObject::connect: No such slot Foo::bar() in /foo/bar.cpp:313"
         << "/foo/bar.cpp"
         << 312 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qt-connect-nosuch-signal")
         << "QObject::connect: No such signal Foo::bar() in /foo/bar.cpp:313"
         << "/foo/bar.cpp"
         << 312 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qt-connect-parentheses-slot")
         << "QObject::connect: Parentheses expected, slot Foo::bar() in /foo/bar.cpp:313"
         << "/foo/bar.cpp"
         << 312 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qt-connect-parentheses-signal")
         << "QObject::connect: Parentheses expected, signal Foo::bar() in /foo/bar.cpp:313"
         << "/foo/bar.cpp"
         << 312 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qt-assert")
         << "ASSERT: \"errors().isEmpty()\" in file /tmp/foo/bar.cpp, line 49"
         << "/tmp/foo/bar.cpp"
         << 48 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qttest-assert")
         << "QFATAL : FooTest::testBar() ASSERT: \"index.isValid()\" in file /foo/bar.cpp, line 32"
         << "/foo/bar.cpp"
         << 31 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qttest-loc")
         << "   Loc: [/foo/bar.cpp(33)]"
         << "/foo/bar.cpp"
         << 32 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qttest-loc-nocatch")
         << "   Loc: [Unknown file(0)]"
         << ""
         << -1 << -1 << FilteredItem::InvalidItem;
     QTest::newRow("qml-import-unix")
         << "file:///path/to/foo.qml:7:1: Bar is not a type"
         << "/path/to/foo.qml"
         << 6 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qml-import-unix1")
         << "file:///path/to/foo.qml:7:1: Bar is ambiguous. Found in A and in B"
         << "/path/to/foo.qml"
         << 6 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qml-import-unix2")
         << "file:///path/to/foo.qml:7:1: Bar is instantiated recursively"
         << "/path/to/foo.qml"
         << 6 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qml-typeerror")
         << "file:///path/to/foo.qml:7: TypeError: Cannot read property 'height' of null"
         << "/path/to/foo.qml"
         << 6 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qml-referenceerror")
         << "file:///path/to/foo.qml:7: ReferenceError: readOnly is not defined"
         << "/path/to/foo.qml"
         << 6 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("qml-bindingloop")
         << "file:///path/to/foo.qml:7:5: QML Row: Binding loop detected for property \"height\""
         << "/path/to/foo.qml"
         << 6 << 4 << FilteredItem::ErrorItem;
     // END: Qt
 }
 
 void TestFilteringStrategy::testNativeAppErrorFilterStrategy()
 {
     QFETCH(QString, line);
     QFETCH(QString, file);
     QFETCH(int, lineNo);
     QFETCH(int, column);
     QFETCH(FilteredItem::FilteredOutputItemType, itemtype);
     NativeAppErrorFilterStrategy testee;
     FilteredItem item = testee.errorInLine(line);
     QCOMPARE(item.url.path(), file);
     QCOMPARE(item.lineNo , lineNo);
     QCOMPARE(item.columnNo , column);
     QCOMPARE(item.type , itemtype);
 }
 
 void TestFilteringStrategy::testStaticAnalysisFilterStrategy_data()
 {
     QTest::addColumn<QString>("line");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expectedError");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("expectedAction");
+    QTest::addColumn<TestPathType>("pathType");
 
     QTest::newRow("cppcheck-info-line")
-    << buildCppCheckInformationLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("cppcheck-error-line")
-    << buildCppCheckErrorLine() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
-    QTest::newRow("krazy2-error-line")
-    << buildKrazyErrorLine() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
-    QTest::newRow("krazy2-error-line-two-colons")
-    << buildKrazyErrorLine2() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
-    QTest::newRow("krazy2-error-line-error-description")
-    << buildKrazyErrorLine3() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
-    QTest::newRow("krazy2-error-line-wo-line-info")
-    << buildKrazyErrorLineNoLineInfo() << FilteredItem::ErrorItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-line")
-    << buildCompilerLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("compiler-error-line")
-    << buildCompilerErrorLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
+    << buildCppCheckInformationLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("cppcheck-error-line", pathType)
+        << buildCppCheckErrorLine(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem << pathType;;
+        QTest::newRowForPathType("krazy2-error-line", pathType)
+        << buildKrazyErrorLine(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("krazy2-error-line-two-colons", pathType)
+        << buildKrazyErrorLine2(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("krazy2-error-line-error-description", pathType)
+        << buildKrazyErrorLine3(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("krazy2-error-line-wo-line-info", pathType)
+        << buildKrazyErrorLineNoLineInfo(pathType) << FilteredItem::ErrorItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("compiler-line", pathType)
+        << buildCompilerLine(pathType) << FilteredItem::InvalidItem << FilteredItem::InvalidItem << pathType;
+        QTest::newRowForPathType("compiler-error-line", pathType)
+        << buildCompilerErrorLine(pathType) << FilteredItem::InvalidItem << FilteredItem::InvalidItem << pathType;
+    }
     QTest::newRow("compiler-action-line")
-    << "linking testCustombuild (g++)" << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
-    QTest::newRow("python-error-line")
-    << buildPythonErrorLine() << FilteredItem::InvalidItem << FilteredItem::InvalidItem;
+    << "linking testCustombuild (g++)" << FilteredItem::InvalidItem << FilteredItem::InvalidItem << UnixFilePathNoSpaces;
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        QTest::newRowForPathType("python-error-line", pathType)
+        << buildPythonErrorLine(pathType) << FilteredItem::InvalidItem << FilteredItem::InvalidItem << pathType;
+    }
 }
 
 void TestFilteringStrategy::testStaticAnalysisFilterStrategy()
 {
-    // Test that url's are extracted correctly as well
-    QString referencePath = projectPath() + "main.cpp";
-
     QFETCH(QString, line);
     QFETCH(FilteredItem::FilteredOutputItemType, expectedError);
     QFETCH(FilteredItem::FilteredOutputItemType, expectedAction);
+    QFETCH(TestPathType, pathType);
+
+    // Test that url's are extracted correctly as well
+    QString referencePath = projectPath(pathType) + "main.cpp";
+
     StaticAnalysisFilterStrategy testee;
     FilteredItem item1 = testee.errorInLine(line);
     QString extractedPath = item1.url.toLocalFile();
     QVERIFY((item1.type != FilteredItem::ErrorItem) || ( extractedPath == referencePath));
     QCOMPARE(item1.type, expectedError);
     item1 = testee.actionInLine(line);
     QCOMPARE(item1.type, expectedAction);
 }
 
 void TestFilteringStrategy::testCompilerFilterstrategyUrlFromAction_data()
 {
     QTest::addColumn<QString>("line");
     QTest::addColumn<QString>("expectedLastDir");
-    QString basepath = projectPath();
-
-    QTest::newRow("cmake-line1")
-    << "[ 25%] Building CXX object path/to/one/CMakeFiles/file.o" << QString( basepath + "/path/to/one" );
-    QTest::newRow("cmake-line2")
-    << "[ 26%] Building CXX object path/to/two/CMakeFiles/file.o" << QString( basepath + "/path/to/two");
-    QTest::newRow("cmake-line3")
-    << "[ 26%] Building CXX object path/to/three/CMakeFiles/file.o" << QString( basepath + "/path/to/three");
-    QTest::newRow("cmake-line4")
-    << "[ 26%] Building CXX object path/to/four/CMakeFiles/file.o" << QString( basepath + "/path/to/four");
-    QTest::newRow("cmake-line5")
-    << "[ 26%] Building CXX object path/to/two/CMakeFiles/file.o" << QString( basepath + "/path/to/two");
-    QTest::newRow("cd-line6")
-    << QString("make[4]: Entering directory '" + basepath + "/path/to/one/'") << QString( basepath + "/path/to/one");
-    QTest::newRow("waf-cd")
-    << QString("Waf: Entering directory `" + basepath + "/path/to/two/'") << QString( basepath + "/path/to/two");
-    QTest::newRow("cmake-line7")
-    << QStringLiteral("[ 50%] Building CXX object CMakeFiles/testdeque.dir/RingBuffer.cpp.o") << QString( basepath);
+    QTest::addColumn<TestPathType>("pathType");
+
+    for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+        const QString basepath = projectPath(pathType);
+
+        QTest::newRowForPathType("cmake-line1", pathType)
+        << "[ 25%] Building CXX object path/to/one/CMakeFiles/file.o" << QString( basepath + "/path/to/one" ) << pathType;
+        QTest::newRowForPathType("cmake-line2", pathType)
+        << "[ 26%] Building CXX object path/to/two/CMakeFiles/file.o" << QString( basepath + "/path/to/two") << pathType;
+        QTest::newRowForPathType("cmake-line3", pathType)
+        << "[ 26%] Building CXX object path/to/three/CMakeFiles/file.o" << QString( basepath + "/path/to/three") << pathType;
+        QTest::newRowForPathType("cmake-line4", pathType)
+        << "[ 26%] Building CXX object path/to/four/CMakeFiles/file.o" << QString( basepath + "/path/to/four") << pathType;
+        QTest::newRowForPathType("cmake-line5", pathType)
+        << "[ 26%] Building CXX object path/to/two/CMakeFiles/file.o" << QString( basepath + "/path/to/two") << pathType;
+        QTest::newRowForPathType("cd-line6", pathType)
+        << QString("make[4]: Entering directory '" + basepath + "/path/to/one/'") << QString( basepath + "/path/to/one") << pathType;
+        QTest::newRowForPathType("waf-cd", pathType)
+        << QString("Waf: Entering directory `" + basepath + "/path/to/two/'") << QString( basepath + "/path/to/two") << pathType;
+        QTest::newRowForPathType("cmake-line7", pathType)
+        << QStringLiteral("[ 50%] Building CXX object CMakeFiles/testdeque.dir/RingBuffer.cpp.o") << QString( basepath) << pathType;
+    }
 }
 
 void TestFilteringStrategy::testCompilerFilterstrategyUrlFromAction()
 {
     QFETCH(QString, line);
     QFETCH(QString, expectedLastDir);
-    QUrl projecturl = QUrl::fromLocalFile( projectPath() );
-    static CompilerFilterStrategy testee(projecturl);
+    QFETCH(TestPathType, pathType);
+
+    QUrl projecturl = QUrl::fromLocalFile( projectPath(pathType) );
+    CompilerFilterStrategy testee(projecturl);
     FilteredItem item1 = testee.actionInLine(line);
     int last = testee.getCurrentDirs().size() - 1;
     QCOMPARE(testee.getCurrentDirs().at(last), expectedLastDir);
 }
 
 void TestFilteringStrategy::benchMarkCompilerFilterAction()
 {
     QString projecturl = projectPath();
     QStringList outputlines;
     const int numLines(10000);
     int j(0), k(0), l(0), m(0);
     do {
         ++j; ++k; ++l;
         QString tmp;
         if(m % 2 == 0) {
             tmp = QStringLiteral( "[ 26%] Building CXX object /this/is/the/path/to/the/files/%1/%2/%3/CMakeFiles/file.o").arg( j ).arg( k ).arg( l );
         } else {
             tmp = QString( "make[4]: Entering directory '" + projecturl + "/this/is/the/path/to/the/files/%1/%2/%3/").arg( j ).arg( k ).arg( l );
         }
         outputlines << tmp;
         if(j % 6 == 0) {
             j = 0; ++m;
         }
         if(k % 9 == 0) {
             k = 0; ++m;
         }
         if(l % 13 == 0) {
             l = 0; ++m;
         }
     }
     while(outputlines.size() < numLines ); // gives us numLines (-ish)
 
     QElapsedTimer totalTime;
     totalTime.start();
 
     static CompilerFilterStrategy testee(QUrl::fromLocalFile(projecturl));
     FilteredItem item1(QStringLiteral("dummyline"), FilteredItem::InvalidItem);
     QBENCHMARK {
         for(int i = 0; i < outputlines.size(); ++i) {
             item1 = testee.actionInLine(outputlines.at(i));
         }
     }
 
     const qint64 elapsed = totalTime.elapsed();
 
     qDebug() << "ms elapsed to add directories: " << elapsed;
     qDebug() << "total number of directories: " << outputlines.count();
     const double avgDirectoryInsertion = double(elapsed) / outputlines.count();
     qDebug() << "average ms spend pr. dir: " << avgDirectoryInsertion;
 
     QVERIFY(avgDirectoryInsertion < 2);
 }
 
 void TestFilteringStrategy::testExtractionOfLineAndColumn_data()
 {
     QTest::addColumn<QString>("line");
     QTest::addColumn<QString>("file");
     QTest::addColumn<int>("lineNr");
     QTest::addColumn<int>("column");
     QTest::addColumn<FilteredItem::FilteredOutputItemType>("itemtype");
 
 #ifdef Q_OS_WIN
     QTest::newRow("msvc-compiler-error-line")
         << "Z:\\kderoot\\download\\git\\kcoreaddons\\src\\lib\\jobs\\kjob.cpp(3): error C2065: 'dadsads': undeclared identifier"
         << "Z:/kderoot/download/git/kcoreaddons/src/lib/jobs/kjob.cpp" << 2 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("msvc-compiler-warning-line")
         << "c:\\program files\\microsoft visual studio 10.0\\vc\\include\\crtdefs.h(527): warning C4229: anachronism used : modifiers on data are ignored"
         << "c:/program files/microsoft visual studio 10.0/vc/include/crtdefs.h" << 526 << 0 << FilteredItem::WarningItem;
 #else
     QTest::newRow("gcc-with-col")
         << "/path/to/file.cpp:123:45: fatal error: ..."
         << "/path/to/file.cpp" << 122 << 44 << FilteredItem::ErrorItem;
     QTest::newRow("gcc-no-col")
         << "/path/to/file.cpp:123: error ..."
         << "/path/to/file.cpp" << 122 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("gcc-app-gives-invalid-column")
     << "/path/to/file.h:60:0:\
 warning: \"SOME_MACRO\" redefined" << "/path/to/file.h" << 59 << 0 << FilteredItem::WarningItem;
     QTest::newRow("fortcom")
         << "fortcom: Error: Ogive8.f90, line 123: ..."
         << QString(projectPath() + "/Ogive8.f90") << 122 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("fortcomError")
         << "fortcom: Error: ./Ogive8.f90, line 123: ..."
         << QString(projectPath() + "/Ogive8.f90") << 122 << 0 << FilteredItem::ErrorItem;
     QTest::newRow("fortcomWarning")
         << "fortcom: Warning: /path/Ogive8.f90, line 123: ..."
         << "/path/Ogive8.f90" << 122 << 0 << FilteredItem::WarningItem;
     QTest::newRow("fortcomInfo")
         << "fortcom: Info: Ogive8.f90, line 123: ..."
         << QString(projectPath() + "/Ogive8.f90") << 122 << 0 << FilteredItem::InformationItem;
     QTest::newRow("libtool")
         << "libtool: link: warning: ..."
         << "" << -1 << 0  << FilteredItem::WarningItem;
     QTest::newRow("gfortranError1")
         << "/path/to/file.f90:123.456:Error: ...."
         << "/path/to/file.f90" << 122 << 455  << FilteredItem::ErrorItem;
     QTest::newRow("gfortranError2")
         << "/path/flib.f90:3567.22:"
         << "/path/flib.f90" << 3566 << 21 << FilteredItem::ErrorItem;
     QTest::newRow("ant-javac-Warning")
         << "    [javac] /path/class.java:383: warning: [deprecation] ..."
         << "/path/class.java" << 382 << 0 << FilteredItem::WarningItem;
     QTest::newRow("ant-javac-Error")
         << "    [javac] /path/class.java:447: error: cannot find symbol"
         << "/path/class.java" << 446 << 0 << FilteredItem::ErrorItem;
 #endif
 }
 
 void TestFilteringStrategy::testExtractionOfLineAndColumn()
 {
     QFETCH(QString, line);
     QFETCH(QString, file);
     QFETCH(int, lineNr);
     QFETCH(int, column);
     QFETCH(FilteredItem::FilteredOutputItemType, itemtype);
     QUrl projecturl = QUrl::fromLocalFile( projectPath() );
     CompilerFilterStrategy testee(projecturl);
     FilteredItem item1 = testee.errorInLine(line);
     QCOMPARE(item1.type , itemtype);
     QCOMPARE(KDevelop::toUrlOrLocalFile(item1.url), file);
     QCOMPARE(item1.lineNo , lineNr);
     QCOMPARE(item1.columnNo , column);
 }
diff --git a/outputview/tests/test_outputmodel.cpp b/outputview/tests/test_outputmodel.cpp
index b1ae82d50d..6282e1e461 100644
--- a/outputview/tests/test_outputmodel.cpp
+++ b/outputview/tests/test_outputmodel.cpp
@@ -1,117 +1,119 @@
 /*
     This file is part of KDevelop
     Copyright 2012 Milian Wolff <mail@milianw.de>
     Copyright (C) 2012  Morten Danielsen Volden mvolden2@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, see <http://www.gnu.org/licenses/>.
 */
 #include "test_outputmodel.h"
 #include "testlinebuilderfunctions.h"
 #include "../outputmodel.h"
 
 #include <QTest>
 
 QTEST_MAIN(KDevelop::TestOutputModel)
 
 namespace KDevelop
 {
 
 TestOutputModel::TestOutputModel(QObject* parent): QObject(parent)
 {
 }
 
 QStringList generateLines()
 {
     const int numLines = 10000;
     QStringList outputlines;
     do {
-        outputlines << buildCompilerErrorLine();
-        outputlines << buildCompilerLine();
         outputlines << buildCompilerActionLine();
-        outputlines << buildCppCheckErrorLine();
         outputlines << buildCppCheckInformationLine();
-        outputlines << buildPythonErrorLine();
+        for (TestPathType pathType : {UnixFilePathNoSpaces, UnixFilePathWithSpaces}) {
+            outputlines << buildCompilerErrorLine(pathType);
+            outputlines << buildCompilerLine(pathType);
+            outputlines << buildCppCheckErrorLine(pathType);
+            outputlines << buildPythonErrorLine(pathType);
+        }
     }
     while(outputlines.size() < numLines ); // gives us numLines (-ish)
     return outputlines;
 }
 
 QStringList generateLongLine()
 {
     const int objects = 100; // *.o files
     const int libs = 20; // -l...
     const int libPaths = 20; // -L...
     QString line = QStringLiteral("g++ -m64 -Wl,-rpath,/home/gabo/md/qt/lib -o bin/flap_ui");
     for(int i = 0; i < objects; ++i) {
         line += QStringLiteral(" .obj/file%1.o").arg(i);
     }
     for(int i = 0; i < libPaths; ++i) {
         line += QStringLiteral(" -Lsome/path/to/lib%1").arg(i);
     }
     for(int i = 0; i < libs; ++i) {
         line += QStringLiteral(" -lsomelib%1").arg(i);
     }
     return QStringList() << line;
 }
 
 void TestOutputModel::bench()
 {
     QFETCH(KDevelop::OutputModel::OutputFilterStrategy, strategy);
     QFETCH(QStringList, lines);
 
     OutputModel testee(QUrl::fromLocalFile(QStringLiteral("/tmp/build-foo")));
     testee.setFilteringStrategy(strategy);
 
     quint64 processEventsCounter = 1;
     QElapsedTimer totalTime;
     totalTime.start();
 
     testee.appendLines(lines);
     while(testee.rowCount() != lines.count()) {
         QCoreApplication::instance()->processEvents();
         processEventsCounter++;
     }
 
     QVERIFY(testee.rowCount() == lines.count());
     const qint64 elapsed = totalTime.elapsed();
 
     qDebug() << "ms elapsed to add lines: " << elapsed;
     qDebug() << "total number of added lines: " << lines.count();
     const double avgUiLockup = double(elapsed) / processEventsCounter;
     qDebug() << "average UI lockup in ms: " << avgUiLockup;
     QVERIFY(avgUiLockup < 200);
 }
 
 void TestOutputModel::bench_data()
 {
     QTest::addColumn<KDevelop::OutputModel::OutputFilterStrategy>("strategy");
     QTest::addColumn<QStringList>("lines");
 
     const QStringList lines = generateLines();
     const QStringList longLine = generateLongLine();
 
     QTest::newRow("no-filter") << OutputModel::NoFilter << lines;
     QTest::newRow("no-filter-longline") << OutputModel::NoFilter << longLine;
 
     QTest::newRow("compiler-filter") << OutputModel::CompilerFilter << lines;
     QTest::newRow("compiler-filter-longline") << OutputModel::CompilerFilter << longLine;
 
     QTest::newRow("script-error-filter") << OutputModel::ScriptErrorFilter << lines;
     QTest::newRow("script-error-filter-longline") << OutputModel::ScriptErrorFilter << longLine;
 
     QTest::newRow("static-analysis-filter") << OutputModel::StaticAnalysisFilter << lines;
     QTest::newRow("static-analysis-filter-longline") << OutputModel::StaticAnalysisFilter << longLine;
 }
 
 }
diff --git a/outputview/tests/testlinebuilderfunctions.h b/outputview/tests/testlinebuilderfunctions.h
index a51319f863..5630e9f1b6 100644
--- a/outputview/tests/testlinebuilderfunctions.h
+++ b/outputview/tests/testlinebuilderfunctions.h
@@ -1,159 +1,170 @@
 /*
     This file is part of KDevelop
     Copyright (C) 2012  Morten Danielsen Volden mvolden2@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, see <http://www.gnu.org/licenses/>.
 */
 #ifndef KDEVPLATFORM_TESTLINEBUILDERFUNCTIONS_H
 #define KDEVPLATFORM_TESTLINEBUILDERFUNCTIONS_H
 
 #include <QUrl>
 #include <QString>
-#include <QFileInfo>
 
-#define PROJECTS_SOURCE_DIR
+namespace KDevelop
+{
+
+enum TestPathType {
+    UnixFilePathNoSpaces,
+    UnixFilePathWithSpaces
+};
+
+}
+
+Q_DECLARE_METATYPE( KDevelop::TestPathType)
 
 namespace KDevelop
 {
 
-static QString projectPath()
+// TODO: extend with windows path and other potential path patterns (network shares?)
+static QString projectPath(TestPathType pathType = UnixFilePathNoSpaces)
 {
-    /// Use existing directory with one file
-    return QFileInfo(QStringLiteral(__FILE__)).absolutePath() + QLatin1String("/onefileproject");
+    return
+        (pathType == UnixFilePathNoSpaces) ? QStringLiteral("/some/path/to/a/project") :
+        /* else, UnixFilePathWithSpaces) */  QStringLiteral("/some/path with spaces/to/a/project");
 }
 
-QString buildCppCheckErrorLine()
+QString buildCppCheckErrorLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     /// Test CPP check output
     QString outputline(QStringLiteral("["));
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("main.cpp:26]: (error) Memory leak: str");
     return outputline;
 }
 
-QString buildKrazyErrorLine()
+QString buildKrazyErrorLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     /// Test krazy2 output
     QString outputline(QStringLiteral("\t"));
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("main.cpp: line#22 (1)");
     return outputline;
 }
 
-QString buildKrazyErrorLine2()
+QString buildKrazyErrorLine2(TestPathType pathType = UnixFilePathNoSpaces)
 {
     /// Test krazy2 output
     QString outputline(QStringLiteral("\t"));
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("main.cpp: missing tags: email address line#2  (1)");
     return outputline;
 }
 
-QString buildKrazyErrorLine3()
+QString buildKrazyErrorLine3(TestPathType pathType = UnixFilePathNoSpaces)
 {
     /// Test krazy2 output
     QString outputline(QStringLiteral("\t"));
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("main.cpp: non-const ref iterator line#451 (1)");
     return outputline;
 }
 
-QString buildKrazyErrorLineNoLineInfo()
+QString buildKrazyErrorLineNoLineInfo(TestPathType pathType = UnixFilePathNoSpaces)
 {
     /// Test krazy2 output
     QString outputline(QStringLiteral("\t"));
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("main.cpp: missing license");
     return outputline;
 }
 
-QString buildCompilerLine()
+QString buildCompilerLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     /// Test with compiler output
     QString outputline;
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append(">make");
     return outputline;
 }
 
-QString buildCompilerErrorLine()
+QString buildCompilerErrorLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     QString outputline;
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("main.cpp:5:5: error: ‘RingBuffer’ was not declared in this scope");
     return outputline;
 }
 
-QString buildCompilerInformationLine()
+QString buildCompilerInformationLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     QString outputline;
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("main.cpp:6:14: instantiated from here");
     return outputline;
 }
 
-QString buildInfileIncludedFromFirstLine()
+QString buildInfileIncludedFromFirstLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     QString outputline(QStringLiteral("In file included from "));
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("PriorityFactory.h:52:0,");
     return outputline;
 }
 
-QString buildInfileIncludedFromSecondLine()
+QString buildInfileIncludedFromSecondLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     QString outputline(QStringLiteral("    from "));
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("PatchBasedInpainting.hxx:29,");
     return outputline;
 }
 
 QString buildCompilerActionLine()
 {
     return QStringLiteral("linking testCustombuild (g++)");
 }
 
-QString buildCmakeConfigureMultiLine()
+QString buildCmakeConfigureMultiLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     QString outputline;
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("CMakeLists.txt:10:");
     return outputline;
 }
 
 
-QString buildLinkerErrorLine()
+QString buildLinkerErrorLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
-    return QStringLiteral("/path/to/file/Buffer.cpp:66: undefined reference to `Buffer::does_not_exist()'");
+    return projectPath(pathType) + QLatin1String("Buffer.cpp:66: undefined reference to `Buffer::does_not_exist()'");
 }
 
-QString buildPythonErrorLine()
+QString buildPythonErrorLine(TestPathType pathType = UnixFilePathNoSpaces)
 {
     QString outputline(QStringLiteral("File \""));
-    outputline.append(projectPath());
+    outputline.append(projectPath(pathType));
     outputline.append("pythonExample.py\", line 10");
     return outputline;
 }
 
 QString buildCppCheckInformationLine()
 {
     return QStringLiteral("(information) Cppcheck cannot find all the include files. Cpppcheck can check the code without the include\
     files found. But the results will probably be more accurate if all the include files are found. Please check your project's \
     include directories and add all of them as include directories for Cppcheck. To see what files Cppcheck cannot find use --check-config.");
 }
 
 
 }
 
 #endif