diff --git a/kdevplatform/shell/problemmodel.cpp b/kdevplatform/shell/problemmodel.cpp
index 02bf1c93aa..5e5f551367 100644
--- a/kdevplatform/shell/problemmodel.cpp
+++ b/kdevplatform/shell/problemmodel.cpp
@@ -1,392 +1,429 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library 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 "problemmodel.h"
 #include <QThread>
 #include <QIcon>
 #include <KLocalizedString>
 #include <interfaces/icore.h>
 #include <interfaces/idocument.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 #include <interfaces/iassistant.h>
 #include <language/editor/documentrange.h>
 
 #include <shell/problem.h>
 #include <shell/problemstore.h>
 #include <shell/problemstorenode.h>
 #include <shell/filteredproblemstore.h>
 #include <shell/problemconstants.h>
 #include <shell/watcheddocumentset.h>
 
 namespace {
 QIcon iconForSeverity(KDevelop::IProblem::Severity severity)
 {
     switch (severity) {
     case KDevelop::IProblem::Hint:
         return QIcon::fromTheme(QStringLiteral("dialog-information"));
     case KDevelop::IProblem::Warning:
         return QIcon::fromTheme(QStringLiteral("dialog-warning"));
     case KDevelop::IProblem::Error:
         return QIcon::fromTheme(QStringLiteral("dialog-error"));
     case KDevelop::IProblem::NoSeverity:
         return {};
     }
     return {};
 }
 
 }
 
 
 namespace KDevelop
 {
 
 class ProblemModelPrivate
 {
 public:
     explicit ProblemModelPrivate(KDevelop::ProblemStore *store)
         : m_problems(store)
         , m_features(KDevelop::ProblemModel::NoFeatures)
         , m_fullUpdateTooltip(i18nc("@info:tooltip", "Re-parse all watched documents"))
+        , m_isPlaceholderShown(false)
     {
     }
 
+    KDevelop::IProblem::Ptr createPlaceholdreProblem() const
+    {
+        Q_ASSERT(!m_placeholderText.isEmpty());
+
+        KDevelop::IProblem::Ptr problem(new KDevelop::DetectedProblem(m_placeholderSource));
+        problem->setDescription(m_placeholderText);
+        problem->setFinalLocation(m_placeholderLocation);
+        problem->setSeverity(KDevelop::IProblem::Hint);
+
+        return problem;
+    }
+
     QScopedPointer<KDevelop::ProblemStore> m_problems;
     KDevelop::ProblemModel::Features m_features;
     QString m_fullUpdateTooltip;
+    QString m_placeholderText;
+    QString m_placeholderSource;
+    KDevelop::DocumentRange m_placeholderLocation;
+    bool m_isPlaceholderShown;
 };
 
 
 ProblemModel::ProblemModel(QObject * parent, ProblemStore *store)
   : QAbstractItemModel(parent)
   , d(new ProblemModelPrivate(store))
 {
     if (!d->m_problems) {
         d->m_problems.reset(new FilteredProblemStore());
         d->m_features = ScopeFilter | SeverityFilter | Grouping | CanByPassScopeFilter;
     }
 
     setScope(CurrentDocument);
 
     connect(ICore::self()->documentController(), &IDocumentController::documentActivated, this, &ProblemModel::setCurrentDocument);
     connect(ICore::self()->documentController(), &IDocumentController::documentClosed, this, &ProblemModel::closedDocument);
     /// CompletionSettings include a list of todo markers we care for, so need to update
     connect(ICore::self()->languageController()->completionSettings(), &ICompletionSettings::settingsChanged, this, &ProblemModel::forceFullUpdate);
 
     if (ICore::self()->documentController()->activeDocument()) {
         setCurrentDocument(ICore::self()->documentController()->activeDocument());
     }
 
     connect(d->m_problems.data(), &ProblemStore::beginRebuild, this, &ProblemModel::onBeginRebuild);
     connect(d->m_problems.data(), &ProblemStore::endRebuild, this, &ProblemModel::onEndRebuild);
 
     connect(d->m_problems.data(), &ProblemStore::problemsChanged, this, &ProblemModel::problemsChanged);
 }
 
 ProblemModel::~ ProblemModel()
 {
 }
 
 int ProblemModel::rowCount(const QModelIndex& parent) const
 {
     if (!parent.isValid()) {
         return d->m_problems->count();
     } else {
         return d->m_problems->count(reinterpret_cast<ProblemStoreNode*>(parent.internalPointer()));
     }
 }
 
 static QString displayUrl(const QUrl &url, const QUrl &base)
 {
     if (base.isParentOf(url)) {
         return url.toDisplayString(QUrl::PreferLocalFile).mid(base.toDisplayString(QUrl::PreferLocalFile).length());
     } else {
         return ICore::self()->projectController()->prettyFileName(url, IProjectController::FormatPlain);
     }
 }
 
 QVariant ProblemModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid())
         return QVariant();
 
     QUrl baseDirectory = d->m_problems->currentDocument().toUrl().adjusted(QUrl::RemoveFilename);
     IProblem::Ptr p = problemForIndex(index);
     if (!p.constData()) {
         if (role == Qt::DisplayRole && index.column() == Error) {
             ProblemStoreNode *node = reinterpret_cast<ProblemStoreNode*>(index.internalPointer());
             if (node) {
                 return node->label();
             }
         }
         return {};
     }
 
     if (role == SeverityRole) {
         return p->severity();
     } else if (role == ProblemRole) {
         return QVariant::fromValue(p);
     }
 
     switch (role) {
     case Qt::DisplayRole:
         switch (index.column()) {
         case Source:
             return p->sourceString();
         case Error:
             return p->description();
         case File:
             return displayUrl(p->finalLocation().document.toUrl().adjusted(QUrl::NormalizePathSegments), baseDirectory);
         case Line:
             if (p->finalLocation().isValid()) {
                 return QString::number(p->finalLocation().start().line() + 1);
             }
             break;
         case Column:
             if (p->finalLocation().isValid()) {
                 return QString::number(p->finalLocation().start().column() + 1);
             }
             break;
         }
         break;
 
     case Qt::DecorationRole:
         if (index.column() == Error) {
             return iconForSeverity(p->severity());
         }
         break;
     case Qt::ToolTipRole:
         return p->explanation();
 
     default:
         break;
     }
 
     return {};
 }
 
 QModelIndex ProblemModel::parent(const QModelIndex& index) const
 {
     ProblemStoreNode *node = reinterpret_cast<ProblemStoreNode*>(index.internalPointer());
     if (!node) {
         return {};
     }
 
     ProblemStoreNode *parent = node->parent();
     if (!parent || parent->isRoot()) {
         return {};
     }
 
     int idx = parent->index();
     return createIndex(idx, 0, parent);
 }
 
 QModelIndex ProblemModel::index(int row, int column, const QModelIndex& parent) const
 {
     if (row < 0 || row >= rowCount(parent) || column < 0 || column >= LastColumn) {
         return QModelIndex();
     }
 
     ProblemStoreNode *parentNode = reinterpret_cast<ProblemStoreNode*>(parent.internalPointer());
     const ProblemStoreNode *node = d->m_problems->findNode(row, parentNode);
     return createIndex(row, column, (void*)node);
 }
 
 int ProblemModel::columnCount(const QModelIndex& parent) const
 {
     Q_UNUSED(parent)
     return LastColumn;
 }
 
 IProblem::Ptr ProblemModel::problemForIndex(const QModelIndex& index) const
 {
     ProblemStoreNode *node = reinterpret_cast<ProblemStoreNode*>(index.internalPointer());
     if (!node) {
         return {};
     } else {
         return node->problem();
     }
 }
 
 ProblemModel::Features ProblemModel::features() const
 {
     return d->m_features;
 }
 
 void ProblemModel::setFeatures(Features features)
 {
     d->m_features = features;
 }
 
 QString ProblemModel::fullUpdateTooltip() const
 {
     return d->m_fullUpdateTooltip;
 }
 
 void ProblemModel::setFullUpdateTooltip(const QString& tooltip)
 {
     if (d->m_fullUpdateTooltip == tooltip) {
         return;
     }
 
     d->m_fullUpdateTooltip = tooltip;
     emit fullUpdateTooltipChanged();
 }
 
+void ProblemModel::setPlaceholderText(const QString& text, const KDevelop::DocumentRange& location, const QString& source)
+{
+    d->m_placeholderText = text;
+    d->m_placeholderLocation = location;
+    d->m_placeholderSource = source;
+
+    if (d->m_isPlaceholderShown || d->m_problems->count() == 0) {
+        // clearing will show/update the new placeholder
+        clearProblems();
+    }
+}
+
 void ProblemModel::addProblem(const IProblem::Ptr &problem)
 {
-    int c = d->m_problems->count();
-    beginInsertRows(QModelIndex(), c, c);
-    d->m_problems->addProblem(problem);
-    endInsertRows();
+    if (d->m_isPlaceholderShown) {
+        setProblems({ problem });
+    } else {
+        int c = d->m_problems->count();
+        beginInsertRows(QModelIndex(), c, c);
+        d->m_problems->addProblem(problem);
+        endInsertRows();
+    }
 }
 
 void ProblemModel::setProblems(const QVector<IProblem::Ptr> &problems)
 {
     beginResetModel();
-    d->m_problems->setProblems(problems);
+    if (problems.isEmpty() && !d->m_placeholderText.isEmpty()) {
+        d->m_problems->setProblems({ d->createPlaceholdreProblem() });
+        d->m_isPlaceholderShown = true;
+    } else {
+        d->m_problems->setProblems(problems);
+        d->m_isPlaceholderShown = false;
+    }
     endResetModel();
 }
 
 void ProblemModel::clearProblems()
 {
-    beginResetModel();
-    d->m_problems->clear();
-    endResetModel();
+    setProblems({});
 }
 
 QVector<IProblem::Ptr> ProblemModel::problems(const KDevelop::IndexedString& document) const
 {
     return d->m_problems->problems(document);
 }
 
 QVariant ProblemModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     Q_UNUSED(orientation);
 
     if (role != Qt::DisplayRole)
         return {};
 
     switch (section) {
         case Source:
             return i18nc("@title:column source of problem", "Source");
         case Error:
             return i18nc("@title:column problem description", "Problem");
         case File:
             return i18nc("@title:column file where problem was found", "File");
         case Line:
             return i18nc("@title:column line number with problem", "Line");
         case Column:
             return i18nc("@title:column column number with problem", "Column");
     }
 
     return {};
 }
 
 void ProblemModel::setCurrentDocument(IDocument* document)
 {
     Q_ASSERT(thread() == QThread::currentThread());
 
     QUrl currentDocument = document->url();
     /// Will trigger signals beginRebuild(), endRebuild() if problems change and are rebuilt
     d->m_problems->setCurrentDocument(IndexedString(currentDocument));
 }
 
 void ProblemModel::closedDocument(IDocument* document)
 {
     if (IndexedString(document->url()) == d->m_problems->currentDocument())
     {   // reset current document
         d->m_problems->setCurrentDocument(IndexedString());
     }
 }
 
 void ProblemModel::onBeginRebuild()
 {
     beginResetModel();
 }
 
 void ProblemModel::onEndRebuild()
 {
     endResetModel();
 }
 
 void ProblemModel::setShowImports(bool showImports)
 {
     Q_ASSERT(thread() == QThread::currentThread());
 
     d->m_problems->setShowImports(showImports);
 }
 
 bool ProblemModel::showImports()
 {
     return d->m_problems->showImports();
 }
 
 void ProblemModel::setScope(int scope)
 {
     Q_ASSERT(thread() == QThread::currentThread());
 
     if (!features().testFlag(ScopeFilter))
         scope = ProblemScope::BypassScopeFilter;
 
     /// Will trigger signals beginRebuild(), endRebuild() if problems change and are rebuilt
     d->m_problems->setScope(scope);
 }
 
 void ProblemModel::setSeverity(int severity)
 {
     switch (severity)
     {
         case KDevelop::IProblem::Error:
             setSeverities(KDevelop::IProblem::Error);
             break;
         case KDevelop::IProblem::Warning:
             setSeverities(KDevelop::IProblem::Error | KDevelop::IProblem::Warning);
             break;
         case KDevelop::IProblem::Hint:
             setSeverities(KDevelop::IProblem::Error | KDevelop::IProblem::Warning | KDevelop::IProblem::Hint);
             break;
     }
 }
 
 void ProblemModel::setSeverities(KDevelop::IProblem::Severities severities)
 {
     Q_ASSERT(thread() == QThread::currentThread());
     /// Will trigger signals beginRebuild(), endRebuild() if problems change and are rebuilt
     d->m_problems->setSeverities(severities);
 }
 
 void ProblemModel::setGrouping(int grouping)
 {
     /// Will trigger signals beginRebuild(), endRebuild() if problems change and are rebuilt
     d->m_problems->setGrouping(grouping);
 }
 
 ProblemStore* ProblemModel::store() const
 {
     return d->m_problems.data();
 }
 
 }
 
 
diff --git a/kdevplatform/shell/problemmodel.h b/kdevplatform/shell/problemmodel.h
index 344ab965f6..c7272fe298 100644
--- a/kdevplatform/shell/problemmodel.h
+++ b/kdevplatform/shell/problemmodel.h
@@ -1,208 +1,223 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library 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.
  */
 
 #ifndef PROBLEMMODEL_H
 #define PROBLEMMODEL_H
 
 #include <shell/shellexport.h>
 #include <QAbstractItemModel>
 #include <shell/problem.h>
+#include <language/editor/documentrange.h>
 
 namespace KDevelop {
     class IDocument;
 class IndexedString;
 class ProblemStore;
 
 /**
  * @brief Wraps a ProblemStore and adds the QAbstractItemModel interface, so the it can be used in a model/view architecture.
  *
  * By default ProblemModel instantiates a FilteredProblemStore, with the following features on:
  * \li ScopeFilter
  * \li SeverityFilter
  * \li Grouping
  * \li CanByPassScopeFilter
  *
  * Has to following columns:
  * \li Error
  * \li Source
  * \li File
  * \li Line
  * \li Column
  * \li LastColumn
  *
  * Possible ProblemModel features
  * \li NoFeatures
  * \li CanDoFullUpdate
  * \li CanShowImports
  * \li ScopeFilter
  * \li SeverityFilter
  * \li Grouping
  * \li CanByPassScopeFilter
  *
  * Scope, severity, grouping, imports can be set using the slots named after these features.
  *
  * Usage example:
  * @code
  * IProblem::Ptr problem(new DetectedProblem);
  * problem->setDescription(QStringLiteral("Problem"));
  * ProblemModel *model = new ProblemModel(nullptr);
  * model->addProblem(problem);
  * model->rowCount(); // returns 1
  * QModelIndex idx = model->index(0, 0);
  * model->data(index); // "Problem"
  * @endcode
  *
  */
 class KDEVPLATFORMSHELL_EXPORT ProblemModel : public QAbstractItemModel
 {
     Q_OBJECT
 
 public:
     /// List of supportable features
     enum FeatureCode
     {
         NoFeatures                 = 0,  /// No features :(
         CanDoFullUpdate            = 1,  /// Reload/Reparse problems
         CanShowImports             = 2,  /// Show problems from imported files. E.g.: Header files in C/C++
         ScopeFilter                = 4,  /// Filter problems by scope. E.g.: current document, open documents, etc
         SeverityFilter             = 8,  /// Filter problems by severity. E.g.: hint, warning, error, etc
         Grouping                   = 16, /// Can group problems
         CanByPassScopeFilter       = 32, /// Can bypass scope filter
         ShowSource                 = 64  /// Show problem's source. Set if problems can have different sources.
     };
 
     Q_DECLARE_FLAGS(Features, FeatureCode)
 
     explicit ProblemModel(QObject *parent, ProblemStore *store = nullptr);
     ~ProblemModel() override;
 
     enum Columns {
         Error,
         Source,
         File,
         Line,
         Column,
         LastColumn
     };
 
     enum Roles {
         ProblemRole = Qt::UserRole + 1,
         SeverityRole
     };
 
     int columnCount(const QModelIndex & parent = QModelIndex()) const override;
     QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex & index) const override;
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     int rowCount(const QModelIndex & parent = QModelIndex()) const override;
     QVariant headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const override;
 
     IProblem::Ptr problemForIndex(const QModelIndex& index) const;
 
     /// Adds a new problem to the model
     void addProblem(const IProblem::Ptr &problem);
 
     /// Clears the problems, then adds a new set of them
     void setProblems(const QVector<IProblem::Ptr> &problems);
 
     /// Clears the problems
     void clearProblems();
 
     /// Retrieve problems for selected document
     QVector<IProblem::Ptr> problems(const KDevelop::IndexedString& document) const;
 
+    /**
+     * Add new "placeholder" item (problem). The item will be displayed whenever the model is empty.
+     *
+     * The method should be used to notify user about some events. For example, analyzer plugin
+     * can set placeholders at analysis state changes - started/finished without errors/etc.
+     *
+     * \param[in] text Sets problem description.
+     * \param[in] location Sets problem final location.
+     * \param[in] source Sets problem source string.
+    */
+    void setPlaceholderText(const QString& text,
+                            const KDevelop::DocumentRange& location = KDevelop::DocumentRange::invalid(),
+                            const QString& source = QString());
+
     /// Retrieve the supported features
     Features features() const;
 
     /// Retrieve 'show imports' filter setting
     bool showImports();
 
     /// Set the supported features
     void setFeatures(Features features);
 
     /// Tooltip for "Force Full Update" action in the Problems View when the model
     /// is active (correspondent tab is selected)
     QString fullUpdateTooltip() const;
 
     /// Set the "Force Full Update" action tooltip
     void setFullUpdateTooltip(const QString& tooltip);
 
 Q_SIGNALS:
     /// Emitted when the stored problems are changed with addProblem(), setProblems() and
     /// clearProblems() methods. This signal emitted only when internal problems storage is
     /// really changed: for example, it is not emitted when we call clearProblems() method
     /// for empty model.
     void problemsChanged();
 
     /// Emitted when the "Force Full Update" action tooltip is changed with setFullUpdateTooltip().
     /// This signal emitted only when tooltip is really changed.
     void fullUpdateTooltipChanged();
 
 public Q_SLOTS:
     /// Show imports
     void setShowImports(bool showImports);
 
     /// Sets the scope filter. Uses int to be able to use QSignalMapper
     void setScope(int scope);
 
     /// Sets the severity filter. Uses int to be able to use QSignalMapper
     void setSeverity(int severity);///old-style severity filtering
 
     void setSeverities(KDevelop::IProblem::Severities severities);///new-style severity filtering
 
     void setGrouping(int grouping);
 
     /**
      * Force a full problem update.
      * E.g.: Reparse the source code.
      * Obviously it doesn't make sense for run-time problem checkers.
      */
     virtual void forceFullUpdate(){}
 
 protected Q_SLOTS:
     /// Triggered when problems change
     virtual void onProblemsChanged(){}
 
 private Q_SLOTS:
     /// Triggered when the current document changes
     virtual void setCurrentDocument(IDocument* doc);
 
     virtual void closedDocument(IDocument* doc);
 
     /// Triggered before the problems are rebuilt
     void onBeginRebuild();
 
     /// Triggered once the problems have been rebuilt
     void onEndRebuild();
 
 protected:
     ProblemStore *store() const;
 
 private:
     const QScopedPointer<class ProblemModelPrivate> d;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(ProblemModel::Features)
 
 }
 
 #endif // PROBLEMMODEL_H
diff --git a/kdevplatform/shell/tests/test_problemmodel.cpp b/kdevplatform/shell/tests/test_problemmodel.cpp
index 0a62d636b0..f0fc3f82a5 100644
--- a/kdevplatform/shell/tests/test_problemmodel.cpp
+++ b/kdevplatform/shell/tests/test_problemmodel.cpp
@@ -1,515 +1,571 @@
 /*
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library 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 <QTest>
 
 #include <shell/problemmodel.h>
 #include <shell/problem.h>
 #include <shell/problemconstants.h>
 #include <language/editor/documentrange.h>
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 
 #include <KLocalizedString>
 
 #define MYCOMPARE(actual, expected) \
     if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__)) \
     return false
 
 #define MYVERIFY(statement) \
     if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\
         return false
 
 using namespace KDevelop;
 
 class TestProblemModel : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void cleanupTestCase();
 
     void testNoGrouping();
     void testPathGrouping();
     void testSeverityGrouping();
+    void testPlaceholderText();
 
 private:
     void generateProblems();
     bool checkIsSame(int row, const QModelIndex &parent, const IProblem::Ptr &problem);
     bool checkDiagnostics(int row, const QModelIndex &parent);
     bool checkDisplay(int row, const QModelIndex &parent, const IProblem::Ptr &problem);
     bool checkLabel(int row, const QModelIndex &parent, const QString &label);
     bool checkPathGroup(int row, const IProblem::Ptr &problem);
     bool checkSeverityGroup(int row, const IProblem::Ptr &problem);
 
     QScopedPointer<ProblemModel> m_model;
     QVector<IProblem::Ptr> m_problems;
     IProblem::Ptr m_diagnosticTestProblem;
 };
 
 void TestProblemModel::initTestCase()
 {
     AutoTestShell::init();
     TestCore::initialize(Core::NoUi);
 
     m_model.reset(new ProblemModel(nullptr));
     m_model->setScope(BypassScopeFilter);
 
     generateProblems();
 }
 
 void TestProblemModel::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestProblemModel::testNoGrouping()
 {
     m_model->setGrouping(NoGrouping);
     m_model->setSeverity(IProblem::Hint);
 
     QCOMPARE(m_model->rowCount(), 0);
 
     // Check if setting the problems works
     m_model->setProblems(m_problems);
     QCOMPARE(m_model->rowCount(), 3);
 
     for (int i = 0; i < m_model->rowCount(); i++) {
         QVERIFY(checkIsSame(i, QModelIndex(), m_problems[i]));
     }
 
     // Check if displaying various data parts works
     QVERIFY(checkDisplay(0, QModelIndex(), m_problems[0]));
 
     // Check if clearing the problems works
     m_model->clearProblems();
     QCOMPARE(m_model->rowCount(), 0);
 
     // Check if adding the problems works
     int c = 0;
     foreach (const IProblem::Ptr &p, m_problems) {
         m_model->addProblem(p);
         c++;
 
         QCOMPARE(m_model->rowCount(), c);
     }
 
     for (int i = 0; i < m_model->rowCount(); i++) {
         QVERIFY(checkIsSame(i, QModelIndex(), m_problems[i]));
     }
 
 
     // Check if filtering works
     // old-style setSeverity
     // Error filter
     m_model->setSeverity(IProblem::Error);
     QCOMPARE(m_model->rowCount(), 1);
     QVERIFY(checkIsSame(0, QModelIndex(), m_problems[0]));
 
     // Warning filter
     m_model->setSeverity(IProblem::Warning);
     QCOMPARE(m_model->rowCount(), 2);
     QVERIFY(checkIsSame(0, QModelIndex(), m_problems[0]));
     QVERIFY(checkIsSame(1, QModelIndex(), m_problems[1]));
 
     // Hint filter
     m_model->setSeverity(IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 3);
     QVERIFY(checkIsSame(0, QModelIndex(), m_problems[0]));
     QVERIFY(checkIsSame(1, QModelIndex(), m_problems[1]));
     QVERIFY(checkIsSame(2, QModelIndex(), m_problems[2]));
 
     // Check if filtering works
     // new style
     // Error filter
     m_model->setSeverities(IProblem::Error);
     QCOMPARE(m_model->rowCount(), 1);
     QVERIFY(checkIsSame(0, QModelIndex(), m_problems[0]));
 
     // Warning filter
     m_model->setSeverities(IProblem::Warning);
     QCOMPARE(m_model->rowCount(), 1);
     QVERIFY(checkIsSame(0, QModelIndex(), m_problems[1]));
 
     // Hint filter
     m_model->setSeverities(IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 1);
     QVERIFY(checkIsSame(0, QModelIndex(), m_problems[2]));
 
     // Error + Hint filter
     m_model->setSeverities(IProblem::Error | IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 2);
     QVERIFY(checkIsSame(0, QModelIndex(), m_problems[0]));
     QVERIFY(checkIsSame(1, QModelIndex(), m_problems[2]));
 
     m_model->setSeverities(IProblem::Error | IProblem::Warning | IProblem::Hint);
 
     // Check if diagnostics are added properly
     m_model->clearProblems();
     m_model->addProblem(m_diagnosticTestProblem);
     QVERIFY(checkDiagnostics(0, QModelIndex()));
 
     m_model->clearProblems();
 }
 
 void TestProblemModel::testPathGrouping()
 {
     m_model->setGrouping(PathGrouping);
     m_model->setSeverity(IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 0);
 
     // Check if setting problems works
     m_model->setProblems(m_problems);
     QCOMPARE(m_model->rowCount(), 3);
 
     for (int i = 0; i < m_model->rowCount(); i++) {
         QVERIFY(checkLabel(i, QModelIndex(), m_problems[i]->finalLocation().document.str()));
 
         QModelIndex idx = m_model->index(i, 0);
         QVERIFY(idx.isValid());
         QVERIFY(checkIsSame(0, idx, m_problems[i]));
     }
 
     // Check if displaying various data parts works
     {
         QModelIndex idx = m_model->index(0, 0);
         QVERIFY(idx.isValid());
         QVERIFY(checkDisplay(0, idx, m_problems[0]));
     }
 
     // Check if clearing works
     m_model->clearProblems();
     QCOMPARE(m_model->rowCount(), 0);
 
     // Check if add problems works
     int c = 0;
     foreach (const IProblem::Ptr &p, m_problems) {
         m_model->addProblem(p);
         c++;
 
         QCOMPARE(m_model->rowCount(), c);
     }
 
     for (int i = 0; i < m_model->rowCount(); i++) {
         QVERIFY(checkLabel(i, QModelIndex(), m_problems[i]->finalLocation().document.str()));
 
         QModelIndex idx = m_model->index(i, 0);
         QVERIFY(idx.isValid());
         QVERIFY(checkIsSame(0, idx, m_problems[i]));
     }
 
     // Check if filtering works
     // old-style setSeverity
     // Error filtering
     m_model->setSeverity(IProblem::Error);
     QCOMPARE(m_model->rowCount(), 1);
     QVERIFY(checkPathGroup(0, m_problems[0]));
 
     // Warning filtering
     m_model->setSeverity(IProblem::Warning);
     QCOMPARE(m_model->rowCount(), 2);
     QVERIFY(checkPathGroup(0, m_problems[0]));
     QVERIFY(checkPathGroup(1, m_problems[1]));
 
     // Hint filtering
     m_model->setSeverity(IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 3);
     QVERIFY(checkPathGroup(0, m_problems[0]));
     QVERIFY(checkPathGroup(1, m_problems[1]));
     QVERIFY(checkPathGroup(2, m_problems[2]));
 
     // Check if filtering works
     // new style
     // Error filtering
     m_model->setSeverities(IProblem::Error);
     QCOMPARE(m_model->rowCount(), 1);
     QVERIFY(checkPathGroup(0, m_problems[0]));
 
     // Warning filtering
     m_model->setSeverities(IProblem::Warning);
     QCOMPARE(m_model->rowCount(), 1);
     QVERIFY(checkPathGroup(0, m_problems[1]));
 
     // Hint filtering
     m_model->setSeverities(IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 1);;
     QVERIFY(checkPathGroup(0, m_problems[2]));
 
     // Error + Hint filtering
     m_model->setSeverities(IProblem::Error | IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 2);
     QVERIFY(checkPathGroup(0, m_problems[0]));
     QVERIFY(checkPathGroup(1, m_problems[2]));
 
     m_model->setSeverities(IProblem::Error | IProblem::Warning | IProblem::Hint);
 
     // Check if diagnostics get to the right place
     m_model->clearProblems();
     m_model->addProblem(m_diagnosticTestProblem);
     {
         QModelIndex parent = m_model->index(0, 0);
         QVERIFY(parent.isValid());
         checkDiagnostics(0, parent);
     }
 
     m_model->clearProblems();
 }
 
 void TestProblemModel::testSeverityGrouping()
 {
     m_model->setGrouping(SeverityGrouping);
     m_model->setSeverity(IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 3);
 
     // Check if setting problems works
     m_model->setProblems(m_problems);
     QCOMPARE(m_model->rowCount(), 3);
     for (int i = 0; i < m_model->rowCount(); i++) {
         QVERIFY(checkSeverityGroup(i, m_problems[i]));
     }
 
     // Check if displaying works
     for (int i = 0; i < m_model->rowCount(); i++) {
         QModelIndex parent = m_model->index(i, 0);
         QVERIFY(parent.isValid());
 
         QVERIFY(checkDisplay(0, parent, m_problems[i]));
     }
 
     // Check if clearing works
     m_model->clearProblems();
     QCOMPARE(m_model->rowCount(), 3);
 
     // Check if adding problems works
     int c = 0;
     foreach (const IProblem::Ptr &p, m_problems) {
         m_model->addProblem(p);
         QVERIFY(checkSeverityGroup(c, m_problems[c]));
         c++;
     }
 
     // Check if filtering works
     // old-style setSeverity
     // Error filtering
     m_model->setSeverity(IProblem::Error);
     QCOMPARE(m_model->rowCount(), 3);
     checkSeverityGroup(0, m_problems[0]);
 
     // Warning filtering
     m_model->setSeverity(IProblem::Warning);
     QCOMPARE(m_model->rowCount(), 3);
     checkSeverityGroup(0, m_problems[0]);
     checkSeverityGroup(1, m_problems[1]);
 
     // Hint filtering
     m_model->setSeverity(IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 3);
     checkSeverityGroup(0, m_problems[0]);
     checkSeverityGroup(1, m_problems[1]);
     checkSeverityGroup(2, m_problems[2]);
 
     // Check if filtering works
     // Error filtering
     m_model->setSeverities(IProblem::Error);
     QCOMPARE(m_model->rowCount(), 3);
     checkSeverityGroup(0, m_problems[0]);
 
     // Warning filtering
     m_model->setSeverities(IProblem::Warning);
     QCOMPARE(m_model->rowCount(), 3);
     checkSeverityGroup(1, m_problems[1]);
 
     // Hint filtering
     m_model->setSeverities(IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 3);
     checkSeverityGroup(2, m_problems[2]);
 
     // Error + Hint filtering
     m_model->setSeverities(IProblem::Error | IProblem::Hint);
     QCOMPARE(m_model->rowCount(), 3);
     checkSeverityGroup(0, m_problems[0]);
     checkSeverityGroup(2, m_problems[2]);
 
     m_model->setSeverities(IProblem::Error | IProblem::Warning | IProblem::Hint);
 
     // Check if diagnostics get to the right place
     m_model->clearProblems();
     m_model->addProblem(m_diagnosticTestProblem);
     {
         QModelIndex parent = m_model->index(0, 0);
         QVERIFY(parent.isValid());
 
         checkDiagnostics(0, parent);
     }
 
     m_model->clearProblems();
 }
 
+void TestProblemModel::testPlaceholderText()
+{
+    const QString text1 = QStringLiteral("testPlaceholderText1");
+    const QString text2 = QStringLiteral("testPlaceholderText2");
+    const QString empty;
+
+    m_model->setGrouping(NoGrouping);
+
+    // Test model with empty placeholder text
+
+    QCOMPARE(m_model->rowCount(), 0);
+    m_model->setPlaceholderText(empty);
+    QCOMPARE(m_model->rowCount(), 0);
+    m_model->setProblems(m_problems);
+    QCOMPARE(m_model->rowCount(), 3);
+    m_model->clearProblems();
+    QCOMPARE(m_model->rowCount(), 0);
+
+    // Test empty model with non-empty placeholder text
+
+    m_model->setPlaceholderText(text1);
+    QCOMPARE(m_model->rowCount(), 1);
+    QVERIFY(checkLabel(0, QModelIndex(), text1));
+
+    m_model->setPlaceholderText(text2);
+    QCOMPARE(m_model->rowCount(), 1);
+    QVERIFY(checkLabel(0, QModelIndex(), text2));
+
+    // Test non-empty model with non-empty placeholder text
+
+    m_model->setProblems(m_problems);
+    QCOMPARE(m_model->rowCount(), 3);
+
+    m_model->clearProblems();
+    QCOMPARE(m_model->rowCount(), 1);
+    QVERIFY(checkLabel(0, QModelIndex(), text2));
+
+    m_model->addProblem(m_problems[0]);
+    QCOMPARE(m_model->rowCount(), 1);
+    QVERIFY(checkIsSame(0, QModelIndex(), m_problems[0]));
+
+    m_model->addProblem(m_problems[1]);
+    QCOMPARE(m_model->rowCount(), 2);
+    QVERIFY(checkIsSame(1, QModelIndex(), m_problems[1]));
+
+    m_model->setPlaceholderText(text1);
+    QCOMPARE(m_model->rowCount(), 2);
+    QVERIFY(checkIsSame(0, QModelIndex(), m_problems[0]));
+    QVERIFY(checkIsSame(1, QModelIndex(), m_problems[1]));
+
+    m_model->setProblems({});
+    QCOMPARE(m_model->rowCount(), 1);
+    QVERIFY(checkLabel(0, QModelIndex(), text1));
+}
+
 // Generate 3 problems, all with different paths, different severity
 // Also generates a problem with diagnostics
 void TestProblemModel::generateProblems()
 {
     IProblem::Ptr p1(new DetectedProblem());
     IProblem::Ptr p2(new DetectedProblem());
     IProblem::Ptr p3(new DetectedProblem());
 
     DocumentRange r1;
     r1.document = IndexedString("/just/a/random/path");
 
     p1->setDescription(QStringLiteral("PROBLEM1"));
     p1->setSeverity(IProblem::Error);
     p1->setFinalLocation(r1);
 
     DocumentRange r2;
     r2.document = IndexedString("/just/another/path");
 
     p2->setDescription(QStringLiteral("PROBLEM2"));
     p2->setSeverity(IProblem::Warning);
     p2->setFinalLocation(r2);
 
     DocumentRange r3;
     r3.document = IndexedString("/yet/another/test/path");
 
     p2->setDescription(QStringLiteral("PROBLEM3"));
     p3->setSeverity(IProblem::Hint);
     p3->setFinalLocation(r3);
 
     m_problems.push_back(p1);
     m_problems.push_back(p2);
     m_problems.push_back(p3);
 
     // Problem for diagnostic testing
     IProblem::Ptr p(new DetectedProblem());
     DocumentRange r;
     r.document = IndexedString("DIAGTEST");
     p->setFinalLocation(r);
     p->setDescription(QStringLiteral("PROBLEM"));
     p->setSeverity(IProblem::Error);
 
     IProblem::Ptr d(new DetectedProblem());
     d->setDescription(QStringLiteral("DIAG"));
 
     IProblem::Ptr dd(new DetectedProblem());
     dd->setDescription(QStringLiteral("DIAGDIAG"));
     d->addDiagnostic(dd);
     p->addDiagnostic(d);
     m_diagnosticTestProblem = p;
 }
 
 bool TestProblemModel::checkIsSame(int row, const QModelIndex &parent, const IProblem::Ptr &problem)
 {
     QModelIndex idx;
 
     idx = m_model->index(row, 0, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), problem->description());
 
     return true;
 }
 
 bool TestProblemModel::checkDiagnostics(int row, const QModelIndex &parent)
 {
     MYCOMPARE(m_model->rowCount(parent), 1);
 
     QModelIndex idx;
     idx = m_model->index(row, 0, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), m_diagnosticTestProblem->description());
 
     QModelIndex diagidx;
     IProblem::Ptr diag = m_diagnosticTestProblem->diagnostics().at(0);
     diagidx = m_model->index(0, 0, idx);
     MYVERIFY(diagidx.isValid());
     MYCOMPARE(m_model->data(diagidx).toString(), diag->description());
 
     QModelIndex diagdiagidx;
     IProblem::Ptr diagdiag = diag->diagnostics().at(0);
     diagdiagidx = m_model->index(0, 0, diagidx);
     MYVERIFY(diagdiagidx.isValid());
     MYCOMPARE(m_model->data(diagdiagidx).toString(), diagdiag->description());
 
     return true;
 }
 
 bool TestProblemModel::checkDisplay(int row, const QModelIndex &parent, const IProblem::Ptr &problem)
 {
     QModelIndex idx;
 
     idx = m_model->index(row, 0, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), problem->description());
 
     idx = m_model->index(row, 1, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), problem->sourceString());
 
     idx = m_model->index(row, 2, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), problem->finalLocation().document.str());
 
     idx = m_model->index(row, 3, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), QString::number(problem->finalLocation().start().line() + 1));
 
     idx = m_model->index(row, 4, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), QString::number(problem->finalLocation().start().column() + 1));
 
     return true;
 }
 
 bool TestProblemModel::checkLabel(int row, const QModelIndex &parent, const QString &label)
 {
     QModelIndex idx = m_model->index(row, 0, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), label);
 
     return true;
 }
 
 bool TestProblemModel::checkPathGroup(int row, const IProblem::Ptr &problem)
 {
     QModelIndex parent = m_model->index(row, 0);
     MYVERIFY(parent.isValid());
     MYCOMPARE(m_model->data(parent).toString(), problem->finalLocation().document.str());
 
     QModelIndex idx = m_model->index(0, 0, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), problem->description());
 
     return true;
 }
 
 bool TestProblemModel::checkSeverityGroup(int row, const IProblem::Ptr &problem)
 {
     QModelIndex parent = m_model->index(row, 0);
     MYVERIFY(parent.isValid());
     MYCOMPARE(m_model->data(parent).toString(), problem->severityString());
 
     QModelIndex idx = m_model->index(0, 0, parent);
     MYVERIFY(idx.isValid());
     MYCOMPARE(m_model->data(idx).toString(), problem->description());
 
     return true;
 }
 
 QTEST_MAIN(TestProblemModel)
 
 #include "test_problemmodel.moc"