diff --git a/libs/image/kis_keyframe_channel.cpp b/libs/image/kis_keyframe_channel.cpp
index 81ba16b6ff..1755aab22b 100644
--- a/libs/image/kis_keyframe_channel.cpp
+++ b/libs/image/kis_keyframe_channel.cpp
@@ -1,513 +1,515 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_keyframe_channel.h"
 #include "KoID.h"
 #include "kis_global.h"
 #include "kis_node.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 
 #include <QMap>
 
 const KoID KisKeyframeChannel::Content = KoID("content", ki18n("Content"));
 
 struct KisKeyframeChannel::Private
 {
     Private() {}
     Private(const Private &rhs, KisNodeWSP newParentNode) {
         keys = rhs.keys;
         node = newParentNode;
         id = rhs.id;
         defaultBounds = rhs.defaultBounds;
     }
 
     KeyframesMap keys;
     KisNodeWSP node;
     KoID id;
     KisDefaultBoundsBaseSP defaultBounds;
 };
 
 struct KisKeyframeChannel::InsertFrameCommand : public KUndo2Command
 {
     InsertFrameCommand(KisKeyframeChannel *channel, KisKeyframeSP keyframe, bool insert, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_insert(insert)
     {
     }
 
     void redo() {
         doSwap(m_insert);
     }
 
     void undo() {
         doSwap(!m_insert);
     }
 
 private:
     void doSwap(bool insert) {
         if (insert) {
             m_channel->insertKeyframeLogical(m_keyframe);
         } else {
             m_channel->deleteKeyframeLogical(m_keyframe);
         }
     }
 
 private:
     KisKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     bool m_insert;
 };
 
 struct KisKeyframeChannel::MoveFrameCommand : public KUndo2Command
 {
     MoveFrameCommand(KisKeyframeChannel *channel, KisKeyframeSP keyframe, int oldTime, int newTime, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldTime(oldTime),
           m_newTime(newTime)
     {
     }
 
     void redo() {
         m_channel->moveKeyframeImpl(m_keyframe, m_newTime);
     }
 
     void undo() {
         m_channel->moveKeyframeImpl(m_keyframe, m_oldTime);
     }
 
 private:
     KisKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     int m_oldTime;
     int m_newTime;
 };
 
 KisKeyframeChannel::KisKeyframeChannel(const KoID &id, KisNodeWSP node, KisDefaultBoundsBaseSP defaultBounds)
     : m_d(new Private)
 {
     m_d->id = id;
     m_d->node = node;
     m_d->defaultBounds = defaultBounds;
 }
 
 KisKeyframeChannel::KisKeyframeChannel(const KisKeyframeChannel &rhs, KisNodeWSP newParentNode)
     : m_d(new Private(*rhs.m_d, newParentNode))
 {
     KIS_ASSERT_RECOVER_NOOP(&rhs != this);
 }
 
 KisKeyframeChannel::~KisKeyframeChannel()
 {}
 
 QString KisKeyframeChannel::id() const
 {
     return m_d->id.id();
 }
 
 QString KisKeyframeChannel::name() const
 {
     return m_d->id.name();
 }
 
 KisNodeWSP KisKeyframeChannel::node() const
 {
     return m_d->node;
 }
 
 #define LAZY_INITIALIZE_PARENT_COMMAND(cmd)       \
     QScopedPointer<KUndo2Command> __tempCommand;  \
     if (!parentCommand) {                         \
         __tempCommand.reset(new KUndo2Command()); \
         cmd = __tempCommand.data();               \
     }
 
 KisKeyframeSP KisKeyframeChannel::addKeyframe(int time, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
     return insertKeyframe(time, KisKeyframeSP(), parentCommand);
 }
 
 void KisKeyframeChannel::deleteKeyframeLogical(KisKeyframeSP keyframe)
 {
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(keyframe->time());
 
     emit sigKeyframeAboutToBeRemoved(keyframe.data());
     m_d->keys.remove(keyframe->time());
     emit sigKeyframeRemoved(keyframe.data());
 
     requestUpdate(range, rect);
 }
 
 
 bool KisKeyframeChannel::deleteKeyframeImpl(KisKeyframeSP keyframe, KUndo2Command *parentCommand, bool recreate)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     Q_ASSERT(parentCommand);
 
     KUndo2Command *cmd = new InsertFrameCommand(this, keyframe, false, parentCommand);
     cmd->redo();
     destroyKeyframe(keyframe, parentCommand);
 
     if (recreate && keyframe->time() == 0) {
         addKeyframe(0, parentCommand);
     }
 
     return true;
 }
 
 bool KisKeyframeChannel::deleteKeyframe(KisKeyframeSP keyframe, KUndo2Command *parentCommand)
 {
     return deleteKeyframeImpl(keyframe, parentCommand, true);
 }
 
 void KisKeyframeChannel::moveKeyframeImpl(KisKeyframeSP keyframe, int newTime)
 {
     KIS_ASSERT_RECOVER_RETURN(keyframe);
     KIS_ASSERT_RECOVER_RETURN(!keyframeAt(newTime));
 
     KisTimeRange rangeSrc = affectedFrames(keyframe->time());
     QRect rectSrc = affectedRect(keyframe);
 
     emit sigKeyframeAboutToBeMoved(keyframe.data(), newTime);
 
     m_d->keys.remove(keyframe->time());
     int oldTime = keyframe->time();
     keyframe->setTime(newTime);
     m_d->keys.insert(newTime, keyframe);
 
     emit sigKeyframeMoved(keyframe.data(), oldTime);
 
     KisTimeRange rangeDst = affectedFrames(keyframe->time());
     QRect rectDst = affectedRect(keyframe);
 
     requestUpdate(rangeSrc, rectSrc);
     requestUpdate(rangeDst, rectDst);
 }
 
 bool KisKeyframeChannel::moveKeyframe(KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
+    if (newTime == keyframe->time()) return false;
+
     KisKeyframeSP other = keyframeAt(newTime);
     if (other) {
         deleteKeyframeImpl(other, parentCommand, false);
     }
 
     const int srcTime = keyframe->time();
 
     KUndo2Command *cmd = new MoveFrameCommand(this, keyframe, srcTime, newTime, parentCommand);
     cmd->redo();
 
     if (srcTime == 0) {
         addKeyframe(srcTime, parentCommand);
     }
 
     return true;
 }
 
 KisKeyframeSP KisKeyframeChannel::copyKeyframe(const KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
     return insertKeyframe(newTime, keyframe, parentCommand);
 }
 
 KisKeyframeSP KisKeyframeChannel::keyframeAt(int time) const
 {
     KeyframesMap::const_iterator i = m_d->keys.constFind(time);
     if (i != m_d->keys.constEnd()) {
         return i.value();
     }
 
     return KisKeyframeSP();
 }
 
 KisKeyframeSP KisKeyframeChannel::activeKeyframeAt(int time) const
 {
     return activeKeyIterator(time).value();
 }
 
 KisKeyframeSP KisKeyframeChannel::currentlyActiveKeyframe() const
 {
     return activeKeyframeAt(currentTime());
 }
 
 KisKeyframeSP KisKeyframeChannel::firstKeyframe() const
 {
     return keyframeAt(0);
 }
 
 KisKeyframeSP KisKeyframeChannel::nextKeyframe(KisKeyframeSP keyframe) const
 {
     KeyframesMap::iterator i = m_d->keys.find(keyframe->time());
     if (i == m_d->keys.end()) return KisKeyframeSP(0);
 
     i++;
 
     if (i == m_d->keys.end()) return KisKeyframeSP(0);
     return i.value();
 }
 
 KisKeyframeSP KisKeyframeChannel::previousKeyframe(KisKeyframeSP keyframe) const
 {
     KeyframesMap::iterator i = m_d->keys.find(keyframe->time());
     if (i == m_d->keys.begin() || i == m_d->keys.end()) return KisKeyframeSP(0);
     i--;
 
     return i.value();
 }
 
 KisKeyframeSP KisKeyframeChannel::lastKeyframe() const
 {
     if (m_d->keys.isEmpty()) return KisKeyframeSP(0);
 
     return (m_d->keys.end()-1).value();
 }
 
 int KisKeyframeChannel::framesHash() const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int hash = 0;
 
     while (it != end) {
         hash += it.key();
         ++it;
     }
 
     return hash;
 }
 
 QSet<int> KisKeyframeChannel::allKeyframeIds() const
 {
     QSet<int> frames;
 
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     while (it != end) {
         frames.insert(it.key());
         ++it;
     }
 
     return frames;
 }
 
 KisTimeRange KisKeyframeChannel::affectedFrames(int time) const
 {
     return identicalFrames(time);
 }
 
 KisTimeRange KisKeyframeChannel::identicalFrames(int time) const
 {
     if (m_d->keys.isEmpty()) return KisTimeRange::infinite(0);
 
     KeyframesMap::const_iterator active = activeKeyIterator(time);
     KeyframesMap::const_iterator next = active + 1;
 
     int from;
 
     if (active == m_d->keys.constBegin()) {
         // First key affects even the frames before it
         from = 0;
     } else {
         from = active.key();
     }
 
     if (next == m_d->keys.constEnd()) {
         return KisTimeRange::infinite(from);
     } else {
         return KisTimeRange::fromTime(from, next.key() - 1);
     }
 }
 
 int KisKeyframeChannel::keyframeCount() const
 {
     return m_d->keys.count();
 }
 
 int KisKeyframeChannel::keyframeRowIndexOf(KisKeyframeSP keyframe) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int row = 0;
 
     for (; it != end; ++it) {
         if (it.value().data() == keyframe) {
             return row;
         }
 
         row++;
     }
 
     return -1;
 }
 
 KisKeyframeSP KisKeyframeChannel::keyframeAtRow(int row) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     for (; it != end; ++it) {
         if (row <= 0) {
             return it.value();
         }
 
         row--;
     }
 
     return KisKeyframeSP();
 }
 
 int KisKeyframeChannel::keyframeInsertionRow(int time) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int row = 0;
 
     for (; it != end; ++it) {
         if (it.value()->time() > time) {
             break;
         }
         row++;
     }
 
     return row;
 }
 
 QDomElement KisKeyframeChannel::toXML(QDomDocument doc, const QString &layerFilename)
 {
     QDomElement channelElement = doc.createElement("channel");
 
     channelElement.setAttribute("name", id());
 
     Q_FOREACH (KisKeyframeSP keyframe, m_d->keys.values()) {
         QDomElement keyframeElement = doc.createElement("keyframe");
         keyframeElement.setAttribute("time", keyframe->time());
 
         saveKeyframe(keyframe, keyframeElement, layerFilename);
 
         channelElement.appendChild(keyframeElement);
     }
 
     return channelElement;
 }
 
 void KisKeyframeChannel::loadXML(const QDomElement &channelNode)
 {
     for (QDomElement keyframeNode = channelNode.firstChildElement(); !keyframeNode.isNull(); keyframeNode = keyframeNode.nextSiblingElement()) {
         if (keyframeNode.nodeName().toUpper() != "KEYFRAME") continue;
 
         KisKeyframeSP keyframe = loadKeyframe(keyframeNode);
 
         m_d->keys.insert(keyframe->time(), keyframe);
     }
 }
 
 KisKeyframeChannel::KeyframesMap& KisKeyframeChannel::keys()
 {
     return m_d->keys;
 }
 
 const KisKeyframeChannel::KeyframesMap& KisKeyframeChannel::constKeys() const
 {
     return m_d->keys;
 }
 
 void KisKeyframeChannel::insertKeyframeLogical(KisKeyframeSP keyframe)
 {
     const int time = keyframe->time();
 
     emit sigKeyframeAboutToBeAdded(keyframe.data());
     m_d->keys.insert(time, keyframe);
     emit sigKeyframeAdded(keyframe.data());
 
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(time);
     requestUpdate(range, rect);
 }
 
 KisKeyframeSP KisKeyframeChannel::insertKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
     KisKeyframeSP keyframe = keyframeAt(time);
     if (keyframe) {
         deleteKeyframeImpl(keyframe, parentCommand, false);
     }
 
     Q_ASSERT(parentCommand);
     keyframe = createKeyframe(time, copySrc, parentCommand);
 
     KUndo2Command *cmd = new InsertFrameCommand(this, keyframe, true, parentCommand);
     cmd->redo();
 
     return keyframe;
 }
 
 KisKeyframeSP KisKeyframeChannel::copyExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, int dstTime, KUndo2Command *parentCommand)
 {
     if (srcChannel->id() != id()) {
         warnKrita << "Cannot copy frames from different ids:" << ppVar(srcChannel->id()) << ppVar(id());
         return KisKeyframeSP();
     }
 
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     KisKeyframeSP dstFrame = keyframeAt(dstTime);
     if (dstFrame) {
         deleteKeyframeImpl(dstFrame, parentCommand, false);
     }
 
     KisKeyframeSP newKeyframe = createKeyframe(dstTime, KisKeyframeSP(), parentCommand);
     uploadExternalKeyframe(srcChannel, srcTime, newKeyframe);
 
     KUndo2Command *cmd = new InsertFrameCommand(this, newKeyframe, true, parentCommand);
     cmd->redo();
 
     return newKeyframe;
 }
 
 KisKeyframeChannel::KeyframesMap::const_iterator
 KisKeyframeChannel::activeKeyIterator(int time) const
 {
     KeyframesMap::const_iterator i = const_cast<const KeyframesMap*>(&m_d->keys)->upperBound(time);
 
     if (i != m_d->keys.constBegin()) i--;
 
     return i;
 }
 
 void KisKeyframeChannel::requestUpdate(const KisTimeRange &range, const QRect &rect)
 {
     if (m_d->node) {
         m_d->node->invalidateFrames(range, rect);
     }
 }
 
 int KisKeyframeChannel::currentTime() const
 {
     return m_d->defaultBounds->currentTime();
 }
diff --git a/libs/image/kis_scalar_keyframe_channel.cpp b/libs/image/kis_scalar_keyframe_channel.cpp
index fc1feccfca..a6d10faad4 100644
--- a/libs/image/kis_scalar_keyframe_channel.cpp
+++ b/libs/image/kis_scalar_keyframe_channel.cpp
@@ -1,203 +1,203 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_scalar_keyframe_channel.h"
 #include "kis_node.h"
 #include "kundo2command.h"
 
 #include "kis_global.h"
 
 
 struct KisScalarKeyframeChannel::Private
 {
 public:
     Private(qreal min, qreal max)
         : minValue(min), maxValue(max), firstFreeIndex(0)
     {}
 
     qreal minValue;
     qreal maxValue;
     QMap<int, qreal> values;
     int firstFreeIndex;
 
     struct InsertValueCommand;
     struct SetValueCommand;
 };
 
 KisScalarKeyframeChannel::KisScalarKeyframeChannel(const KoID &id, KisNodeWSP node, qreal minValue, qreal maxValue, KisDefaultBoundsBaseSP defaultBounds)
     : KisKeyframeChannel(id, node, defaultBounds),
       m_d(new Private(minValue, maxValue))
 {
 }
 
 KisScalarKeyframeChannel::~KisScalarKeyframeChannel()
 {}
 
 bool KisScalarKeyframeChannel::hasScalarValue() const
 {
     return true;
 }
 
 qreal KisScalarKeyframeChannel::minScalarValue() const
 {
     return m_d->minValue;
 }
 
 qreal KisScalarKeyframeChannel::maxScalarValue() const
 {
     return m_d->maxValue;
 }
 
 qreal KisScalarKeyframeChannel::scalarValue(const KisKeyframeSP keyframe) const
 {
     return m_d->values[keyframe->value()];
 }
 
 struct KisScalarKeyframeChannel::Private::SetValueCommand : public KUndo2Command
 {
     SetValueCommand(KisScalarKeyframeChannel::Private *d, int index, qreal oldValue, qreal newValue, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_d(d),
           m_index(index),
           m_oldValue(oldValue),
           m_newValue(newValue)
     {
     }
 
     void redo() {
         m_d->values[m_index] = m_newValue;
     }
 
     void undo() {
         m_d->values[m_index] = m_oldValue;
     }
 
 private:
     KisScalarKeyframeChannel::Private *m_d;
     int m_index;
     qreal m_oldValue;
     qreal m_newValue;
 };
 
 void KisScalarKeyframeChannel::setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand)
 {
     QScopedPointer<KUndo2Command> tempCommand;
     if (!parentCommand) {
         tempCommand.reset(new KUndo2Command());
         parentCommand = tempCommand.data();
     }
 
     int index = keyframe->value();
     KUndo2Command *cmd = new Private::SetValueCommand(m_d.data(), index, m_d->values[index], value, parentCommand);
     cmd->redo();
 }
 
 struct KisScalarKeyframeChannel::Private::InsertValueCommand : public KUndo2Command
 {
     InsertValueCommand(KisScalarKeyframeChannel::Private *d, int index, qreal value, bool insert, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_d(d),
           m_index(index),
           m_value(value),
           m_insert(insert)
     {
     }
 
     void redo() {
         doSwap(m_insert);
     }
 
     void undo() {
         doSwap(!m_insert);
     }
 
 private:
     void doSwap(bool insert) {
         if (insert) {
             m_d->values[m_index] = m_value;
         } else {
             m_d->values.remove(m_index);
         }
     }
 
 private:
     KisScalarKeyframeChannel::Private *m_d;
     int m_index;
     qreal m_value;
     bool m_insert;
 };
 
 KisKeyframeSP KisScalarKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
-    qreal value = (copySrc != 0) ? scalarValue(copySrc) : 0;
+    qreal value = (copySrc.isNull() ? 0 : scalarValue(copySrc));
     int index = m_d->firstFreeIndex++;
 
     KUndo2Command *cmd = new Private::InsertValueCommand(m_d.data(), index, value, true, parentCommand);
     cmd->redo();
 
     return toQShared(new KisKeyframe(this, time, index));
 }
 
 void KisScalarKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
 {
     int index = key->value();
 
     KIS_ASSERT_RECOVER_RETURN(m_d->values.contains(index));
 
     KUndo2Command *cmd = new Private::InsertValueCommand(m_d.data(), index, m_d->values[index], false, parentCommand);
     cmd->redo();
 }
 
 void KisScalarKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
 {
     KisScalarKeyframeChannel *srcScalarChannel = dynamic_cast<KisScalarKeyframeChannel*>(srcChannel);
     KIS_ASSERT_RECOVER_RETURN(srcScalarChannel);
 
     KisKeyframeSP srcFrame = srcScalarChannel->keyframeAt(srcTime);
     KIS_ASSERT_RECOVER_RETURN(srcFrame);
 
     const qreal newValue = scalarValue(srcFrame);
 
     const int dstId = dstFrame->value();
     KIS_ASSERT_RECOVER_RETURN(m_d->values.contains(dstId));
     m_d->values[dstId] = newValue;
 }
 
 QRect KisScalarKeyframeChannel::affectedRect(KisKeyframeSP key)
 {
     Q_UNUSED(key);
     return QRect();
 }
 
 void KisScalarKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
 {
     Q_UNUSED(layerFilename);
     keyframeElement.setAttribute("value", m_d->values[keyframe->value()]);
 }
 
 KisKeyframeSP KisScalarKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
     int time = keyframeNode.toElement().attribute("time").toUInt();
     QVariant value = keyframeNode.toElement().attribute("value");
 
     KUndo2Command tempParentCommand;
     KisKeyframeSP keyframe = createKeyframe(time, KisKeyframeSP(), &tempParentCommand);
     setScalarValue(keyframe, value.toReal());
 
     return keyframe;
 }
diff --git a/libs/image/tests/CMakeLists.txt b/libs/image/tests/CMakeLists.txt
index 0be4d81114..53bfad6bea 100644
--- a/libs/image/tests/CMakeLists.txt
+++ b/libs/image/tests/CMakeLists.txt
@@ -1,690 +1,690 @@
 # cmake in some versions for some not yet known reasons fails to run automoc
 # on random targets (changing target names already has an effect)
 # As temporary workaround skipping build of tests on these versions for now
 # See https://mail.kde.org/pipermail/kde-buildsystem/2015-June/010819.html
 # extend range of affected cmake versions as needed
 if(NOT ${CMAKE_VERSION} VERSION_LESS 3.1.3 AND
    NOT ${CMAKE_VERSION} VERSION_GREATER 3.2.3)
     message(WARNING "Skipping krita/image/tests, CMake in at least versions 3.1.3 - 3.2.3 seems to have a problem with automoc.  \n(FRIENDLY REMINDER: PLEASE DON'T BREAK THE TESTS!)")
     set (HAVE_FAILING_CMAKE TRUE)
 else()
     set (HAVE_FAILING_CMAKE FALSE)
 endif()
 
 include_directories(
     ${CMAKE_SOURCE_DIR}/libs/image/metadata
     ${CMAKE_BINARY_DIR}/libs/image/
     ${CMAKE_SOURCE_DIR}/libs/image/
     ${CMAKE_SOURCE_DIR}/libs/image/brushengine
     ${CMAKE_SOURCE_DIR}/libs/image/tiles3
     ${CMAKE_SOURCE_DIR}/libs/image/tiles3/swap
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 include_Directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${Boost_INCLUDE_DIRS}
 )
 
 if(HAVE_VC)
   include_directories(${Vc_INCLUDE_DIR})
 endif()
 
 macro_add_unittest_definitions()
 
 set(KisRandomGeneratorDemoSources kis_random_generator_demo.cpp kimageframe.cpp)
 ki18n_wrap_ui(KisRandomGeneratorDemoSources kis_random_generator_demo.ui)
 kde4_add_executable(KisRandomGeneratorDemo ${KisRandomGeneratorDemoSources})
 target_link_libraries(KisRandomGeneratorDemo  kritaimage )
 
 ########### next target ###############
 
 set(kis_base_node_test_SRCS kis_base_node_test.cpp )
 kde4_add_unit_test(KisBaseNodeTest TESTNAME krita-image-BaseNodeTest ${kis_base_node_test_SRCS})
 target_link_libraries(KisBaseNodeTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_fast_math_test_SRCS kis_fast_math_test.cpp )
 kde4_add_unit_test(KisFastMathTest TESTNAME krita-image-FastMathTest ${kis_fast_math_test_SRCS})
 target_link_libraries(KisFastMathTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_test_SRCS kis_node_test.cpp )
 kde4_add_unit_test(KisNodeTest TESTNAME krita-image-Node-Test ${kis_node_test_SRCS})
 target_link_libraries(KisNodeTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_facade_test_SRCS kis_node_facade_test.cpp )
 kde4_add_unit_test(KisNodeFacadeTest TESTNAME krita-image-NodeFacadeTest ${kis_node_facade_test_SRCS})
 target_link_libraries(KisNodeFacadeTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 if (NOT HAVE_FAILING_CMAKE)
   set(kis_paint_device_test_SRCS kis_paint_device_test.cpp )
   kde4_add_broken_unit_test(KisPaintDeviceTest TESTNAME krita-image-KisPaintDeviceTest ${kis_paint_device_test_SRCS})
   target_link_libraries(KisPaintDeviceTest   kritaimage kritaodf Qt5::Test)
 else()
   message(WARNING "Skipping KisPaintDeviceTest!!!!!!!!!!!!!!")
 endif()
 
 ########### next target ###############
 
 set(kis_fixed_paint_device_test_SRCS kis_fixed_paint_device_test.cpp )
 kde4_add_unit_test(KisFixedPaintDeviceTest TESTNAME krita-image-KisFixedPaintDeviceTest ${kis_fixed_paint_device_test_SRCS})
 target_link_libraries(KisFixedPaintDeviceTest   kritaimage Qt5::Test)
 
 
 ########### next target ###############
 
 set(kis_layer_test_SRCS kis_layer_test.cpp )
 kde4_add_unit_test(KisLayerTest TESTNAME krita-image-KisLayerTest  ${kis_layer_test_SRCS})
 target_link_libraries(KisLayerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_effect_mask_test_SRCS kis_effect_mask_test.cpp )
 kde4_add_unit_test(KisEffectMaskTest TESTNAME krita-image-KisEffectMaskTest  ${kis_effect_mask_test_SRCS})
 target_link_libraries(KisEffectMaskTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_iterator_test_SRCS kis_iterator_test.cpp )
 kde4_add_unit_test(KisIteratorTest TESTNAME krita-image-KisIteratorTest  ${kis_iterator_test_SRCS})
 target_link_libraries(KisIteratorTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_painter_test_SRCS kis_painter_test.cpp )
 
 
 kde4_add_unit_test(KisPainterTest TESTNAME krita-image-KisPainterTest ${kis_painter_test_SRCS})
 
 target_link_libraries(KisPainterTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_selection_test_SRCS kis_selection_test.cpp )
 
 kde4_add_unit_test(KisSelectionTest TESTNAME krita-image-SelectionTest ${kis_selection_test_SRCS})
 
 target_link_libraries(KisSelectionTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_count_visitor_test_SRCS kis_count_visitor_test.cpp )
 
 kde4_add_unit_test(KisCountVisitorTest TESTNAME krita-image-KisCountVisitorTest ${kis_count_visitor_test_SRCS})
 
 target_link_libraries(KisCountVisitorTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 set(kis_projection_test_SRCS kis_projection_test.cpp )
 
 kde4_add_unit_test(KisProjectionTest TESTNAME krita-image-KisProjectionTest ${kis_projection_test_SRCS})
 
 target_link_libraries(KisProjectionTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_properties_configuration_test_SRCS kis_properties_configuration_test.cpp )
 
 kde4_add_unit_test(Kis_Properties_Configuration_Test TESTNAME krita-image-properties-configuration-Test ${kis_properties_configuration_test_SRCS})
 
 target_link_libraries(Kis_Properties_Configuration_Test   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_transaction_test_SRCS kis_transaction_test.cpp )
 
 kde4_add_unit_test(KisTransactionTest TESTNAME krita-image-KisTransactionTest ${kis_transaction_test_SRCS})
 
 target_link_libraries(KisTransactionTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_pixel_selection_test_SRCS kis_pixel_selection_test.cpp )
 
 kde4_add_unit_test(KisPixelSelectionTest TESTNAME krita-image-KisPixelSelectionTest ${kis_pixel_selection_test_SRCS})
 
 target_link_libraries(KisPixelSelectionTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_group_layer_test_SRCS kis_group_layer_test.cpp )
 
 kde4_add_unit_test(KisGroupLayerTest TESTNAME krita-image-KisGroupLayerTest ${kis_group_layer_test_SRCS})
 
 target_link_libraries(KisGroupLayerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 if (NOT HAVE_FAILING_CMAKE)
   set(kis_filter_mask_test_SRCS kis_filter_mask_test.cpp )
   kde4_add_broken_unit_test(KisFilterMaskTest TESTNAME krita-image-KisFilterMaskTest ${kis_filter_mask_test_SRCS})
   target_link_libraries(KisFilterMaskTest   kritaimage Qt5::Test)
 else()
   message(WARNING "Skipping KisFilterMaskTest!!!!!!!!!!!!!!")
 endif()
 
 ########### next target ###############
 
 set(kis_transform_mask_test_SRCS kis_transform_mask_test.cpp )
 
 kde4_add_broken_unit_test(KisTransformMaskTest TESTNAME krita-image-KisTransformMaskTest ${kis_transform_mask_test_SRCS})
 
 target_link_libraries(KisTransformMaskTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_paint_layer_test_SRCS kis_paint_layer_test.cpp )
 
 kde4_add_unit_test(KisPaintLayerTest TESTNAME krita-image-KisPaintLayerTest ${kis_paint_layer_test_SRCS})
 
 target_link_libraries(KisPaintLayerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_adjustment_layer_test_SRCS kis_adjustment_layer_test.cpp )
 kde4_add_unit_test(KisAdjustmentLayerTest TESTNAME krita-image-KisAdjustmentLayerTest ${kis_adjustment_layer_test_SRCS})
 target_link_libraries(KisAdjustmentLayerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_annotation_test_SRCS kis_annotation_test.cpp )
 kde4_add_unit_test(KisAnnotationTest TESTNAME krita-image-KisAnnotationTest ${kis_annotation_test_SRCS})
 target_link_libraries(KisAnnotationTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_bookmarked_configuration_manager_test_SRCS kis_bookmarked_configuration_manager_test.cpp )
 kde4_add_unit_test(KisBookmarkedConfigurationManagerTest TESTNAME krita-image-KisBookmarkedConfigurationManagerTest ${kis_bookmarked_configuration_manager_test_SRCS})
 target_link_libraries(KisBookmarkedConfigurationManagerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_change_profile_visitor_test_SRCS kis_change_profile_visitor_test.cpp )
 kde4_add_unit_test(KisChangeProfileVisitorTest TESTNAME krita-image-KisChangeProfileVisitorTest ${kis_change_profile_visitor_test_SRCS})
 target_link_libraries(KisChangeProfileVisitorTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_clone_layer_test_SRCS kis_clone_layer_test.cpp )
 kde4_add_unit_test(KisCloneLayerTest TESTNAME krita-image-KisCloneLayerTest ${kis_clone_layer_test_SRCS})
 target_link_libraries(KisCloneLayerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_colorspace_convert_visitor_test_SRCS kis_colorspace_convert_visitor_test.cpp )
 kde4_add_unit_test(KisColorspaceConvertVisitorTest TESTNAME krita-image-KisColorspaceConvertVisitorTest ${kis_colorspace_convert_visitor_test_SRCS})
 target_link_libraries(KisColorspaceConvertVisitorTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_convolution_painter_test_SRCS kis_convolution_painter_test.cpp )
 kde4_add_unit_test(KisConvolutionPainterTest TESTNAME krita-image-KisConvolutionPainterTest ${kis_convolution_painter_test_SRCS})
 target_link_libraries(KisConvolutionPainterTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_crop_processing_visitor_test_SRCS kis_crop_processing_visitor_test.cpp )
 kde4_add_unit_test(KisCropProcessingVisitorTest TESTNAME krita-image-KisCropProcessingVisitorTest ${kis_crop_processing_visitor_test_SRCS})
 target_link_libraries(KisCropProcessingVisitorTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_processing_applicator_test_SRCS kis_processing_applicator_test.cpp )
 kde4_add_unit_test(KisProcessingApplicatorTest TESTNAME krita-image-KisProcessingApplicatorTest ${kis_processing_applicator_test_SRCS})
 target_link_libraries(KisProcessingApplicatorTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_datamanager_test_SRCS kis_datamanager_test.cpp )
 kde4_add_unit_test(KisDatamanagerTest TESTNAME krita-image-KisDatamanagerTest ${kis_datamanager_test_SRCS})
 target_link_libraries(KisDatamanagerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_fill_painter_test_SRCS kis_fill_painter_test.cpp )
 kde4_add_unit_test(KisFillPainterTest TESTNAME krita-image-KisFillPainterTest ${kis_fill_painter_test_SRCS})
 target_link_libraries(KisFillPainterTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_filter_configuration_test_SRCS kis_filter_configuration_test.cpp )
 kde4_add_unit_test(KisFilterConfigurationTest TESTNAME krita-image-KisFilterConfigurationTest ${kis_filter_configuration_test_SRCS})
 target_link_libraries(KisFilterConfigurationTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_filter_test_SRCS kis_filter_test.cpp )
 kde4_add_unit_test(KisFilterTest TESTNAME krita-image-KisFilterTest ${kis_filter_test_SRCS})
 target_link_libraries(KisFilterTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_filter_processing_information_test_SRCS kis_filter_processing_information_test.cpp )
 kde4_add_unit_test(KisFilterProcessingInformationTest TESTNAME krita-image-KisFilterProcessingInformationTest ${kis_filter_processing_information_test_SRCS})
 target_link_libraries(KisFilterProcessingInformationTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_filter_registry_test_SRCS kis_filter_registry_test.cpp )
 kde4_add_unit_test(KisFilterRegistryTest TESTNAME krita-image-KisFilterRegistryTest ${kis_filter_registry_test_SRCS})
 target_link_libraries(KisFilterRegistryTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_filter_strategy_test_SRCS kis_filter_strategy_test.cpp )
 kde4_add_unit_test(KisFilterStrategyTest TESTNAME krita-image-KisFilterStrategyTest ${kis_filter_strategy_test_SRCS})
 target_link_libraries(KisFilterStrategyTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_gradient_painter_test_SRCS kis_gradient_painter_test.cpp )
 kde4_add_unit_test(KisGradientPainterTest TESTNAME krita-image-KisGradientPainterTest ${kis_gradient_painter_test_SRCS})
 target_link_libraries(KisGradientPainterTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_histogram_test_SRCS kis_histogram_test.cpp )
 kde4_add_broken_unit_test(KisHistogramTest TESTNAME krita-image-KisHistogramTest ${kis_histogram_test_SRCS})
 target_link_libraries(KisHistogramTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_image_commands_test_SRCS kis_image_commands_test.cpp )
 kde4_add_unit_test(KisImageCommandsTest TESTNAME krita-image-KisImageCommandsTest ${kis_image_commands_test_SRCS})
 target_link_libraries(KisImageCommandsTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_image_test_SRCS kis_image_test.cpp )
 kde4_add_unit_test(KisImageTest TESTNAME krita-image-KisImageTest ${kis_image_test_SRCS})
 target_link_libraries(KisImageTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_image_signal_router_test_SRCS kis_image_signal_router_test.cpp )
 kde4_add_unit_test(KisImageSignalRouterTest TESTNAME krita-image-KisImageSignalRouterTest ${kis_image_signal_router_test_SRCS})
 target_link_libraries(KisImageSignalRouterTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_iterators_ng_test_SRCS kis_iterators_ng_test.cpp )
 kde4_add_unit_test(KisIteratorsNGTest TESTNAME krita-image-KisIteratorsNGTest ${kis_iterators_ng_test_SRCS})
 target_link_libraries(KisIteratorsNGTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_iterator_benchmark_SRCS kis_iterator_benchmark.cpp )
 kde4_add_unit_test(KisIteratorBenchmark TESTNAME krita-image-KisIteratorBenchmark ${kis_iterator_benchmark_SRCS})
 target_link_libraries(KisIteratorBenchmark   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_walkers_test_SRCS kis_walkers_test.cpp )
 kde4_add_broken_unit_test(KisWalkersTest TESTNAME krita-image-KisWalkersTest ${kis_walkers_test_SRCS})
 target_link_libraries(KisWalkersTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_async_merger_test_SRCS kis_async_merger_test.cpp )
 kde4_add_broken_unit_test(KisAsyncMergerTest TESTNAME krita-image-KisAsyncMergerTest ${kis_async_merger_test_SRCS})
 target_link_libraries(KisAsyncMergerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_updater_context_test_SRCS kis_updater_context_test.cpp )
 kde4_add_unit_test(KisUpdaterContextTest TESTNAME krita-image-KisUpdaterContextTest ${kis_updater_context_test_SRCS})
 target_link_libraries(KisUpdaterContextTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_simple_update_queue_test_SRCS kis_simple_update_queue_test.cpp )
 kde4_add_unit_test(KisSimpleUpdateQueueTest TESTNAME krita-image-KisSimpleUpdateQueueTest ${kis_simple_update_queue_test_SRCS})
 target_link_libraries(KisSimpleUpdateQueueTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_update_scheduler_test_SRCS kis_update_scheduler_test.cpp )
 kde4_add_broken_unit_test(KisUpdateSchedulerTest TESTNAME krita-image-KisUpdateSchedulerTest ${kis_update_scheduler_test_SRCS})
 target_link_libraries(KisUpdateSchedulerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_stroke_test_SRCS kis_stroke_test.cpp )
 kde4_add_unit_test(KisStrokeTest TESTNAME krita-image-KisStrokeTest ${kis_stroke_test_SRCS})
 target_link_libraries(KisStrokeTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_simple_stroke_strategy_test_SRCS kis_simple_stroke_strategy_test.cpp )
 kde4_add_unit_test(KisSimpleStrokeStrategyTest TESTNAME krita-image-KisSimpleStrokeStrategyTest ${kis_simple_stroke_strategy_test_SRCS})
 target_link_libraries(KisSimpleStrokeStrategyTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_stroke_strategy_undo_command_based_test_SRCS kis_stroke_strategy_undo_command_based_test.cpp )
 kde4_add_unit_test(KisStrokeStrategyUndoCommandBasedTest TESTNAME krita-image-KisStrokeStrategyUndoCommandBasedTest ${kis_stroke_strategy_undo_command_based_test_SRCS})
 target_link_libraries(KisStrokeStrategyUndoCommandBasedTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_strokes_queue_test_SRCS kis_strokes_queue_test.cpp )
 kde4_add_unit_test(KisStrokesQueueTest TESTNAME krita-image-KisStrokesQueueTest ${kis_strokes_queue_test_SRCS})
 target_link_libraries(KisStrokesQueueTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_queues_progress_updater_test_SRCS kis_queues_progress_updater_test.cpp )
 kde4_add_broken_unit_test(KisQueuesProgressUpdaterTest TESTNAME krita-image-KisQueuesProgressUpdaterTest ${kis_queues_progress_updater_test_SRCS})
 target_link_libraries(KisQueuesProgressUpdaterTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_macro_test_SRCS kis_macro_test.cpp )
 kde4_add_unit_test(KisMacroTest TESTNAME krita-image-KisMacroTest ${kis_macro_test_SRCS})
 target_link_libraries(KisMacroTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_mask_test_SRCS kis_mask_test.cpp )
 kde4_add_unit_test(KisMaskTest TESTNAME krita-image-KisMaskTest ${kis_mask_test_SRCS})
 target_link_libraries(KisMaskTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_math_toolbox_test_SRCS kis_math_toolbox_test.cpp )
 kde4_add_unit_test(KisMathToolboxTest TESTNAME krita-image-KisMathToolboxTest ${kis_math_toolbox_test_SRCS})
 target_link_libraries(KisMathToolboxTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_name_server_test_SRCS kis_name_server_test.cpp )
 kde4_add_unit_test(KisNameServerTest TESTNAME krita-image-KisNameServerTest ${kis_name_server_test_SRCS})
 target_link_libraries(KisNameServerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_commands_test_SRCS kis_node_commands_test.cpp )
 kde4_add_unit_test(KisNodeCommandsTest TESTNAME krita-image-KisNodeCommandsTest ${kis_node_commands_test_SRCS})
 target_link_libraries(KisNodeCommandsTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_graph_listener_test_SRCS kis_node_graph_listener_test.cpp )
 kde4_add_unit_test(KisNodeGraphListenerTest TESTNAME krita-image-KisNodeGraphListenerTest ${kis_node_graph_listener_test_SRCS})
 target_link_libraries(KisNodeGraphListenerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_visitor_test_SRCS kis_node_visitor_test.cpp )
 kde4_add_unit_test(KisNodeVisitorTest TESTNAME krita-image-KisNodeVisitorTest ${kis_node_visitor_test_SRCS})
 target_link_libraries(KisNodeVisitorTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_paint_information_test_SRCS kis_paint_information_test.cpp )
 kde4_add_unit_test(KisPaintInformationTest TESTNAME krita-image-KisPaintInformationTest ${kis_paint_information_test_SRCS})
 target_link_libraries(KisPaintInformationTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_paintop_test_SRCS kis_paintop_test.cpp )
 kde4_add_unit_test(KisPaintopTest TESTNAME krita-image-KisPaintopTest ${kis_paintop_test_SRCS})
 target_link_libraries(KisPaintopTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_pattern_test_SRCS kis_pattern_test.cpp )
 kde4_add_unit_test(KoPatternTest TESTNAME krita-image-KoPatternTest ${kis_pattern_test_SRCS})
 target_link_libraries(KoPatternTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_recorded_action_factory_registry_test_SRCS kis_recorded_action_factory_registry_test.cpp )
 kde4_add_unit_test(KisRecordedActionFactoryRegistryTest TESTNAME krita-image-KisRecordedActionFactoryRegistryTest ${kis_recorded_action_factory_registry_test_SRCS})
 target_link_libraries(KisRecordedActionFactoryRegistryTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_recorded_action_test_SRCS kis_recorded_action_test.cpp )
 kde4_add_unit_test(KisRecordedActionTest TESTNAME krita-image-KisRecordedActionTest ${kis_recorded_action_test_SRCS})
 target_link_libraries(KisRecordedActionTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_recorded_filter_action_test_SRCS kis_recorded_filter_action_test.cpp )
 kde4_add_unit_test(KisRecordedFilterActionTest TESTNAME krita-image-KisRecordedFilterActionTest ${kis_recorded_filter_action_test_SRCS})
 target_link_libraries(KisRecordedFilterActionTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_selection_mask_test_SRCS kis_selection_mask_test.cpp )
 kde4_add_unit_test(KisSelectionMaskTest TESTNAME krita-image-KisSelectionMaskTest ${kis_selection_mask_test_SRCS})
 target_link_libraries(KisSelectionMaskTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_shared_ptr_test_SRCS kis_shared_ptr_test.cpp )
 kde4_add_unit_test(KisSharedPtrTest TESTNAME krita-image-KisSharedPtrTest ${kis_shared_ptr_test_SRCS})
 target_link_libraries(KisSharedPtrTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 # kisdoc dep
 #set(kis_transform_worker_test_SRCS kis_transform_worker_test.cpp )
 #kde4_add_unit_test(KisTransformWorkerTest TESTNAME krita-image-KisTransformWorkerTest ${kis_transform_worker_test_SRCS})
 #target_link_libraries(KisTransformWorkerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 # kisdoc
 #set(kis_perspective_transform_worker_test_SRCS kis_perspective_transform_worker_test.cpp )
 #kde4_add_unit_test(KisPerspectiveTransformWorkerTest TESTNAME krita-image-KisPerspectiveTransformWorkerTest ${kis_perspective_transform_worker_test_SRCS})
 #target_link_libraries(KisPerspectiveTransformWorkerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_bsplines_test_SRCS kis_bsplines_test.cpp )
 kde4_add_unit_test(KisBSplinesTest TESTNAME krita-image-KisBSplinesTest ${kis_bsplines_test_SRCS})
 target_link_libraries(KisBSplinesTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_warp_transform_worker_test_SRCS  kis_warp_transform_worker_test.cpp)
 kde4_add_unit_test(KisWarpTransformWorkerTest TESTNAME krita-image-KisWarpTransformWorkerTest ${kis_warp_transform_worker_test_SRCS})
 target_link_libraries(KisWarpTransformWorkerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_cage_transform_worker_test_SRCS  kis_cage_transform_worker_test.cpp)
 kde4_add_broken_unit_test(KisCageTransformWorkerTest TESTNAME krita-image-KisCageTransformWorkerTest ${kis_cage_transform_worker_test_SRCS})
 target_link_libraries(KisCageTransformWorkerTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_liquify_transform_worker_test_SRCS  kis_liquify_transform_worker_test.cpp)
 kde4_add_unit_test(KisLiquifyTransformWorkerTest TESTNAME krita-image-KisLiquifyTransformWorkerTest ${kis_liquify_transform_worker_test_SRCS})
 target_link_libraries(KisLiquifyTransformWorkerTest   kritaimage Qt5::Test)
 
 
 ########### next target ###############
 
 set(kis_transparency_mask_test_SRCS kis_transparency_mask_test.cpp )
 kde4_add_unit_test(KisTransparencyMaskTest TESTNAME krita-image-KisTransparencyMaskTest ${kis_transparency_mask_test_SRCS})
 target_link_libraries(KisTransparencyMaskTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_types_test_SRCS kis_types_test.cpp )
 kde4_add_unit_test(KisTypesTest TESTNAME krita-image-KisTypesTest ${kis_types_test_SRCS})
 target_link_libraries(KisTypesTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_vec_test_SRCS kis_vec_test.cpp )
 kde4_add_unit_test(KisVecTest TESTNAME krita-image-KisVecTest ${kis_vec_test_SRCS})
 target_link_libraries(KisVecTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_filter_config_widget_test_SRCS kis_filter_config_widget_test.cpp )
 kde4_add_unit_test(KisFilterConfigWidgetTest TESTNAME krita-image-KisFilterConfigWidgetTest ${kis_filter_config_widget_test_SRCS})
 target_link_libraries(KisFilterConfigWidgetTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_meta_data_test_SRCS kis_meta_data_test.cpp )
 kde4_add_broken_unit_test(KisMetaDataTest TESTNAME krita-image-KisMetaDataTest ${kis_meta_data_test_SRCS})
 target_link_libraries(KisMetaDataTest  kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_random_generator_test_SRCS kis_random_generator_test.cpp )
 kde4_add_broken_unit_test(KisRandomGeneratorTest TESTNAME krita-image-KisRandomGeneratorTest ${kis_random_generator_test_SRCS})
 target_link_libraries(KisRandomGeneratorTest  kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_mask_generator_test_SRCS kis_mask_generator_test.cpp )
 kde4_add_unit_test(KisMaskGeneratorTest TESTNAME krita-image-KisMaskGeneratorTest ${kis_mask_generator_test_SRCS})
 target_link_libraries(KisMaskGeneratorTest  kritaimage Qt5::Test)
 
 ########### next target ###############
 
 #set(kis_cs_conversion_test_SRCS kis_cs_conversion_test.cpp )
 #kde4_add_unit_test(KisCsConversionTest TESTNAME krita-image-KisCsConversionTest ${kis_cs_conversion_test_SRCS})
 #target_link_libraries(KisCsConversionTest  kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_cubic_curve_test_SRCS kis_cubic_curve_test.cpp )
 kde4_add_unit_test(KisCubicCurveTest TESTNAME krita-image-KisCubicCurveTest ${kis_cubic_curve_test_SRCS})
 target_link_libraries(KisCubicCurveTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_query_path_test_SRCS kis_node_query_path_test.cpp )
 kde4_add_unit_test(KisNodeQueryPathTest TESTNAME krita-image-KisNodeQueryPathTest ${kis_node_query_path_test_SRCS})
 target_link_libraries(KisNodeQueryPathTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 # kisdoc
 #set(kis_processings_test_SRCS kis_processings_test.cpp )
 #kde4_add_unit_test(KisProcessingsTest TESTNAME krita-image-KisProcessingsTest ${kis_processings_test_SRCS})
 #target_link_libraries(KisProcessingsTest   kritaimage Qt5::Test)
 
 
 ########### next target ###############
 
 set(kis_fixed_point_maths_test_SRCS kis_fixed_point_maths_test.cpp )
 kde4_add_unit_test(KisFixedPointMathsTest TESTNAME krita-image-KisFixedPointMathsTest ${kis_fixed_point_maths_test_SRCS})
 target_link_libraries(KisFixedPointMathsTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_filter_weights_buffer_test_SRCS kis_filter_weights_buffer_test.cpp )
 kde4_add_unit_test(KisFilterWeightsBufferTest TESTNAME krita-image-KisFilterWeightsBufferTest ${kis_filter_weights_buffer_test_SRCS})
 target_link_libraries(KisFilterWeightsBufferTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_filter_weights_applicator_test_SRCS kis_filter_weights_applicator_test.cpp )
 kde4_add_unit_test(KisFilterWeightsApplicatorTest TESTNAME krita-image-KisFilterWeightsApplicatorTest ${kis_filter_weights_applicator_test_SRCS})
 target_link_libraries(KisFilterWeightsApplicatorTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_fill_interval_test_SRCS kis_fill_interval_test.cpp )
 kde4_add_unit_test(KisFillIntervalTest TESTNAME krita-image-FillInterval-Test ${kis_fill_interval_test_SRCS})
 target_link_libraries(KisFillIntervalTest   kritaimage Qt5::Test)
 
 
 ########### next target ###############
 
 set(kis_fill_interval_map_test_SRCS kis_fill_interval_map_test.cpp )
 kde4_add_unit_test(KisFillIntervalMapTest TESTNAME krita-image-FillIntervalMap-Test ${kis_fill_interval_map_test_SRCS})
 target_link_libraries(KisFillIntervalMapTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_scanline_fill_test_SRCS kis_scanline_fill_test.cpp )
 kde4_add_unit_test(KisScanlineFillTest TESTNAME krita-image-ScanlineFill-Test ${kis_scanline_fill_test_SRCS})
 target_link_libraries(KisScanlineFillTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_keyframing_test_SRCS kis_keyframing_test.cpp )
 kde4_add_broken_unit_test(KisKeyframingTest TESTNAME krita-image-Keyframing-Test ${kis_keyframing_test_SRCS})
-target_link_libraries(KisKeyframingTest  ${KDE4_KDEUI_LIBS} kritaimage ${QT_QTTEST_LIBRARY})
+target_link_libraries(KisKeyframingTest  kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_psd_layer_style_test_SRCS kis_psd_layer_style_test.cpp )
 kde4_add_unit_test(KisPSDLayerStyleTest TESTNAME krita-image-PSDLayerStyle-Test ${kis_psd_layer_style_test_SRCS})
 target_link_libraries(KisPSDLayerStyleTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_dom_utils_test_SRCS kis_dom_utils_test.cpp )
 kde4_add_unit_test(KisDomUtilsTest TESTNAME krita-image-DomUtils-Test ${kis_dom_utils_test_SRCS})
 target_link_libraries(KisDomUtilsTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_image_animation_interface_test_SRCS kis_image_animation_interface_test.cpp )
 kde4_add_broken_unit_test(KisImageAnimationInterfaceTest TESTNAME krita-image-ImageAnimationInterface-Test ${kis_image_animation_interface_test_SRCS})
 target_link_libraries(KisImageAnimationInterfaceTest  ${KDE4_KDEUI_LIBS} kritaimage ${QT_QTTEST_LIBRARY})
 ########### next target ###############
 
 set(kis_onion_skin_compositor_test_SRCS kis_onion_skin_compositor_test.cpp )
 kde4_add_broken_unit_test(KisOnionSkinCompositorTest TESTNAME krita-image-OnionSkinCompositor-Test ${kis_onion_skin_compositor_test_SRCS})
 target_link_libraries(KisOnionSkinCompositorTest  ${KDE4_KDEUI_LIBS} kritaimage ${QT_QTTEST_LIBRARY})
 
 ########### next target ###############
 
 set(kis_layer_styles_test_SRCS kis_layer_styles_test.cpp )
 kde4_add_broken_unit_test(KisLayerStylesTest TESTNAME krita-image-LayerStylesTest  ${kis_layer_styles_test_SRCS})
 target_link_libraries(KisLayerStylesTest    kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_layer_style_projection_plane_test_SRCS kis_layer_style_projection_plane_test.cpp )
 kde4_add_unit_test(KisLayerStyleProjectionPlaneTest TESTNAME kritaimage-layer_style_projection_plane_test ${kis_layer_style_projection_plane_test_SRCS})
 target_link_libraries(KisLayerStyleProjectionPlaneTest   kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_layer_style_filter_environment_test_SRCS kis_layer_style_filter_environment_test.cpp )
 kde4_add_unit_test(KisLayerStyleFilterEnvironmentTest TESTNAME kritaimage-layer_style_filter_environment_test ${kis_layer_style_filter_environment_test_SRCS})
 target_link_libraries(KisLayerStyleFilterEnvironmentTest  ${KDE4_KDEUI_LIBS} kritaimage ${QT_QTTEST_LIBRARY})
 
 
 ########### next target ###############
 
 set(kis_layer_style_filter_environment_test_SRCS kis_layer_style_filter_environment_test.cpp )
 kde4_add_unit_test(KisLayerStyleFilterEnvironmentTest TESTNAME kritaimage-layer_style_filter_environment_test ${kis_layer_style_filter_environment_test_SRCS})
 target_link_libraries(KisLayerStyleFilterEnvironmentTest  ${KDE4_KDEUI_LIBS} kritaimage ${QT_QTTEST_LIBRARY})
 
 
 ########### next target ###############
 # image/tests cannot use stuff that needs kisdocument
 #set(kis_projection_leaf_test_SRCS kis_projection_leaf_test.cpp )
 #kde4_add_unit_test(KisProjectionLeafTest TESTNAME kritaimage-projection_leaf_test ${kis_projection_leaf_test_SRCS})
 #target_link_libraries(KisProjectionLeafTest kritaimage ${QT_QTTEST_LIBRARY})
 
 ########### next target ###############
 
 set(kis_lod_capable_layer_offset_test_SRCS kis_lod_capable_layer_offset_test.cpp )
 kde4_add_unit_test(KisLodCapableLayerOffsetTest TESTNAME kritaimage-lod_capable_layer_offset_test ${kis_lod_capable_layer_offset_test_SRCS})
 target_link_libraries(KisLodCapableLayerOffsetTest kritaimage ${QT_QTTEST_LIBRARY})
 
 ########### next target ###############
 
 set(kis_asl_parser_test_SRCS kis_asl_parser_test.cpp )
 kde4_add_unit_test(KisAslParserTest TESTNAME kritalibpsd-asl_parser_test ${kis_asl_parser_test_SRCS})
 target_link_libraries(KisAslParserTest kritapsd kritapigment kritawidgetutils  ${QT_QTXML_LIBRARY} Qt5::Test)
 
diff --git a/libs/image/tests/kis_keyframing_test.cpp b/libs/image/tests/kis_keyframing_test.cpp
index 42b365a430..a35b359cb0 100644
--- a/libs/image/tests/kis_keyframing_test.cpp
+++ b/libs/image/tests/kis_keyframing_test.cpp
@@ -1,440 +1,442 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_keyframing_test.h"
 #include <QTest>
 #include <qsignalspy.h>
 
 #include "kis_paint_device_frames_interface.h"
 #include "kis_keyframe_channel.h"
 #include "kis_scalar_keyframe_channel.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_node.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 
 
 #include <KoColorSpaceRegistry.h>
 
 #include "testing_timed_default_bounds.h"
 
 
 void KisKeyframingTest::initTestCase()
 {
     cs = KoColorSpaceRegistry::instance()->rgb8();
 
     red = new quint8[cs->pixelSize()];
     green = new quint8[cs->pixelSize()];
     blue = new quint8[cs->pixelSize()];
 
     cs->fromQColor(Qt::red, red);
     cs->fromQColor(Qt::green, green);
     cs->fromQColor(Qt::blue, blue);
 }
 
 void KisKeyframingTest::cleanupTestCase()
 {
     delete[] red;
     delete[] green;
     delete[] blue;
 }
 
 void KisKeyframingTest::testScalarChannel()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID("", ""), 0, -17, 31, 0);
     KisKeyframeSP key;
     bool ok;
 
     QCOMPARE(channel->hasScalarValue(), true);
     QCOMPARE(channel->minScalarValue(), -17.0);
     QCOMPARE(channel->maxScalarValue(),  31.0);
 
     QVERIFY(channel->keyframeAt(0) == 0);
 
     // Adding new keyframe
 
     key = channel->addKeyframe(42);
     channel->setScalarValue(key, 7.0);
 
     key = channel->keyframeAt(42);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
-    // Adding a keyframe where one exists
-
-    KisKeyframeSP key2 = channel->addKeyframe(42);
-    QVERIFY(key2 == key);
-
     // Copying a keyframe
 
-    key2 = channel->copyKeyframe(key, 13);
+    KisKeyframeSP key2 = channel->copyKeyframe(key, 13);
     QVERIFY(key2 != 0);
     QVERIFY(channel->keyframeAt(13) == key2);
     QCOMPARE(channel->scalarValue(key2), 7.0);
 
+    // Adding a keyframe where one exists
+
+    key2 = channel->addKeyframe(13);
+    QVERIFY(key2 != key);
+    QCOMPARE(channel->keyframeCount(), 2);
+
     // Moving keyframes
 
     ok = channel->moveKeyframe(key, 10);
     QCOMPARE(ok, true);
     QVERIFY(channel->keyframeAt(42) == 0);
 
     key = channel->keyframeAt(10);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
     // Moving a keyframe where another one exists
     ok = channel->moveKeyframe(key, 13);
-    QCOMPARE(ok, false);
-    QVERIFY(channel->keyframeAt(13) == key2);
+    QCOMPARE(ok, true);
+    QVERIFY(channel->keyframeAt(13) != key2);
 
+    // Deleting a keyframe
     channel->deleteKeyframe(key);
-
     QVERIFY(channel->keyframeAt(10) == 0);
+    QCOMPARE(channel->keyframeCount(), 0);
 
     delete channel;
 }
 
 void KisKeyframingTest::testScalarChannelUndoRedo()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID("", ""), 0, -17, 31, 0);
     KisKeyframeSP key;
 
     QCOMPARE(channel->hasScalarValue(), true);
     QCOMPARE(channel->minScalarValue(), -17.0);
     QCOMPARE(channel->maxScalarValue(),  31.0);
 
     QVERIFY(channel->keyframeAt(0) == 0);
 
     // Adding new keyframe
 
     KUndo2Command addCmd;
 
     key = channel->addKeyframe(42, &addCmd);
     channel->setScalarValue(key, 7.0, &addCmd);
 
     key = channel->keyframeAt(42);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
     addCmd.undo();
 
     KisKeyframeSP newKey;
 
     newKey = channel->keyframeAt(42);
     QVERIFY(!newKey);
 
     addCmd.redo();
 
     newKey = channel->keyframeAt(42);
     QVERIFY(newKey);
 
     QCOMPARE(channel->scalarValue(key), 7.0);
     QCOMPARE(channel->scalarValue(newKey), 7.0);
 
     delete channel;
 }
 
 void KisKeyframingTest::testRasterChannel()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID(), 0);
 
     QCOMPARE(channel->hasScalarValue(), false);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QCOMPARE(channel->frameIdAt(0), 0);
     QVERIFY(channel->keyframeAt(0) != 0);
 
     KisKeyframeSP key_0 = channel->keyframeAt(0);
 
     // New keyframe
 
     KisKeyframeSP key_10 = channel->addKeyframe(10);
     QCOMPARE(channel->keyframeCount(), 2);
     QCOMPARE(dev->framesInterface()->frames().count(), 2);
     QVERIFY(channel->frameIdAt(10) != 0);
 
     dev->fill(0, 0, 512, 512, red);
     QImage thumb1a = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
 
     dev->fill(0, 0, 512, 512, green);
     QImage thumb2a = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(0);
     QImage thumb1b = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb2a != thumb1a);
     QVERIFY(thumb1b == thumb1a);
 
     // Duplicate keyframe
 
     KisKeyframeSP key_20 = channel->copyKeyframe(key_0, 20);
     bounds->testingSetTime(20);
     QImage thumb3a = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb3a == thumb1b);
 
     dev->fill(0, 0, 512, 512, blue);
     QImage thumb3b = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(0);
     QImage thumb1c = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb3b != thumb3a);
     QVERIFY(thumb1c == thumb1b);
 
     // Delete keyrame
     QCOMPARE(channel->keyframeCount(), 3);
     QCOMPARE(dev->framesInterface()->frames().count(), 3);
 
     channel->deleteKeyframe(key_0);
     QCOMPARE(channel->keyframeCount(), 2);
     QCOMPARE(dev->framesInterface()->frames().count(), 2);
     QVERIFY(channel->keyframeAt(0) == 0);
 
     channel->deleteKeyframe(key_20);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QVERIFY(channel->keyframeAt(20) == 0);
 
     // Last remaining keyframe cannot be deleted
     channel->deleteKeyframe(key_10);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QVERIFY(channel->keyframeAt(10) != 0);
 
     // Fetching current keyframe before the first one should
     // return the first keyframe
     QCOMPARE(channel->frameIdAt(0), (int)key_10->value());
 }
 
 void KisKeyframingTest::testChannelSignals()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID("", ""), 0, -17, 31, 0);
     KisKeyframeSP key;
     KisKeyframe *resKey;
 
     qRegisterMetaType<KisKeyframe*>("KisKeyframePtr");
     QSignalSpy spyPreAdd(channel, SIGNAL(sigKeyframeAboutToBeAdded(KisKeyframe*)));
     QSignalSpy spyPostAdd(channel, SIGNAL(sigKeyframeAdded(KisKeyframe*)));
 
     QSignalSpy spyPreRemove(channel, SIGNAL(sigKeyframeAboutToBeRemoved(KisKeyframe*)));
     QSignalSpy spyPostRemove(channel, SIGNAL(sigKeyframeRemoved(KisKeyframe*)));
 
     QSignalSpy spyPreMove(channel, SIGNAL(sigKeyframeAboutToBeMoved(KisKeyframe*,int)));
     QSignalSpy spyPostMove(channel, SIGNAL(sigKeyframeMoved(KisKeyframe*, int)));
 
     QVERIFY(spyPreAdd.isValid());
     QVERIFY(spyPostAdd.isValid());
     QVERIFY(spyPreRemove.isValid());
     QVERIFY(spyPostRemove.isValid());
     QVERIFY(spyPreMove.isValid());
     QVERIFY(spyPostMove.isValid());
 
     // Adding a keyframe
 
     QCOMPARE(spyPreAdd.count(), 0);
     QCOMPARE(spyPostAdd.count(), 0);
 
     key = channel->addKeyframe(10);
 
     QCOMPARE(spyPreAdd.count(), 1);
     QCOMPARE(spyPostAdd.count(), 1);
 
     resKey = spyPreAdd.at(0).at(0).value<KisKeyframe*>();
     QVERIFY(resKey == key.data());
     resKey = spyPostAdd.at(0).at(0).value<KisKeyframe*>();
     QVERIFY(resKey == key.data());
 
     // Moving a keyframe
 
     QCOMPARE(spyPreMove.count(), 0);
     QCOMPARE(spyPostMove.count(), 0);
     channel->moveKeyframe(key, 15);
     QCOMPARE(spyPreMove.count(), 1);
     QCOMPARE(spyPostMove.count(), 1);
 
     resKey = spyPreMove.at(0).at(0).value<KisKeyframe*>();
     QVERIFY(resKey == key.data());
     QCOMPARE(spyPreMove.at(0).at(1).toInt(), 15);
     resKey = spyPostMove.at(0).at(0).value<KisKeyframe*>();
     QVERIFY(resKey == key.data());
 
     // No-op move (no signals)
 
     channel->moveKeyframe(key, 15);
     QCOMPARE(spyPreMove.count(), 1);
     QCOMPARE(spyPostMove.count(), 1);
 
     // Deleting a keyframe
 
     QCOMPARE(spyPreRemove.count(), 0);
     QCOMPARE(spyPostRemove.count(), 0);
     channel->deleteKeyframe(key);
     QCOMPARE(spyPreRemove.count(), 1);
     QCOMPARE(spyPostRemove.count(), 1);
 
     delete channel;
 }
 
 void KisKeyframingTest::testRasterFrameFetching()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     KisPaintDeviceSP devTarget = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID(), 0);
 
     channel->addKeyframe(0);
     channel->addKeyframe(10);
     channel->addKeyframe(50);
 
     bounds->testingSetTime(0);
     dev->fill(0, 0, 512, 512, red);
     QImage frame1 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
     dev->fill(0, 256, 512, 512, green);
     QImage frame2 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(50);
     dev->fill(0, 0, 256, 512, blue);
     QImage frame3 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
 
     KisKeyframeSP keyframe = channel->activeKeyframeAt(0);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched1 = devTarget->createThumbnail(50, 50);
 
     keyframe = channel->activeKeyframeAt(10);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched2 = devTarget->createThumbnail(50, 50);
 
     keyframe = channel->activeKeyframeAt(50);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched3 = devTarget->createThumbnail(50, 50);
 
     QVERIFY(fetched1 == frame1);
     QVERIFY(fetched2 == frame2);
     QVERIFY(fetched3 == frame3);
 }
 
 void KisKeyframingTest::testDeleteFirstRasterChannel()
 {
     // Test Plan:
     // 
     // delete
     // undo delete
     // move
     // undo move
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID(), 0);
 
     QCOMPARE(channel->hasScalarValue(), false);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QCOMPARE(channel->frameIdAt(0), 0);
     QVERIFY(channel->keyframeAt(0) != 0);
 
     KisKeyframeSP key_0 = channel->keyframeAt(0);
 
     {
         KUndo2Command cmd;
         bool deleteResult = channel->deleteKeyframe(key_0, &cmd);
         QVERIFY(deleteResult);
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) != 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) != key_0);
 
         cmd.undo();
 
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) == key_0);
     }
 
     {
         KUndo2Command cmd;
         bool moveResult = channel->moveKeyframe(key_0, 1, &cmd);
         QVERIFY(moveResult);
         QCOMPARE(dev->framesInterface()->frames().count(), 2);
         QVERIFY(channel->frameIdAt(0) != 0);
         QVERIFY(channel->frameIdAt(1) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(1));
         QVERIFY(channel->keyframeAt(0) != key_0);
         QVERIFY(channel->keyframeAt(1) == key_0);
 
         cmd.undo();
 
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) == key_0);
     }
 }
 
 void KisKeyframingTest::testAffectedFrames()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID("", ""), 0, -17, 31, 0);
     KisTimeRange range;
 
     channel->addKeyframe(10);
     channel->addKeyframe(20);
     channel->addKeyframe(30);
 
     // At a keyframe
     range = channel->affectedFrames(20);
     QCOMPARE(range.start(), 20);
     QCOMPARE(range.end(), 29);
     QCOMPARE(range.isInfinite(), false);
 
     // Between frames
     range = channel->affectedFrames(25);
     QCOMPARE(range.start(), 20);
     QCOMPARE(range.end(), 29);
     QCOMPARE(range.isInfinite(), false);
 
     // Before first frame
     range = channel->affectedFrames(5);
     QCOMPARE(range.start(), 0);
     QCOMPARE(range.end(), 19);
     QCOMPARE(range.isInfinite(), false);
 
     // After last frame
     range = channel->affectedFrames(35);
     QCOMPARE(range.start(), 30);
     QCOMPARE(range.isInfinite(), true);
 
 }
 
 QTEST_MAIN(KisKeyframingTest)
 #include "kis_keyframing_test.moc"