diff --git a/benchmarks/kis_composition_benchmark.cpp b/benchmarks/kis_composition_benchmark.cpp
index efb4f1e9e7..4065a1adfb 100644
--- a/benchmarks/kis_composition_benchmark.cpp
+++ b/benchmarks/kis_composition_benchmark.cpp
@@ -1,951 +1,949 @@
 /*
  *  Copyright (c) 2012 Dmitry Kazakov <dimula73@gmail.com>
  *  Copyright (c) 2015 Thorsten Zachmann <zachmann@kde.org>
  *
  *  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.
  */
 
 // for calculation of the needed alignment
 #include <config-vc.h>
 #ifdef HAVE_VC
 #if defined _MSC_VER
 // Lets shut up the "possible loss of data" and "forcing value to bool 'true' or 'false'
 #pragma warning ( push )
 #pragma warning ( disable : 4244 )
 #pragma warning ( disable : 4800 )
 #endif
 #include <Vc/Vc>
 #include <Vc/IO>
 #if defined _MSC_VER
 #pragma warning ( pop )
 #endif
 
 #include <KoOptimizedCompositeOpOver32.h>
 #include <KoOptimizedCompositeOpOver128.h>
 #include <KoOptimizedCompositeOpAlphaDarken32.h>
 #endif
 
 #include "kis_composition_benchmark.h"
 #include <QTest>
 
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <KoColorSpaceTraits.h>
 #include <KoCompositeOpAlphaDarken.h>
 #include <KoCompositeOpOver.h>
 #include <KoOptimizedCompositeOpFactory.h>
 #include <KoAlphaDarkenParamsWrapper.h>
 
 // for posix_memalign()
 #include <stdlib.h>
 
 #include <kis_debug.h>
 
 #if defined _MSC_VER
 #define MEMALIGN_ALLOC(p, a, s) ((*(p)) = _aligned_malloc((s), (a)), *(p) ? 0 : errno)
 #define MEMALIGN_FREE(p) _aligned_free((p))
 #else
 #define MEMALIGN_ALLOC(p, a, s) posix_memalign((p), (a), (s))
 #define MEMALIGN_FREE(p) free((p))
 #endif
 
-const int alpha_pos = 3;
-
 enum AlphaRange {
     ALPHA_ZERO,
     ALPHA_UNIT,
     ALPHA_RANDOM
 };
 
 
 template <typename channel_type, class RandomGenerator>
 inline channel_type generateAlphaValue(AlphaRange range, RandomGenerator &rnd) {
     channel_type value = 0;
 
     switch (range) {
     case ALPHA_ZERO:
         break;
     case ALPHA_UNIT:
         value = rnd.unit();
         break;
     case ALPHA_RANDOM:
         value = rnd();
         break;
     }
 
     return value;
 }
 
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/uniform_smallint.hpp>
 #include <boost/random/uniform_real.hpp>
 
 template <typename channel_type>
 struct RandomGenerator {
     channel_type operator() () {
         qFatal("Wrong template instantiation");
         return channel_type(0);
     }
 
     channel_type unit() {
         qFatal("Wrong template instantiation");
         return channel_type(0);
     }
 };
 
 template <>
 struct RandomGenerator<quint8>
 {
     RandomGenerator(int seed)
         : m_smallint(0,255),
           m_rnd(seed)
     {
     }
 
     quint8 operator() () {
         return m_smallint(m_rnd);
     }
 
     quint8 unit() {
         return KoColorSpaceMathsTraits<quint8>::unitValue;
     }
 
     boost::uniform_smallint<int> m_smallint;
     boost::mt11213b m_rnd;
 };
 
 template <>
 struct RandomGenerator<float>
 {
     RandomGenerator(int seed)
         : m_rnd(seed)
     {
     }
 
     float operator() () {
         //return float(m_rnd()) / float(m_rnd.max());
         return m_smallfloat(m_rnd);
     }
 
     float unit() {
         return KoColorSpaceMathsTraits<float>::unitValue;
     }
 
     boost::uniform_real<float> m_smallfloat;
     boost::mt11213b m_rnd;
 };
 
 template <>
 struct RandomGenerator<double> : RandomGenerator<float>
 {
     RandomGenerator(int seed)
         : RandomGenerator<float>(seed)
     {
     }
 };
 
 
 template <typename channel_type>
 void generateDataLine(uint seed, int numPixels, quint8 *srcPixels, quint8 *dstPixels, quint8 *mask, AlphaRange srcAlphaRange, AlphaRange dstAlphaRange)
 {
     Q_ASSERT(numPixels >= 4);
 
     RandomGenerator<channel_type> rnd(seed);
     RandomGenerator<quint8> maskRnd(seed + 1);
 
     channel_type *srcArray = reinterpret_cast<channel_type*>(srcPixels);
     channel_type *dstArray = reinterpret_cast<channel_type*>(dstPixels);
 
     for (int i = 0; i < numPixels; i++) {
         for (int j = 0; j < 3; j++) {
             channel_type s = rnd();
             channel_type d = rnd();
             *(srcArray++) = s;
             *(dstArray++) = d;
         }
 
         channel_type sa = generateAlphaValue<channel_type>(srcAlphaRange, rnd);
         channel_type da = generateAlphaValue<channel_type>(dstAlphaRange, rnd);
         *(srcArray++) = sa;
         *(dstArray++) = da;
 
         *(mask++) = maskRnd();
     }
 }
 
 void printData(int numPixels, quint8 *srcPixels, quint8 *dstPixels, quint8 *mask)
 {
     for (int i = 0; i < numPixels; i++) {
         qDebug() << "Src: "
                  << srcPixels[i*4] << "\t"
                  << srcPixels[i*4+1] << "\t"
                  << srcPixels[i*4+2] << "\t"
                  << srcPixels[i*4+3] << "\t"
                  << "Msk:" << mask[i];
 
         qDebug() << "Dst: "
                  << dstPixels[i*4] << "\t"
                  << dstPixels[i*4+1] << "\t"
                  << dstPixels[i*4+2] << "\t"
                  << dstPixels[i*4+3];
     }
 }
 
 const int rowStride = 64;
 const int totalRows = 64;
 const QRect processRect(0,0,64,64);
 const int numPixels = rowStride * totalRows;
 const int numTiles = 1024;
 
 
 struct Tile {
     quint8 *src;
     quint8 *dst;
     quint8 *mask;
 };
 #include <stdint.h>
 QVector<Tile> generateTiles(int size,
                             const int srcAlignmentShift,
                             const int dstAlignmentShift,
                             AlphaRange srcAlphaRange,
                             AlphaRange dstAlphaRange,
                             const quint32 pixelSize)
 {
     QVector<Tile> tiles(size);
 
 #ifdef HAVE_VC
     const int vecSize = Vc::float_v::size();
 #else
     const int vecSize = 1;
 #endif
 
     // the 256 are used to make sure that we have a good alignment no matter what build options are used.
     const size_t pixelAlignment = qMax(size_t(vecSize * sizeof(float)), size_t(256));
     const size_t maskAlignment = qMax(size_t(vecSize), size_t(256));
     for (int i = 0; i < size; i++) {
         void *ptr = 0;
         int error = MEMALIGN_ALLOC(&ptr, pixelAlignment, numPixels * pixelSize + srcAlignmentShift);
         if (error) {
             qFatal("posix_memalign failed: %d", error);
         }
         tiles[i].src = (quint8*)ptr + srcAlignmentShift;
         error = MEMALIGN_ALLOC(&ptr, pixelAlignment, numPixels * pixelSize + dstAlignmentShift);
         if (error) {
             qFatal("posix_memalign failed: %d", error);
         }
         tiles[i].dst = (quint8*)ptr + dstAlignmentShift;
         error = MEMALIGN_ALLOC(&ptr, maskAlignment, numPixels);
         if (error) {
             qFatal("posix_memalign failed: %d", error);
         }
         tiles[i].mask = (quint8*)ptr;
 
         if (pixelSize == 4) {
             generateDataLine<quint8>(1, numPixels, tiles[i].src, tiles[i].dst, tiles[i].mask, srcAlphaRange, dstAlphaRange);
         } else if (pixelSize == 16) {
             generateDataLine<float>(1, numPixels, tiles[i].src, tiles[i].dst, tiles[i].mask, srcAlphaRange, dstAlphaRange);
         } else {
             qFatal("Pixel size %i is not implemented", pixelSize);
         }
     }
 
     return tiles;
 }
 
 void freeTiles(QVector<Tile> tiles,
                const int srcAlignmentShift,
                const int dstAlignmentShift)
 {
     Q_FOREACH (const Tile &tile, tiles) {
         MEMALIGN_FREE(tile.src - srcAlignmentShift);
         MEMALIGN_FREE(tile.dst - dstAlignmentShift);
         MEMALIGN_FREE(tile.mask);
     }
 }
 
 template <typename channel_type>
 inline bool fuzzyCompare(channel_type a, channel_type b, channel_type prec) {
     return qAbs(a - b) <= prec;
 }
 
 template <typename channel_type>
 inline bool comparePixels(channel_type *p1, channel_type *p2, channel_type prec) {
     return (p1[3] == p2[3] && p1[3] == 0) ||
         (fuzzyCompare(p1[0], p2[0], prec) &&
          fuzzyCompare(p1[1], p2[1], prec) &&
          fuzzyCompare(p1[2], p2[2], prec) &&
          fuzzyCompare(p1[3], p2[3], prec));
 }
 
 template <typename channel_type>
 bool compareTwoOpsPixels(QVector<Tile> &tiles, channel_type prec) {
     channel_type *dst1 = reinterpret_cast<channel_type*>(tiles[0].dst);
     channel_type *dst2 = reinterpret_cast<channel_type*>(tiles[1].dst);
 
     channel_type *src1 = reinterpret_cast<channel_type*>(tiles[0].src);
     channel_type *src2 = reinterpret_cast<channel_type*>(tiles[1].src);
 
     for (int i = 0; i < numPixels; i++) {
         if (!comparePixels<channel_type>(dst1, dst2, prec)) {
             qDebug() << "Wrong result:" << i;
             qDebug() << "Act: " << dst1[0] << dst1[1] << dst1[2] << dst1[3];
             qDebug() << "Exp: " << dst2[0] << dst2[1] << dst2[2] << dst2[3];
             qDebug() << "Dif: " << dst1[0] - dst2[0] << dst1[1] - dst2[1] << dst1[2] - dst2[2] << dst1[3] - dst2[3];
 
             channel_type *s1 = src1 + 4 * i;
             channel_type *s2 = src2 + 4 * i;
 
             qDebug() << "SrcA:" << s1[0] << s1[1] << s1[2] << s1[3];
             qDebug() << "SrcE:" << s2[0] << s2[1] << s2[2] << s2[3];
 
             qDebug() << "MskA:" << tiles[0].mask[i];
             qDebug() << "MskE:" << tiles[1].mask[i];
 
             return false;
         }
         dst1 += 4;
         dst2 += 4;
     }
     return true;
 }
 
 bool compareTwoOps(bool haveMask, const KoCompositeOp *op1, const KoCompositeOp *op2)
 {
     Q_ASSERT(op1->colorSpace()->pixelSize() == op2->colorSpace()->pixelSize());
     const quint32 pixelSize = op1->colorSpace()->pixelSize();
     const int alignment = 16;
     QVector<Tile> tiles = generateTiles(2, alignment, alignment, ALPHA_RANDOM, ALPHA_RANDOM, op1->colorSpace()->pixelSize());
 
     KoCompositeOp::ParameterInfo params;
     params.dstRowStride  = 4 * rowStride;
     params.srcRowStride  = 4 * rowStride;
     params.maskRowStride = rowStride;
     params.rows          = processRect.height();
     params.cols          = processRect.width();
     // This is a hack as in the old version we get a rounding of opacity to this value
     params.opacity       = float(Arithmetic::scale<quint8>(0.5*1.0f))/255.0;
     params.flow          = 0.3*1.0f;
     params.channelFlags  = QBitArray();
 
     params.dstRowStart   = tiles[0].dst;
     params.srcRowStart   = tiles[0].src;
     params.maskRowStart  = haveMask ? tiles[0].mask : 0;
     op1->composite(params);
 
     params.dstRowStart   = tiles[1].dst;
     params.srcRowStart   = tiles[1].src;
     params.maskRowStart  = haveMask ? tiles[1].mask : 0;
     op2->composite(params);
 
     bool compareResult = true;
     if (pixelSize == 4) {
         compareResult = compareTwoOpsPixels<quint8>(tiles, 10);
     }
     else if (pixelSize == 16) {
         compareResult = compareTwoOpsPixels<float>(tiles, 2e-7);
     }
     else {
         qFatal("Pixel size %i is not implemented", pixelSize);
     }
 
     freeTiles(tiles, alignment, alignment);
 
     return compareResult;
 }
 
 QString getTestName(bool haveMask,
                     const int srcAlignmentShift,
                     const int dstAlignmentShift,
                     AlphaRange srcAlphaRange,
                     AlphaRange dstAlphaRange)
 {
 
     QString testName;
     testName +=
         !srcAlignmentShift && !dstAlignmentShift ? "Aligned   " :
         !srcAlignmentShift &&  dstAlignmentShift ? "SrcUnalig " :
          srcAlignmentShift && !dstAlignmentShift ? "DstUnalig " :
          srcAlignmentShift &&  dstAlignmentShift ? "Unaligned " : "###";
 
     testName += haveMask ? "Mask   " : "NoMask ";
 
     testName +=
         srcAlphaRange == ALPHA_RANDOM ? "SrcRand " :
         srcAlphaRange == ALPHA_ZERO   ? "SrcZero " :
         srcAlphaRange == ALPHA_UNIT   ? "SrcUnit " : "###";
 
     testName +=
         dstAlphaRange == ALPHA_RANDOM ? "DstRand" :
         dstAlphaRange == ALPHA_ZERO   ? "DstZero" :
         dstAlphaRange == ALPHA_UNIT   ? "DstUnit" : "###";
 
     return testName;
 }
 
 void benchmarkCompositeOp(const KoCompositeOp *op,
                           bool haveMask,
                           qreal opacity,
                           qreal flow,
                           const int srcAlignmentShift,
                           const int dstAlignmentShift,
                           AlphaRange srcAlphaRange,
                           AlphaRange dstAlphaRange)
 {
     QString testName = getTestName(haveMask, srcAlignmentShift, dstAlignmentShift, srcAlphaRange, dstAlphaRange);
 
     QVector<Tile> tiles =
         generateTiles(numTiles, srcAlignmentShift, dstAlignmentShift, srcAlphaRange, dstAlphaRange, op->colorSpace()->pixelSize());
 
     const int tileOffset = 4 * (processRect.y() * rowStride + processRect.x());
 
     KoCompositeOp::ParameterInfo params;
     params.dstRowStride  = 4 * rowStride;
     params.srcRowStride  = 4 * rowStride;
     params.maskRowStride = rowStride;
     params.rows          = processRect.height();
     params.cols          = processRect.width();
     params.opacity       = opacity;
     params.flow          = flow;
     params.channelFlags  = QBitArray();
 
     QTime timer;
     timer.start();
 
     Q_FOREACH (const Tile &tile, tiles) {
         params.dstRowStart   = tile.dst + tileOffset;
         params.srcRowStart   = tile.src + tileOffset;
         params.maskRowStart  = haveMask ? tile.mask : 0;
         op->composite(params);
     }
 
     qDebug() << testName << "RESULT:" << timer.elapsed() << "msec";
 
     freeTiles(tiles, srcAlignmentShift, dstAlignmentShift);
 }
 
 void benchmarkCompositeOp(const KoCompositeOp *op, const QString &postfix)
 {
     qDebug() << "Testing Composite Op:" << op->id() << "(" << postfix << ")";
 
     benchmarkCompositeOp(op, true, 0.5, 0.3, 0, 0, ALPHA_RANDOM, ALPHA_RANDOM);
     benchmarkCompositeOp(op, true, 0.5, 0.3, 8, 0, ALPHA_RANDOM, ALPHA_RANDOM);
     benchmarkCompositeOp(op, true, 0.5, 0.3, 0, 8, ALPHA_RANDOM, ALPHA_RANDOM);
     benchmarkCompositeOp(op, true, 0.5, 0.3, 4, 8, ALPHA_RANDOM, ALPHA_RANDOM);
 
 /// --- Vary the content of the source and destination
 
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_RANDOM, ALPHA_RANDOM);
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_ZERO, ALPHA_RANDOM);
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_UNIT, ALPHA_RANDOM);
 
 /// ---
 
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_RANDOM, ALPHA_ZERO);
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_ZERO, ALPHA_ZERO);
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_UNIT, ALPHA_ZERO);
 
 /// ---
 
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_RANDOM, ALPHA_UNIT);
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_ZERO, ALPHA_UNIT);
     benchmarkCompositeOp(op, false, 1.0, 1.0, 0, 0, ALPHA_UNIT, ALPHA_UNIT);
 }
 
 #ifdef HAVE_VC
 
 template<class Compositor>
 void checkRounding(qreal opacity, qreal flow, qreal averageOpacity = -1, quint32 pixelSize = 4)
 {
     QVector<Tile> tiles =
         generateTiles(2, 0, 0, ALPHA_RANDOM, ALPHA_RANDOM, pixelSize);
 
     const int vecSize = Vc::float_v::size();
 
     const int numBlocks = numPixels / vecSize;
 
     quint8 *src1 = tiles[0].src;
     quint8 *dst1 = tiles[0].dst;
     quint8 *msk1 = tiles[0].mask;
 
     quint8 *src2 = tiles[1].src;
     quint8 *dst2 = tiles[1].dst;
     quint8 *msk2 = tiles[1].mask;
 
     KoCompositeOp::ParameterInfo params;
     params.opacity = opacity;
     params.flow = flow;
 
     if (averageOpacity >= 0.0) {
         params._lastOpacityData = averageOpacity;
         params.lastOpacity = &params._lastOpacityData;
     }
 
     params.channelFlags = QBitArray();
     typename Compositor::ParamsWrapper paramsWrapper(params);
 
     // The error count is needed as 38.5 gets rounded to 38 instead of 39 in the vc version.
     int errorcount = 0;
     for (int i = 0; i < numBlocks; i++) {
         Compositor::template compositeVector<true,true, Vc::CurrentImplementation::current()>(src1, dst1, msk1, params.opacity, paramsWrapper);
         for (int j = 0; j < vecSize; j++) {
 
             //if (8 * i + j == 7080) {
             //    qDebug() << "src: " << src2[0] << src2[1] << src2[2] << src2[3];
             //    qDebug() << "dst: " << dst2[0] << dst2[1] << dst2[2] << dst2[3];
             //    qDebug() << "msk:" << msk2[0];
             //}
 
             Compositor::template compositeOnePixelScalar<true, Vc::CurrentImplementation::current()>(src2, dst2, msk2, params.opacity, paramsWrapper);
 
             bool compareResult = true;
             if (pixelSize == 4) {
                 compareResult = comparePixels<quint8>(dst1, dst2, 0);
                 if (!compareResult) {
                     ++errorcount;
                     compareResult = comparePixels<quint8>(dst1, dst2, 1);
                     if (!compareResult) {
                         ++errorcount;
                     }
                 }
             }
             else if (pixelSize == 16) {
                 compareResult = comparePixels<float>(reinterpret_cast<float*>(dst1), reinterpret_cast<float*>(dst2), 0);
             }
             else {
                 qFatal("Pixel size %i is not implemented", pixelSize);
             }
 
             if(!compareResult || errorcount > 1) {
                 qDebug() << "Wrong rounding in pixel:" << 8 * i + j;
                 qDebug() << "Vector version: " << dst1[0] << dst1[1] << dst1[2] << dst1[3];
                 qDebug() << "Scalar version: " << dst2[0] << dst2[1] << dst2[2] << dst2[3];
 
                 qDebug() << "src:" << src1[0] << src1[1] << src1[2] << src1[3];
                 qDebug() << "msk:" << msk1[0];
 
                 QFAIL("Wrong rounding");
             }
 
             src1 += pixelSize;
             dst1 += pixelSize;
             src2 += pixelSize;
             dst2 += pixelSize;
             msk1++;
             msk2++;
         }
     }
 
     freeTiles(tiles, 0, 0);
 }
 
 #endif
 
 
 void KisCompositionBenchmark::checkRoundingAlphaDarken_05_03()
 {
 #ifdef HAVE_VC
     checkRounding<AlphaDarkenCompositor32<quint8, quint32, KoAlphaDarkenParamsWrapperCreamy> >(0.5,0.3);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarken_05_05()
 {
 #ifdef HAVE_VC
     checkRounding<AlphaDarkenCompositor32<quint8, quint32, KoAlphaDarkenParamsWrapperCreamy> >(0.5,0.5);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarken_05_07()
 {
 #ifdef HAVE_VC
     checkRounding<AlphaDarkenCompositor32<quint8, quint32, KoAlphaDarkenParamsWrapperCreamy> >(0.5,0.7);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarken_05_10()
 {
 #ifdef HAVE_VC
     checkRounding<AlphaDarkenCompositor32<quint8, quint32, KoAlphaDarkenParamsWrapperCreamy> >(0.5,1.0);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarken_05_10_08()
 {
 #ifdef HAVE_VC
     checkRounding<AlphaDarkenCompositor32<quint8, quint32, KoAlphaDarkenParamsWrapperCreamy> >(0.5,1.0,0.8);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarkenF32_05_03()
 {
 #ifdef HAVE_VC
     checkRounding<OverCompositor128<float, float, false, true> >(0.5, 0.3, -1, 16);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarkenF32_05_05()
 {
 #ifdef HAVE_VC
     checkRounding<OverCompositor128<float, float, false, true> >(0.5, 0.5, -1, 16);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarkenF32_05_07()
 {
 #ifdef HAVE_VC
     checkRounding<OverCompositor128<float, float, false, true> >(0.5, 0.7, -1, 16);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarkenF32_05_10()
 {
 #ifdef HAVE_VC
     checkRounding<OverCompositor128<float, float, false, true> >(0.5, 1.0, -1, 16);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingAlphaDarkenF32_05_10_08()
 {
 #ifdef HAVE_VC
     checkRounding<OverCompositor128<float, float, false, true> >(0.5, 1.0, 0.8, 16);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingOver()
 {
 #ifdef HAVE_VC
     checkRounding<OverCompositor32<quint8, quint32, false, true> >(0.5, 0.3);
 #endif
 }
 
 void KisCompositionBenchmark::checkRoundingOverRgbaF32()
 {
 #ifdef HAVE_VC
     checkRounding<OverCompositor128<float, float, false, true> >(0.5, 0.3, -1, 16);
 #endif
 }
 
 void KisCompositionBenchmark::compareAlphaDarkenOps()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoCompositeOp *opAct = KoOptimizedCompositeOpFactory::createAlphaDarkenOpCreamy32(cs);
     KoCompositeOp *opExp = new KoCompositeOpAlphaDarken<KoBgrU8Traits, KoAlphaDarkenParamsWrapperCreamy>(cs);
 
     QVERIFY(compareTwoOps(true, opAct, opExp));
 
     delete opExp;
     delete opAct;
 }
 
 void KisCompositionBenchmark::compareRgbF32AlphaDarkenOps()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F32", "");
     KoCompositeOp *opAct = KoOptimizedCompositeOpFactory::createAlphaDarkenOpCreamy128(cs);
     KoCompositeOp *opExp = new KoCompositeOpAlphaDarken<KoRgbF32Traits, KoAlphaDarkenParamsWrapperCreamy>(cs);
 
     QVERIFY(compareTwoOps(true, opAct, opExp));
 
     delete opExp;
     delete opAct;
 }
 
 void KisCompositionBenchmark::compareAlphaDarkenOpsNoMask()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoCompositeOp *opAct = KoOptimizedCompositeOpFactory::createAlphaDarkenOpCreamy32(cs);
     KoCompositeOp *opExp = new KoCompositeOpAlphaDarken<KoBgrU8Traits, KoAlphaDarkenParamsWrapperCreamy>(cs);
 
     QVERIFY(compareTwoOps(false, opAct, opExp));
 
     delete opExp;
     delete opAct;
 }
 
 void KisCompositionBenchmark::compareOverOps()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoCompositeOp *opAct = KoOptimizedCompositeOpFactory::createOverOp32(cs);
     KoCompositeOp *opExp = new KoCompositeOpOver<KoBgrU8Traits>(cs);
 
     QVERIFY(compareTwoOps(true, opAct, opExp));
 
     delete opExp;
     delete opAct;
 }
 
 void KisCompositionBenchmark::compareOverOpsNoMask()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoCompositeOp *opAct = KoOptimizedCompositeOpFactory::createOverOp32(cs);
     KoCompositeOp *opExp = new KoCompositeOpOver<KoBgrU8Traits>(cs);
 
     QVERIFY(compareTwoOps(false, opAct, opExp));
 
     delete opExp;
     delete opAct;
 }
 
 void KisCompositionBenchmark::compareRgbF32OverOps()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F32", "");
     KoCompositeOp *opAct = KoOptimizedCompositeOpFactory::createOverOp128(cs);
     KoCompositeOp *opExp = new KoCompositeOpOver<KoRgbF32Traits>(cs);
 
     QVERIFY(compareTwoOps(false, opAct, opExp));
 
     delete opExp;
     delete opAct;
 }
 
 void KisCompositionBenchmark::testRgb8CompositeAlphaDarkenLegacy()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoCompositeOp *op = new KoCompositeOpAlphaDarken<KoBgrU8Traits, KoAlphaDarkenParamsWrapperCreamy>(cs);
     benchmarkCompositeOp(op, "Legacy");
     delete op;
 }
 
 void KisCompositionBenchmark::testRgb8CompositeAlphaDarkenOptimized()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoCompositeOp *op = KoOptimizedCompositeOpFactory::createAlphaDarkenOpCreamy32(cs);
     benchmarkCompositeOp(op, "Optimized");
     delete op;
 }
 
 void KisCompositionBenchmark::testRgb8CompositeOverLegacy()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoCompositeOp *op = new KoCompositeOpOver<KoBgrU8Traits>(cs);
     benchmarkCompositeOp(op, "Legacy");
     delete op;
 }
 
 void KisCompositionBenchmark::testRgb8CompositeOverOptimized()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoCompositeOp *op = KoOptimizedCompositeOpFactory::createOverOp32(cs);
     benchmarkCompositeOp(op, "Optimized");
     delete op;
 }
 
 void KisCompositionBenchmark::testRgbF32CompositeAlphaDarkenLegacy()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F32", "");
     KoCompositeOp *op = new KoCompositeOpAlphaDarken<KoRgbF32Traits, KoAlphaDarkenParamsWrapperCreamy>(cs);
     benchmarkCompositeOp(op, "Legacy");
     delete op;
 }
 
 void KisCompositionBenchmark::testRgbF32CompositeAlphaDarkenOptimized()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F32", "");
     KoCompositeOp *op = KoOptimizedCompositeOpFactory::createAlphaDarkenOpCreamy128(cs);
     benchmarkCompositeOp(op, "Optimized");
     delete op;
 }
 
 void KisCompositionBenchmark::testRgbF32CompositeOverLegacy()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F32", "");
     KoCompositeOp *op = new KoCompositeOpOver<KoRgbF32Traits>(cs);
     benchmarkCompositeOp(op, "RGBF32 Legacy");
     delete op;
 }
 
 void KisCompositionBenchmark::testRgbF32CompositeOverOptimized()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F32", "");
     KoCompositeOp *op = KoOptimizedCompositeOpFactory::createOverOp128(cs);
     benchmarkCompositeOp(op, "RGBF32 Optimized");
     delete op;
 }
 
 void KisCompositionBenchmark::testRgb8CompositeAlphaDarkenReal_Aligned()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     const KoCompositeOp *op = cs->compositeOp(COMPOSITE_ALPHA_DARKEN);
     benchmarkCompositeOp(op, true, 0.5, 0.3, 0, 0, ALPHA_RANDOM, ALPHA_RANDOM);
 }
 
 void KisCompositionBenchmark::testRgb8CompositeOverReal_Aligned()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     const KoCompositeOp *op = cs->compositeOp(COMPOSITE_OVER);
     benchmarkCompositeOp(op, true, 0.5, 0.3, 0, 0, ALPHA_RANDOM, ALPHA_RANDOM);
 }
 
 void KisCompositionBenchmark::testRgb8CompositeCopyLegacy()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     const KoCompositeOp *op = cs->compositeOp(COMPOSITE_COPY);
     benchmarkCompositeOp(op, "Copy");
 }
 
 void KisCompositionBenchmark::benchmarkMemcpy()
 {
     QVector<Tile> tiles =
         generateTiles(numTiles, 0, 0, ALPHA_UNIT, ALPHA_UNIT, 4);
 
     QBENCHMARK_ONCE {
         Q_FOREACH (const Tile &tile, tiles) {
             memcpy(tile.dst, tile.src, 4 * numPixels);
         }
     }
 
     freeTiles(tiles, 0, 0);
 }
 
 #ifdef HAVE_VC
     const int vecSize = Vc::float_v::size();
     const size_t uint8VecAlignment = qMax(vecSize * sizeof(quint8), sizeof(void*));
     const size_t uint32VecAlignment = qMax(vecSize * sizeof(quint32), sizeof(void*));
     const size_t floatVecAlignment = qMax(vecSize * sizeof(float), sizeof(void*));
 #endif
 
 void KisCompositionBenchmark::benchmarkUintFloat()
 {
 #ifdef HAVE_VC
     using uint_v = Vc::SimdArray<unsigned int, Vc::float_v::size()>;
 
     const int dataSize = 4096;
     void *ptr = 0;
     int error = MEMALIGN_ALLOC(&ptr, uint8VecAlignment, dataSize);
     if (error) {
         qFatal("posix_memalign failed: %d", error);
     }
     quint8 *iData = (quint8*)ptr;
     error = MEMALIGN_ALLOC(&ptr, floatVecAlignment, dataSize * sizeof(float));
     if (error) {
         qFatal("posix_memalign failed: %d", error);
     }
     float *fData = (float*)ptr;
 
     QBENCHMARK {
         for (int i = 0; i < dataSize; i += Vc::float_v::size()) {
             // convert uint -> float directly, this causes
             // static_cast helper be called
             Vc::float_v b(uint_v(iData + i));
             b.store(fData + i);
         }
     }
 
     MEMALIGN_FREE(iData);
     MEMALIGN_FREE(fData);
 #endif
 }
 
 void KisCompositionBenchmark::benchmarkUintIntFloat()
 {
 #ifdef HAVE_VC
     using int_v = Vc::SimdArray<int, Vc::float_v::size()>;
     using uint_v = Vc::SimdArray<unsigned int, Vc::float_v::size()>;
 
     const int dataSize = 4096;
     void *ptr = 0;
     int error = MEMALIGN_ALLOC(&ptr, uint8VecAlignment, dataSize);
     if (error) {
         qFatal("posix_memalign failed: %d", error);
     }
     quint8 *iData = (quint8*)ptr;
     error = MEMALIGN_ALLOC(&ptr, floatVecAlignment, dataSize * sizeof(float));
     if (error) {
         qFatal("posix_memalign failed: %d", error);
     }
     float *fData = (float*)ptr;
 
     QBENCHMARK {
         for (int i = 0; i < dataSize; i += Vc::float_v::size()) {
             // convert uint->int->float, that avoids special sign
             // treating, and gives 2.6 times speedup
             Vc::float_v b(int_v(uint_v(iData + i)));
             b.store(fData + i);
         }
     }
 
     MEMALIGN_FREE(iData);
     MEMALIGN_FREE(fData);
 #endif
 }
 
 void KisCompositionBenchmark::benchmarkFloatUint()
 {
 #ifdef HAVE_VC
     using uint_v = Vc::SimdArray<unsigned int, Vc::float_v::size()>;
 
     const int dataSize = 4096;
     void *ptr = 0;
     int error = MEMALIGN_ALLOC(&ptr, uint32VecAlignment, dataSize * sizeof(quint32));
     if (error) {
         qFatal("posix_memalign failed: %d", error);
     }
     quint32 *iData = (quint32*)ptr;
     error = MEMALIGN_ALLOC(&ptr, floatVecAlignment, dataSize * sizeof(float));
     if (error) {
         qFatal("posix_memalign failed: %d", error);
     }
     float *fData = (float*)ptr;
 
     QBENCHMARK {
         for (int i = 0; i < dataSize; i += Vc::float_v::size()) {
             // conversion float -> uint
             uint_v b(Vc::float_v(fData + i));
 
             b.store(iData + i);
         }
     }
 
     MEMALIGN_FREE(iData);
     MEMALIGN_FREE(fData);
 #endif
 }
 
 void KisCompositionBenchmark::benchmarkFloatIntUint()
 {
 #ifdef HAVE_VC
     using int_v = Vc::SimdArray<int, Vc::float_v::size()>;
     using uint_v = Vc::SimdArray<unsigned int, Vc::float_v::size()>;
 
     const int dataSize = 4096;
     void *ptr = 0;
     int error = MEMALIGN_ALLOC(&ptr, uint32VecAlignment, dataSize * sizeof(quint32));
     if (error) {
         qFatal("posix_memalign failed: %d", error);
     }
     quint32 *iData = (quint32*)ptr;
     error = MEMALIGN_ALLOC(&ptr, floatVecAlignment, dataSize * sizeof(float));
     if (error) {
         qFatal("posix_memalign failed: %d", error);
     }
     float *fData = (float*)ptr;
 
     QBENCHMARK {
         for (int i = 0; i < dataSize; i += Vc::float_v::size()) {
             // conversion float -> int -> uint
             uint_v b(int_v(Vc::float_v(fData + i)));
 
             b.store(iData + i);
         }
     }
 
     MEMALIGN_FREE(iData);
     MEMALIGN_FREE(fData);
 #endif
 }
 
 QTEST_MAIN(KisCompositionBenchmark)
 
diff --git a/libs/image/tests/kis_group_layer_test.cpp b/libs/image/tests/kis_group_layer_test.cpp
index 10ba51190a..5c04bcac1e 100644
--- a/libs/image/tests/kis_group_layer_test.cpp
+++ b/libs/image/tests/kis_group_layer_test.cpp
@@ -1,111 +1,111 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  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_group_layer_test.h"
 #include <QTest>
 
 #include "testutil.h"
 
 #include <KoColor.h>
 
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_types.h"
 #include "KoColorSpaceRegistry.h"
 #include "kis_image.h"
 
 #include "kis_undo_stores.h"
 
 
 void KisGroupLayerTest::testProjection()
 {
     const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 512, 512, colorSpace, "merge test");
 
 }
 
 #include "commands/kis_image_layer_remove_command.h"
 
 void KisGroupLayerTest::testRemoveAndUndo()
 {
     KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
 
-    QRect transpRect(50,50,300,300);
-    QRect blurRect(66,66,300,300);
-    QPoint blurShift(34,34);
-    QPoint cloneShift(75,75);
+//    QRect transpRect(50,50,300,300);
+//    QRect blurRect(66,66,300,300);
+//    QPoint blurShift(34,34);
+//    QPoint cloneShift(75,75);
 
     QRect imageRect = QRect(0, 0, 64, 64);
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(undoStore, imageRect.width(), imageRect.height(), cs, "merge test");
 
     QRect rect1(10, 10, 30, 30);
     QRect rect2(30, 30, 30, 30);
 
     KisPaintLayerSP paintLayer0 = new KisPaintLayer(image, "paint0", OPACITY_OPAQUE_U8);
     paintLayer0->paintDevice()->fill(imageRect, KoColor(Qt::white, cs));
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
     paintLayer1->paintDevice()->fill(rect1, KoColor(Qt::red, cs));
 
     KisPaintLayerSP paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8);
     paintLayer2->paintDevice()->fill(rect2, KoColor(Qt::blue, cs));
 
 
     KisGroupLayerSP groupLayer1 = new KisGroupLayer(image, "group1", OPACITY_OPAQUE_U8);
 
     image->addNode(paintLayer0, image->root());
     image->addNode(groupLayer1, image->root());
     image->addNode(paintLayer1, groupLayer1);
     image->addNode(paintLayer2, groupLayer1);
 
     image->initialRefreshGraph();
     QVERIFY(TestUtil::checkQImage(image->projection()->convertToQImage(0, imageRect),
                                   "group_layer_test",
                                   "undo_removal",
                                   "0_initial"));
 
     // touch original to cause clearing of the projection
     groupLayer1->original();
 
     image->undoAdapter()->addCommand(new KisImageLayerRemoveCommand(image, groupLayer1));
     image->waitForDone();
 
     // touch original again
     groupLayer1->original();
 
     QVERIFY(TestUtil::checkQImage(image->projection()->convertToQImage(0, imageRect),
                                   "group_layer_test",
                                   "undo_removal",
                                   "1_deleted"));
 
     undoStore->undo();
     image->waitForDone();
 
     // hey, man! don't sleep!
     groupLayer1->original();
 
     QVERIFY(TestUtil::checkQImage(image->projection()->convertToQImage(0, imageRect),
                                   "group_layer_test",
                                   "undo_removal",
                                   "2_undone"));
 }
 
 QTEST_MAIN(KisGroupLayerTest)
 
 
diff --git a/libs/image/tests/kis_image_test.cpp b/libs/image/tests/kis_image_test.cpp
index 035c843720..553d080608 100644
--- a/libs/image/tests/kis_image_test.cpp
+++ b/libs/image/tests/kis_image_test.cpp
@@ -1,1241 +1,1240 @@
 /*
  *  Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.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_image_test.h"
 #include <QApplication>
 
 #include <QTest>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 
 #include "kis_image.h"
 #include "kis_paint_layer.h"
 #include "kis_group_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_selection.h"
 #include <kis_debug.h>
 #include <kis_layer_composition.h>
 #include "kis_keyframe_channel.h"
 #include "kis_selection_mask.h"
 #include "kis_layer_utils.h"
 #include "kis_annotation.h"
 #include "KisProofingConfiguration.h"
 
 #include "kis_undo_stores.h"
 
 
 #define IMAGE_WIDTH 128
 #define IMAGE_HEIGHT 128
 
 void KisImageTest::layerTests()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer 1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
 
     QVERIFY(image->rootLayer()->firstChild()->objectName() == layer->objectName());
 }
 
 void KisImageTest::benchmarkCreation()
 {
     const QRect imageRect(0,0,3000,2000);
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     QList<KisImageSP> images;
     QList<KisSurrogateUndoStore*> stores;
 
 
     QBENCHMARK {
         for (int i = 0; i < 10; i++) {
             stores << new KisSurrogateUndoStore();
         }
 
         for (int i = 0; i < 10; i++) {
             KisImageSP image = new KisImage(stores.takeLast(), imageRect.width(), imageRect.height(), cs, "test image");
             images << image;
         }
     }
 }
 
 #include "testutil.h"
 #include "kis_stroke_strategy.h"
 #include <functional>
 
 
 class ForbiddenLodStrokeStrategy : public KisStrokeStrategy
 {
 public:
     ForbiddenLodStrokeStrategy(std::function<void()> lodCallback)
         : m_lodCallback(lodCallback)
     {
     }
 
     KisStrokeStrategy* createLodClone(int levelOfDetail) override {
         Q_UNUSED(levelOfDetail);
         m_lodCallback();
         return 0;
     }
 
 private:
     std::function<void()> m_lodCallback;
 };
 
 void notifyVar(bool *value) {
     *value = true;
 }
 
 void KisImageTest::testBlockLevelOfDetail()
 {
     TestUtil::MaskParent p;
 
     QCOMPARE(p.image->currentLevelOfDetail(), 0);
 
     p.image->setDesiredLevelOfDetail(1);
     p.image->waitForDone();
 
     QCOMPARE(p.image->currentLevelOfDetail(), 0);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(lodCreated);
     }
 
     p.image->setLevelOfDetailBlocked(true);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(!lodCreated);
     }
 
     p.image->setLevelOfDetailBlocked(false);
     p.image->setDesiredLevelOfDetail(1);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(lodCreated);
     }
 }
 
 void KisImageTest::testConvertImageColorSpace()
 {
     const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
 
     KisPaintDeviceSP device1 = new KisPaintDevice(cs8);
     KisLayerSP paint1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
 
     KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
     Q_ASSERT(filter);
     KisFilterConfigurationSP configuration = filter->defaultConfiguration();
     Q_ASSERT(configuration);
 
     KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
 
     image->addNode(paint1, image->root());
     image->addNode(blur1, image->root());
 
     image->refreshGraph();
 
     const KoColorSpace *cs16 = KoColorSpaceRegistry::instance()->rgb16();
     image->lock();
     image->convertImageColorSpace(cs16,
                                   KoColorConversionTransformation::internalRenderingIntent(),
                                   KoColorConversionTransformation::internalConversionFlags());
     image->unlock();
 
     QVERIFY(*cs16 == *image->colorSpace());
     QVERIFY(*cs16 == *image->root()->colorSpace());
     QVERIFY(*cs16 == *paint1->colorSpace());
     QVERIFY(*cs16 == *blur1->colorSpace());
 
     QVERIFY(!image->root()->compositeOp());
     QVERIFY(*cs16 == *paint1->compositeOp()->colorSpace());
     QVERIFY(*cs16 == *blur1->compositeOp()->colorSpace());
 
     image->refreshGraph();
 }
 
 void KisImageTest::testGlobalSelection()
 {
     const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
 
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 0U);
 
     KisSelectionSP selection1 = new KisSelection(new KisDefaultBounds(image));
     KisSelectionSP selection2 = new KisSelection(new KisDefaultBounds(image));
 
     image->setGlobalSelection(selection1);
     QCOMPARE(image->globalSelection(), selection1);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     image->setGlobalSelection(selection2);
     QCOMPARE(image->globalSelection(), selection2);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     image->deselectGlobalSelection();
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), true);
     QCOMPARE(image->root()->childCount(), 0U);
 
     image->reselectGlobalSelection();
     QCOMPARE(image->globalSelection(), selection2);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     // mixed deselecting/setting/reselecting
 
     image->deselectGlobalSelection();
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), true);
     QCOMPARE(image->root()->childCount(), 0U);
 
     image->setGlobalSelection(selection1);
     QCOMPARE(image->globalSelection(), selection1);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 }
 
 void KisImageTest::testCloneImage()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisAnnotationSP annotation = new KisAnnotation("mytype", "mydescription", QByteArray());
     image->addAnnotation(annotation);
     QVERIFY(image->annotation("mytype"));
 
     KisProofingConfigurationSP proofing = toQShared(new KisProofingConfiguration());
     image->setProofingConfiguration(proofing);
     QVERIFY(image->proofingConfiguration());
 
     const KoColor defaultColor(Qt::green, image->colorSpace());
     image->setDefaultProjectionColor(defaultColor);
     QCOMPARE(image->defaultProjectionColor(), defaultColor);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
     KisLayerSP layer2 = new KisPaintLayer(image, "layer2", OPACITY_OPAQUE_U8);
     image->addNode(layer2);
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     QVERIFY(TestUtil::findNode(image->root(), "layer1"));
     QVERIFY(TestUtil::findNode(image->root(), "layer2"));
 
     QUuid uuid1 = layer->uuid();
     QUuid uuid2 = layer2->uuid();
 
     {
         KisImageSP newImage = image->clone();
 
         KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
         KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
         QVERIFY(newLayer1);
         QVERIFY(newLayer2);
 
         QVERIFY(newLayer1->uuid() != uuid1);
         QVERIFY(newLayer2->uuid() != uuid2);
 
         KisAnnotationSP newAnnotation = newImage->annotation("mytype");
         QVERIFY(newAnnotation);
         QVERIFY(newAnnotation != annotation);
 
 
         KisProofingConfigurationSP newProofing = newImage->proofingConfiguration();
         QVERIFY(newProofing);
         QVERIFY(newProofing != proofing);
 
         QCOMPARE(newImage->defaultProjectionColor(), defaultColor);
     }
 
     {
         KisImageSP newImage = image->clone(true);
 
         KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
         KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
         QVERIFY(newLayer1);
         QVERIFY(newLayer2);
 
         QVERIFY(newLayer1->uuid() == uuid1);
         QVERIFY(newLayer2->uuid() == uuid2);
     }
 }
 
 void KisImageTest::testLayerComposition()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
     KisLayerSP layer2 = new KisPaintLayer(image, "layer2", OPACITY_OPAQUE_U8);
     image->addNode(layer2);
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     KisLayerComposition comp(image, "comp 1");
     comp.store();
 
     layer2->setVisible(false);
 
     QVERIFY(layer->visible());
     QVERIFY(!layer2->visible());
 
     KisLayerComposition comp2(image, "comp 2");
     comp2.store();
 
     KisLayerCompositionSP comp3 = toQShared(new KisLayerComposition(image, "comp 3"));
     comp3->store();
     image->addComposition(comp3);
 
     comp.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     comp2.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(!layer2->visible());
 
     comp.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     KisImageSP newImage = image->clone();
 
     KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
     KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
     QVERIFY(newLayer1);
     QVERIFY(newLayer2);
 
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     KisLayerComposition newComp1(comp, newImage);
     newComp1.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     KisLayerComposition newComp2(comp2, newImage);
     newComp2.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(!newLayer2->visible());
 
     newComp1.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     QVERIFY(!newImage->compositions().isEmpty());
     KisLayerCompositionSP newComp3 = newImage->compositions().first();
     newComp3->apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(!newLayer2->visible());
 }
 
 #include "kis_transparency_mask.h"
 #include "kis_psd_layer_style.h"
 
 struct FlattenTestImage
 {
     FlattenTestImage()
         : refRect(0,0,512,512)
         , p(refRect)
     {
 
         image = p.image;
         undoStore = p.undoStore;
         layer1 = p.layer;
 
         layer5 = new KisPaintLayer(p.image, "paint5", 0.4 * OPACITY_OPAQUE_U8);
         layer5->disableAlphaChannel(true);
 
         layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8);
         tmask = new KisTransparencyMask();
 
         // check channel flags
         // make addition composite op
         group1 = new KisGroupLayer(p.image, "group1", OPACITY_OPAQUE_U8);
         layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8);
         layer4 = new KisPaintLayer(p.image, "paint4", OPACITY_OPAQUE_U8);
 
         layer6 = new KisPaintLayer(p.image, "paint6", OPACITY_OPAQUE_U8);
 
         layer7 = new KisPaintLayer(p.image, "paint7", OPACITY_OPAQUE_U8);
         layer8 = new KisPaintLayer(p.image, "paint8", OPACITY_OPAQUE_U8);
         layer7->setCompositeOpId(COMPOSITE_ADD);
         layer8->setCompositeOpId(COMPOSITE_ADD);
 
         QRect rect1(100, 100, 100, 100);
         QRect rect2(150, 150, 150, 150);
         QRect tmaskRect(200,200,100,100);
 
         QRect rect3(400, 100, 100, 100);
         QRect rect4(500, 100, 100, 100);
 
         QRect rect5(50, 50, 100, 100);
 
         QRect rect6(50, 250, 100, 100);
 
         QRect rect7(50, 350, 50, 50);
         QRect rect8(50, 400, 50, 50);
 
         layer1->paintDevice()->fill(rect1, KoColor(Qt::red, p.image->colorSpace()));
 
         layer2->paintDevice()->fill(rect2, KoColor(Qt::green, p.image->colorSpace()));
         tmask->testingInitSelection(tmaskRect, layer2);
 
         layer3->paintDevice()->fill(rect3, KoColor(Qt::blue, p.image->colorSpace()));
         layer4->paintDevice()->fill(rect4, KoColor(Qt::yellow, p.image->colorSpace()));
         layer5->paintDevice()->fill(rect5, KoColor(Qt::green, p.image->colorSpace()));
 
         layer6->paintDevice()->fill(rect6, KoColor(Qt::cyan, p.image->colorSpace()));
 
         layer7->paintDevice()->fill(rect7, KoColor(Qt::red, p.image->colorSpace()));
         layer8->paintDevice()->fill(rect8, KoColor(Qt::green, p.image->colorSpace()));
 
         KisPSDLayerStyleSP style(new KisPSDLayerStyle());
         style->dropShadow()->setEffectEnabled(true);
         style->dropShadow()->setDistance(10.0);
         style->dropShadow()->setSpread(80.0);
         style->dropShadow()->setSize(10);
         style->dropShadow()->setNoise(0);
         style->dropShadow()->setKnocksOut(false);
         style->dropShadow()->setOpacity(80.0);
         layer2->setLayerStyle(style);
 
         layer2->setCompositeOpId(COMPOSITE_ADD);
         group1->setCompositeOpId(COMPOSITE_ADD);
 
         p.image->addNode(layer5);
 
         p.image->addNode(layer2);
         p.image->addNode(tmask, layer2);
 
         p.image->addNode(group1);
         p.image->addNode(layer3, group1);
         p.image->addNode(layer4, group1);
 
         p.image->addNode(layer6);
 
         p.image->addNode(layer7);
         p.image->addNode(layer8);
 
         p.image->initialRefreshGraph();
 
         // dbgKrita << ppVar(layer1->exactBounds());
         // dbgKrita << ppVar(layer5->exactBounds());
         // dbgKrita << ppVar(layer2->exactBounds());
         // dbgKrita << ppVar(group1->exactBounds());
         // dbgKrita << ppVar(layer3->exactBounds());
         // dbgKrita << ppVar(layer4->exactBounds());
 
         TestUtil::ReferenceImageChecker chk("flatten", "imagetest");
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     QRect refRect;
     TestUtil::MaskParent p;
 
     KisImageSP image;
     KisSurrogateUndoStore *undoStore;
     KisPaintLayerSP layer1;
 
     KisPaintLayerSP layer2;
     KisTransparencyMaskSP tmask;
 
     KisGroupLayerSP group1;
     KisPaintLayerSP layer3;
     KisPaintLayerSP layer4;
 
     KisPaintLayerSP layer5;
 
     KisPaintLayerSP layer6;
 
     KisPaintLayerSP layer7;
     KisPaintLayerSP layer8;
 };
 
 template<class ContainerTest>
 KisLayerSP flattenLayerHelper(ContainerTest &p, KisLayerSP layer, bool nothingHappens = false)
 {
     QSignalSpy spy(p.image.data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)));
 
     //p.image->flattenLayer(layer);
     KisLayerUtils::flattenLayer(p.image, layer);
     p.image->waitForDone();
 
     if (nothingHappens) {
         Q_ASSERT(!spy.count());
         return layer;
     }
 
     Q_ASSERT(spy.count() == 1);
     QList<QVariant> arguments = spy.takeFirst();
     KisNodeSP newNode = arguments.first().value<KisNodeSP>();
 
     KisLayerSP newLayer = qobject_cast<KisLayer*>(newNode.data());
     return newLayer;
 }
 
 void KisImageTest::testFlattenLayer()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker chk("flatten", "imagetest");
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.layer2);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.layer2);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
     }
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.group1);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "02_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(newLayer->exactBounds(), QRect(400, 100, 200, 100));
     }
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.layer5, true);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.layer5);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "03_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 50, 100, 100));
 
         QCOMPARE(newLayer->alphaChannelDisabled(), true);
     }
 }
 
 #include <kis_meta_data_merge_strategy_registry.h>
 
 template<class ContainerTest>
 KisLayerSP mergeHelper(ContainerTest &p, KisLayerSP layer)
 {
     KisNodeSP parent = layer->parent();
     const int newIndex = parent->index(layer) - 1;
 
     p.image->mergeDown(layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
 
     //KisLayerUtils::mergeDown(p.image, layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
     p.image->waitForDone();
 
     KisLayerSP newLayer = qobject_cast<KisLayer*>(parent->at(newIndex).data());
     return newLayer;
 }
 
 void KisImageTest::testMergeDown()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_simple", "imagetest");
 
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer5);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer2);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "02_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(100, 100, 213, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.group1);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "03_group1_mergedown_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(100, 100, 500, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationInheritsAlpha()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_dst_inheritsalpha", "imagetest");
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer2);
 
         // WARN: this check is suspicious!
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_proj_merged_layer2_over_layer5_IA"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50,50, 263, 267));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationCustomCompositeOp()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_dst_customop", "imagetest");
 
     {
         QCOMPARE(p.layer6->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer6->alphaChannelDisabled(), false);
 
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer6);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer6_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationSameCompositeOpLayerStyle()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_sameop_ls", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.group1);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(197, 100, 403, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationSameCompositeOp()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_sameop_fastpath", "imagetest");
 
     {
         QCOMPARE(p.layer8->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer8->alphaChannelDisabled(), false);
 
         QCOMPARE(p.layer7->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer7->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer8);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 350, 50, 100));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 #include "kis_image_animation_interface.h"
 void KisImageTest::testMergeDownMultipleFrames()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_simple", "imagetest");
 
     QSet<int> initialFrames;
     {
         KisLayerSP l = p.layer5;
         l->enableAnimation();
         KisKeyframeChannel *channel = l->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
         channel->addKeyframe(10);
         channel->addKeyframe(20);
         channel->addKeyframe(30);
 
         QCOMPARE(channel->keyframeCount(), 4);
         initialFrames = KisLayerUtils::fetchLayerFramesRecursive(l);
         QCOMPARE(initialFrames.size(), 4);
     }
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer5);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
 
         QVERIFY(newLayer->isAnimated());
 
         QSet<int> newFrames = KisLayerUtils::fetchLayerFramesRecursive(newLayer);
         QCOMPARE(newFrames, initialFrames);
 
         foreach (int frame, newFrames) {
             KisImageAnimationInterface *interface = p.image->animationInterface();
             int savedSwitchedTime = 0;
             interface->saveAndResetCurrentTime(frame, &savedSwitchedTime);
             QCOMPARE(newLayer->exactBounds(), QRect(100,100,100,100));
             interface->restoreCurrentTime(&savedSwitchedTime);
         }
 
         p.undoStore->undo();
         p.image->waitForDone();
 
          QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 }
 
 template<class ContainerTest>
 KisNodeSP mergeMultipleHelper(ContainerTest &p, QList<KisNodeSP> selectedNodes, KisNodeSP putAfter)
 {
     QSignalSpy spy(p.image.data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)));
 
     p.image->mergeMultipleLayers(selectedNodes, putAfter);
     //KisLayerUtils::mergeMultipleLayers(p.image, selectedNodes, putAfter);
     p.image->waitForDone();
 
     Q_ASSERT(spy.count() == 1);
     QList<QVariant> arguments = spy.takeFirst();
     KisNodeSP newNode = arguments.first().value<KisNodeSP>();
     return newNode;
 }
 void KisImageTest::testMergeMultiple()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergemultiple", "imagetest");
 
     {
         QList<KisNodeSP> selectedNodes;
 
         selectedNodes << p.layer2
                       << p.group1
                       << p.layer6;
 
         {
             KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
 
             //KisNodeSP newLayer = p.image->mergeMultipleLayers(selectedNodes, 0);
             //p.image->waitForDone();
 
             QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
             QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
             QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
             QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         }
     }
 
     p.p.undoStore->undo();
     p.image->waitForDone();
 
 
     // Test reversed order, the result must be the same
 
     {
         QList<KisNodeSP> selectedNodes;
 
         selectedNodes << p.layer6
                       << p.group1
                       << p.layer2;
 
         {
             KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
 
             //KisNodeSP newLayer = p.image->mergeMultipleLayers(selectedNodes, 0);
             //p.image->waitForDone();
 
             QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
             QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
             QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
             QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         }
     }
 
 }
 
 void testMergeCrossColorSpaceImpl(bool useProjectionColorSpace, bool swapSpaces)
 {
-    QRect refRect;
     TestUtil::MaskParent p;
 
     KisPaintLayerSP layer1;
     KisPaintLayerSP layer2;
     KisPaintLayerSP layer3;
 
     const KoColorSpace *cs2 = useProjectionColorSpace ?
         p.image->colorSpace() : KoColorSpaceRegistry::instance()->lab16();
 
     const KoColorSpace *cs3 = KoColorSpaceRegistry::instance()->rgb16();
 
     if (swapSpaces) {
         std::swap(cs2, cs3);
     }
 
     dbgKrita << "Testing testMergeCrossColorSpaceImpl:";
     dbgKrita << "    " << ppVar(cs2);
     dbgKrita << "    " << ppVar(cs3);
 
     layer1 = p.layer;
     layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8, cs2);
     layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8, cs3);
 
     QRect rect1(100, 100, 100, 100);
     QRect rect2(150, 150, 150, 150);
     QRect rect3(250, 250, 200, 200);
 
     layer1->paintDevice()->fill(rect1, KoColor(Qt::red, layer1->colorSpace()));
     layer2->paintDevice()->fill(rect2, KoColor(Qt::green, layer2->colorSpace()));
     layer3->paintDevice()->fill(rect3, KoColor(Qt::blue, layer3->colorSpace()));
 
     p.image->addNode(layer2);
     p.image->addNode(layer3);
 
     p.image->initialRefreshGraph();
 
     {
         KisLayerSP newLayer = mergeHelper(p, layer3);
 
         QCOMPARE(newLayer->colorSpace(), p.image->colorSpace());
 
         p.undoStore->undo();
         p.image->waitForDone();
     }
 
     {
         layer2->disableAlphaChannel(true);
 
         KisLayerSP newLayer = mergeHelper(p, layer3);
 
         QCOMPARE(newLayer->colorSpace(), p.image->colorSpace());
 
         p.undoStore->undo();
         p.image->waitForDone();
     }
 }
 
 void KisImageTest::testMergeCrossColorSpace()
 {
     testMergeCrossColorSpaceImpl(true, false);
     testMergeCrossColorSpaceImpl(true, true);
     testMergeCrossColorSpaceImpl(false, false);
     testMergeCrossColorSpaceImpl(false, true);
 }
 
 void KisImageTest::testMergeSelectionMasks()
 {
     QRect refRect;
     TestUtil::MaskParent p;
 
     QRect rect1(100, 100, 100, 100);
     QRect rect2(150, 150, 150, 150);
     QRect rect3(50, 50, 100, 100);
 
     KisPaintLayerSP layer1 = p.layer;
     layer1->paintDevice()->fill(rect1, KoColor(Qt::red, layer1->colorSpace()));
 
     p.image->initialRefreshGraph();
 
     KisSelectionSP sel = new KisSelection(layer1->paintDevice()->defaultBounds());
 
     sel->pixelSelection()->select(rect2, MAX_SELECTED);
     KisSelectionMaskSP mask1 = new KisSelectionMask(p.image);
     mask1->initSelection(sel, layer1);
     p.image->addNode(mask1, layer1);
 
     QVERIFY(!layer1->selection());
 
     mask1->setActive(true);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(150,150,150,150));
 
     sel->pixelSelection()->select(rect3, MAX_SELECTED);
     KisSelectionMaskSP mask2 = new KisSelectionMask(p.image);
     mask2->initSelection(sel, layer1);
     p.image->addNode(mask2, layer1);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(150,150,150,150));
 
     mask2->setActive(true);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(50,50,250,250));
 
     QList<KisNodeSP> selectedNodes;
 
     selectedNodes << mask2
                   << mask1;
 
     {
         KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
         QCOMPARE(newLayer->parent(), KisNodeSP(layer1));
         QCOMPARE((int)layer1->childCount(), 1);
         QCOMPARE(layer1->selection()->selectedExactRect(), QRect(50,50,250,250));
     }
 }
 
 void KisImageTest::testFlattenImage()
 {
     FlattenTestImage p;
     KisImageSP image = p.image;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
 
     {
         KisLayerUtils::flattenImage(p.image, 0);
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer5); // flatten with active layer just under the root (not inside any group)
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer2); // flatten with active layer just under the root (not inside any group), but with a mask
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer3); // flatten with active layer inside of a group
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 }
 
 struct FlattenPassThroughTestImage
 {
     FlattenPassThroughTestImage()
         : refRect(0,0,512,512)
         , p(refRect)
     {
 
         image = p.image;
         undoStore = p.undoStore;
 
         group1 = new KisGroupLayer(p.image, "group1", OPACITY_OPAQUE_U8);
         layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8);
         layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8);
 
         group4 = new KisGroupLayer(p.image, "group4", OPACITY_OPAQUE_U8);
         layer5 = new KisPaintLayer(p.image, "paint5", OPACITY_OPAQUE_U8);
         layer6 = new KisPaintLayer(p.image, "paint6", OPACITY_OPAQUE_U8);
 
         QRect rect2(100, 100, 100, 100);
         QRect rect3(150, 150, 100, 100);
 
         QRect rect5(200, 200, 100, 100);
         QRect rect6(250, 250, 100, 100);
 
         group1->setPassThroughMode(true);
         layer2->paintDevice()->fill(rect2, KoColor(Qt::red, p.image->colorSpace()));
         layer3->paintDevice()->fill(rect3, KoColor(Qt::green, p.image->colorSpace()));
 
         group4->setPassThroughMode(true);
         layer5->paintDevice()->fill(rect5, KoColor(Qt::blue, p.image->colorSpace()));
         layer6->paintDevice()->fill(rect6, KoColor(Qt::yellow, p.image->colorSpace()));
 
 
         p.image->addNode(group1);
         p.image->addNode(layer2, group1);
         p.image->addNode(layer3, group1);
 
         p.image->addNode(group4);
         p.image->addNode(layer5, group4);
         p.image->addNode(layer6, group4);
 
         p.image->initialRefreshGraph();
 
         TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     QRect refRect;
     TestUtil::MaskParent p;
 
     KisImageSP image;
     KisSurrogateUndoStore *undoStore;
 
     KisGroupLayerSP group1;
     KisPaintLayerSP layer2;
     KisPaintLayerSP layer3;
 
     KisGroupLayerSP group4;
     KisPaintLayerSP layer5;
     KisPaintLayerSP layer6;
 };
 
 void KisImageTest::testFlattenPassThroughLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 void KisImageTest::testMergeTwoPassThroughLayers()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.group4);
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QVERIFY(newLayer->inherits("KisGroupLayer"));
     }
 }
 
 void KisImageTest::testMergePaintOverPassThroughLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group4);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
 
         newLayer = mergeHelper(p, newLayer);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 void KisImageTest::testMergePassThroughOverPaintLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
 
         newLayer = mergeHelper(p, p.group4);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 #include "kis_paint_device_debug_utils.h"
 #include "kis_algebra_2d.h"
 
 void KisImageTest::testPaintOverlayMask()
 {
     QRect refRect(0, 0, 512, 512);
     TestUtil::MaskParent p(refRect);
 
     QRect fillRect(50, 50, 412, 412);
     QRect selectionRect(200, 200, 100, 50);
 
     KisPaintLayerSP layer1 = p.layer;
     layer1->paintDevice()->fill(fillRect, KoColor(Qt::yellow, layer1->colorSpace()));
 
     KisSelectionMaskSP mask = new KisSelectionMask(p.image);
     KisSelectionSP selection = new KisSelection(new KisSelectionDefaultBounds(layer1->paintDevice(), p.image));
 
     selection->pixelSelection()->select(selectionRect, 128);
     selection->pixelSelection()->select(KisAlgebra2D::blowRect(selectionRect,-0.3), 255);
 
     mask->setSelection(selection);
 
     //mask->setVisible(false);
     //mask->setActive(false);
 
     p.image->addNode(mask, layer1);
 
     // a simple layer to disable oblidge child mechanism
     KisPaintLayerSP layer2 = new KisPaintLayer(p.image, "layer2", OPACITY_OPAQUE_U8);
     p.image->addNode(layer2);
 
     p.image->initialRefreshGraph();
 
     KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "00_initial", "dd");
 
     p.image->setOverlaySelectionMask(mask);
     p.image->waitForDone();
 
     KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "01_activated", "dd");
 
     p.image->setOverlaySelectionMask(0);
     p.image->waitForDone();
 
     KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "02_deactivated", "dd");
 
 
 
 }
 
 
 
 QTEST_MAIN(KisImageTest)
diff --git a/libs/image/tests/kis_paint_device_test.cpp b/libs/image/tests/kis_paint_device_test.cpp
index acf0149928..2b5f798bfb 100644
--- a/libs/image/tests/kis_paint_device_test.cpp
+++ b/libs/image/tests/kis_paint_device_test.cpp
@@ -1,2371 +1,2370 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  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_paint_device_test.h"
 #include <QTest>
 
 #include <QTime>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoStore.h>
 
 #include "kis_paint_device_writer.h"
 #include "kis_painter.h"
 #include "kis_types.h"
 #include "kis_paint_device.h"
 #include "kis_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_selection.h"
 #include "kis_datamanager.h"
 #include "kis_global.h"
 #include "testutil.h"
 #include "kis_transaction.h"
 #include "kis_image.h"
 #include "config-limit-long-tests.h"
 #include "kistest.h"
 
 
 class KisFakePaintDeviceWriter : public KisPaintDeviceWriter {
 public:
     KisFakePaintDeviceWriter(KoStore *store)
         : m_store(store)
     {
     }
 
     bool write(const QByteArray &data) override {
         return (m_store->write(data) == data.size());
     }
 
     bool write(const char* data, qint64 length) override {
         return (m_store->write(data, length) == length);
     }
 
     KoStore *m_store;
 };
 
 void KisPaintDeviceTest::testCreation()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     QVERIFY(dev->objectName().isEmpty());
 
     dev = new KisPaintDevice(cs);
     QVERIFY(*dev->colorSpace() == *cs);
     QVERIFY(dev->x() == 0);
     QVERIFY(dev->y() == 0);
     QVERIFY(dev->pixelSize() == cs->pixelSize());
     QVERIFY(dev->channelCount() == cs->channelCount());
     QVERIFY(dev->dataManager() != 0);
 
     KisImageSP image = new KisImage(0, 1000, 1000, cs, "merge test");
     KisPaintLayerSP layer = new KisPaintLayer(image, "bla", 125);
 
     dev = new KisPaintDevice(layer.data(), cs);
     QVERIFY(*dev->colorSpace() == *cs);
     QVERIFY(dev->x() == 0);
     QVERIFY(dev->y() == 0);
     QVERIFY(dev->pixelSize() == cs->pixelSize());
     QVERIFY(dev->channelCount() == cs->channelCount());
     QVERIFY(dev->dataManager() != 0);
 
     // Let the layer go out of scope and see what happens
     {
         KisPaintLayerSP l2 = new KisPaintLayer(image, "blabla", 250);
         dev = new KisPaintDevice(l2.data(), cs);
     }
 
 }
 
 
 void KisPaintDeviceTest::testStore()
 {
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     KoStore * readStore =
         KoStore::createStore(QString(FILES_DATA_DIR) + QDir::separator() + "store_test.kra", KoStore::Read);
     readStore->open("built image/layers/layer0");
     QVERIFY(dev->read(readStore->device()));
     readStore->close();
     delete readStore;
 
     QVERIFY(dev->exactBounds() == QRect(0, 0, 100, 100));
 
     KoStore * writeStore =
         KoStore::createStore(QString(FILES_OUTPUT_DIR) + QDir::separator() + "store_test_out.kra", KoStore::Write);
     KisFakePaintDeviceWriter fakeWriter(writeStore);
     writeStore->open("built image/layers/layer0");
     QVERIFY(dev->write(fakeWriter));
     writeStore->close();
     delete writeStore;
 
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     readStore =
         KoStore::createStore(QString(FILES_OUTPUT_DIR) + QDir::separator() + "store_test_out.kra", KoStore::Read);
     readStore->open("built image/layers/layer0");
     QVERIFY(dev2->read(readStore->device()));
     readStore->close();
     delete readStore;
 
     QVERIFY(dev2->exactBounds() == QRect(0, 0, 100, 100));
 
     QPoint pt;
     if (!TestUtil::comparePaintDevices(pt, dev, dev2)) {
         QFAIL(QString("Loading a saved image is not pixel perfect, first different pixel: %1,%2 ").arg(pt.x()).arg(pt.y()).toLatin1());
     }
 
 }
 
 void KisPaintDeviceTest::testGeometry()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, pixel);
     dev->fill(0, 0, 512, 512, pixel);
 
     QCOMPARE(dev->exactBounds(), QRect(0, 0, 512, 512));
     QCOMPARE(dev->extent(), QRect(0, 0, 512, 512));
 
     dev->moveTo(10, 10);
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, 512, 512));
     QCOMPARE(dev->extent(), QRect(10, 10, 512, 512));
 
     dev->crop(50, 50, 50, 50);
     QCOMPARE(dev->exactBounds(), QRect(50, 50, 50, 50));
     QCOMPARE(dev->extent(), QRect(10, 10, 128, 128));
 
     QColor c;
 
     dev->clear(QRect(50, 50, 50, 50));
     dev->pixel(80, 80, &c);
     QVERIFY(c.alpha() == OPACITY_TRANSPARENT_U8);
 
     dev->fill(0, 0, 512, 512, pixel);
     dev->pixel(80, 80, &c);
     QVERIFY(c == Qt::white);
     QVERIFY(c.alpha() == OPACITY_OPAQUE_U8);
 
     dev->clear();
     dev->pixel(80, 80, &c);
     QVERIFY(c.alpha() == OPACITY_TRANSPARENT_U8);
 
     QVERIFY(dev->extent().isEmpty());
     QVERIFY(dev->exactBounds().isEmpty());
 
 }
 
 void KisPaintDeviceTest::testClear()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 
     dev->clear();
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 
     QRect fillRect1(50, 100, 150, 100);
     dev->fill(fillRect1, KoColor(Qt::red, cs));
 
     QCOMPARE(dev->extent(), QRect(0, 64, 256, 192));
     QCOMPARE(dev->exactBounds(), fillRect1);
 
     dev->clear(QRect(100, 100, 100, 100));
 
     QCOMPARE(dev->extent(), QRect(0, 64, 256, 192));
     QCOMPARE(dev->exactBounds(), QRect(50, 100, 50, 100));
 
     dev->clear();
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 }
 
 void KisPaintDeviceTest::testCrop()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, pixel);
     dev->fill(-14, 8, 433, 512, pixel);
 
     QVERIFY(dev->exactBounds() == QRect(-14, 8, 433, 512));
 
     // Crop inside
     dev->crop(50, 50, 150, 150);
     QVERIFY(dev->exactBounds() == QRect(50, 50, 150, 150));
 
     // Crop outside, pd should not grow
     dev->crop(0, 0, 1000, 1000);
     QVERIFY(dev->exactBounds() == QRect(50, 50, 150, 150));
 }
 
 void KisPaintDeviceTest::testRoundtripReadWrite()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "tile.png");
     dev->convertFromQImage(image, 0);
 
     quint8* bytes = new quint8[cs->pixelSize() * image.width() * image.height()];
     memset(bytes, 0, image.width() * image.height() * dev->pixelSize());
     dev->readBytes(bytes, image.rect());
 
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     dev2->writeBytes(bytes, image.rect());
     QVERIFY(dev2->exactBounds() == image.rect());
 
     dev2->convertToQImage(0, 0, 0, image.width(), image.height()).save("readwrite.png");
 
 
     QPoint pt;
     if (!TestUtil::comparePaintDevices(pt, dev, dev2)) {
         QFAIL(QString("Failed round trip using readBytes and writeBytes, first different pixel: %1,%2 ").arg(pt.x()).arg(pt.y()).toLatin1());
     }
 }
 
 void logFailure(const QString & reason, const KoColorSpace * srcCs, const KoColorSpace * dstCs)
 {
     QString profile1("no profile");
     QString profile2("no profile");
     if (srcCs->profile())
         profile1 = srcCs->profile()->name();
     if (dstCs->profile())
         profile2 = dstCs->profile()->name();
 
     QWARN(QString("Failed %1 %2 -> %3 %4 %5")
           .arg(srcCs->name())
           .arg(profile1)
           .arg(dstCs->name())
           .arg(profile2)
           .arg(reason)
           .toLatin1());
 }
 
 void KisPaintDeviceTest::testColorSpaceConversion()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "tile.png");
     const KoColorSpace* srcCs = KoColorSpaceRegistry::instance()->rgb8();
     const KoColorSpace* dstCs = KoColorSpaceRegistry::instance()->lab16();
     KisPaintDeviceSP dev = new KisPaintDevice(srcCs);
     dev->convertFromQImage(image, 0);
     dev->moveTo(10, 10);   // Unalign with tile boundaries
     KUndo2Command* cmd = new KUndo2Command();
     dev->convertTo(dstCs,
                    KoColorConversionTransformation::internalRenderingIntent(),
                    KoColorConversionTransformation::internalConversionFlags(),
                    cmd);
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, image.width(), image.height()));
     QCOMPARE(dev->pixelSize(), dstCs->pixelSize());
     QVERIFY(*dev->colorSpace() == *dstCs);
 
     cmd->redo();
     cmd->undo();
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, image.width(), image.height()));
     QCOMPARE(dev->pixelSize(), srcCs->pixelSize());
     QVERIFY(*dev->colorSpace() == *srcCs);
 
     delete cmd;
 }
 
 
 void KisPaintDeviceTest::testRoundtripConversion()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     QImage result = dev->convertToQImage(0, 0, 0, 640, 441);
 
     QPoint errpoint;
 
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("kis_paint_device_test_test_roundtrip_qimage.png");
         result.save("kis_paint_device_test_test_roundtrip_result.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testFastBitBlt()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dstDev = new KisPaintDevice(cs);
     KisPaintDeviceSP srcDev = new KisPaintDevice(cs);
     srcDev->convertFromQImage(image, 0);
 
     QRect cloneRect(100,100,200,200);
     QPoint errpoint;
 
 
     QVERIFY(dstDev->fastBitBltPossible(srcDev));
     dstDev->fastBitBlt(srcDev, cloneRect);
 
     QImage srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                                cloneRect.width(), cloneRect.height());
     QImage dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
 
     if (!TestUtil::compareQImages(errpoint, srcImage, dstImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     // Test Rough version
     dstDev->clear();
     dstDev->fastBitBltRough(srcDev, cloneRect);
 
     srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                        cloneRect.width(), cloneRect.height());
     dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                        cloneRect.width(), cloneRect.height());
 
     if (!TestUtil::compareQImages(errpoint, srcImage, dstImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     srcDev->moveTo(10,10);
     QVERIFY(!dstDev->fastBitBltPossible(srcDev));
 }
 
 void KisPaintDeviceTest::testMakeClone()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP srcDev = new KisPaintDevice(cs);
     srcDev->convertFromQImage(image, 0);
     srcDev->moveTo(10,10);
 
     const KoColorSpace * weirdCS = KoColorSpaceRegistry::instance()->lab16();
     KisPaintDeviceSP dstDev = new KisPaintDevice(weirdCS);
     dstDev->moveTo(1000,1000);
 
     QVERIFY(!dstDev->fastBitBltPossible(srcDev));
 
     QRect cloneRect(100,100,200,200);
     QPoint errpoint;
 
     dstDev->makeCloneFrom(srcDev, cloneRect);
 
     QVERIFY(*dstDev->colorSpace() == *srcDev->colorSpace());
     QCOMPARE(dstDev->pixelSize(), srcDev->pixelSize());
     QCOMPARE(dstDev->x(), srcDev->x());
     QCOMPARE(dstDev->y(), srcDev->y());
     QCOMPARE(dstDev->exactBounds(), cloneRect);
 
     QImage srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
     QImage dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
     if (!TestUtil::compareQImages(errpoint, dstImage, srcImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testThumbnail()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     {
         KisPaintDeviceSP thumb = dev->createThumbnailDevice(50, 50);
         QRect rc = thumb->exactBounds();
         QVERIFY(rc.width() <= 50);
         QVERIFY(rc.height() <= 50);
     }
     {
         QImage thumb = dev->createThumbnail(50, 50);
         QVERIFY(!thumb.isNull());
         QVERIFY(thumb.width() <= 50);
         QVERIFY(thumb.height() <= 50);
         image.save("kis_paint_device_test_test_thumbnail.png");
     }
 }
 
 void KisPaintDeviceTest::testThumbnailDeviceWithOffset()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     dev->setX(10);
     dev->setY(10);
 
     QImage thumb = dev->createThumbnail(640,441,QRect(10,10,640,441));
 
     image.save("oring.png");
     thumb.save("thumb.png");
 
     QPoint pt;
     QVERIFY(TestUtil::compareQImages(pt, thumb, image));
 }
 
 void KisPaintDeviceTest::testCaching()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* whitePixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, whitePixel);
 
     quint8* blackPixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::black, blackPixel);
 
     dev->fill(0, 0, 512, 512, whitePixel);
     QImage thumb1 = dev->createThumbnail(50, 50);
     QRect exactBounds1 = dev->exactBounds();
 
     dev->fill(0, 0, 768, 768, blackPixel);
     QImage thumb2 = dev->createThumbnail(50, 50);
     QRect exactBounds2 = dev->exactBounds();
 
     dev->moveTo(10, 10);
     QImage thumb3 = dev->createThumbnail(50, 50);
     QRect exactBounds3 = dev->exactBounds();
 
     dev->crop(50, 50, 50, 50);
     QImage thumb4 = dev->createThumbnail(50, 50);
     QRect exactBounds4 = dev->exactBounds();
 
     QVERIFY(thumb1 != thumb2);
     QVERIFY(thumb2 == thumb3); // Cache miss, but image is the same
     QVERIFY(thumb3 != thumb4);
     QVERIFY(thumb4 != thumb1);
 
     QCOMPARE(exactBounds1, QRect(0,0,512,512));
     QCOMPARE(exactBounds2, QRect(0,0,768,768));
     QCOMPARE(exactBounds3, QRect(10,10,768,768));
     QCOMPARE(exactBounds4, QRect(50,50,50,50));
 }
 
 void KisPaintDeviceTest::testRegion()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* whitePixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, whitePixel);
 
     dev->fill(0, 0, 10, 10, whitePixel);
     dev->fill(70, 70, 10, 10, whitePixel);
     dev->fill(129, 0, 10, 10, whitePixel);
     dev->fill(0, 1030, 10, 10, whitePixel);
 
     QRegion referenceRegion;
     referenceRegion += QRect(0,0,64,64);
     referenceRegion += QRect(64,64,64,64);
     referenceRegion += QRect(128,0,64,64);
     referenceRegion += QRect(0,1024,64,64);
 
     QCOMPARE(dev->exactBounds(), QRect(0,0,139,1040));
     QCOMPARE(dev->region(), referenceRegion);
 }
 
 void KisPaintDeviceTest::testPixel()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QColor c = Qt::red;
     quint8 opacity = 125;
 
     c.setAlpha(opacity);
     dev->setPixel(5, 5, c);
 
     QColor c2;
 
     dev->pixel(5, 5, &c2);
 
     QVERIFY(c == c2);
     QVERIFY(opacity == c2.alpha());
 
 }
 
 void KisPaintDeviceTest::testPlanarReadWrite()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(QColor(255, 200, 155, 100), pixel);
     dev->fill(0, 0, 5000, 5000, pixel);
     delete[] pixel;
 
     QColor c1;
     dev->pixel(5, 5, &c1);
 
     QVector<quint8*> planes = dev->readPlanarBytes(500, 500, 100, 100);
     QVector<quint8*> swappedPlanes;
 
     QCOMPARE((int)planes.size(), (int)dev->channelCount());
 
     for (int i = 0; i < 100*100; i++) {
         // BGRA encoded
         QVERIFY(planes.at(2)[i] == 255);
         QVERIFY(planes.at(1)[i] == 200);
         QVERIFY(planes.at(0)[i] == 155);
         QVERIFY(planes.at(3)[i] == 100);
     }
 
     for (uint i = 1; i < dev->channelCount() + 1; ++i) {
         swappedPlanes.append(planes[dev->channelCount() - i]);
     }
 
     dev->writePlanarBytes(swappedPlanes, 0, 0, 100, 100);
 
     dev->convertToQImage(0, 0, 0, 1000, 1000).save("planar.png");
 
     dev->pixel(5, 5, &c1);
 
     QVERIFY(c1.red() == 200);
     QVERIFY(c1.green() == 255);
     QVERIFY(c1.blue() == 100);
     QVERIFY(c1.alpha() == 155);
 
     dev->pixel(75, 50, &c1);
 
     QVERIFY(c1.red() == 200);
     QVERIFY(c1.green() == 255);
     QVERIFY(c1.blue() == 100);
     QVERIFY(c1.alpha() == 155);
 
     // check if one of the planes is Null.
     Q_ASSERT(planes.size() == 4);
     delete [] planes[2];
     planes[2] = 0;
     dev->writePlanarBytes(planes, 0, 0, 100, 100);
     dev->convertToQImage(0, 0, 0, 1000, 1000).save("planar_noR.png");
 
     dev->pixel(75, 50, &c1);
 
     QCOMPARE(c1.red(), 200);
     QCOMPARE(c1.green(), 200);
     QCOMPARE(c1.blue(), 155);
     QCOMPARE(c1.alpha(), 100);
 
     QVector<quint8*>::iterator i;
     for (i = planes.begin(); i != planes.end(); ++i)
     {
         delete [] *i;
     }
     swappedPlanes.clear();
 }
 
 void KisPaintDeviceTest::testBltPerformance()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP fdev = new KisPaintDevice(cs);
     fdev->convertFromQImage(image, 0);
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->fill(0, 0, 640, 441, KoColor(Qt::white, cs).data());
 
     QTime t;
     t.start();
 
     int x;
 #ifdef LIMIT_LONG_TESTS
     int steps = 10;
 #else
     int steps = 1000;
 #endif
     for (x = 0; x < steps; ++x) {
         KisPainter gc(dev);
         gc.bitBlt(QPoint(0, 0), fdev, image.rect());
     }
 
     dbgKrita << x
     << "blits"
     << " done in "
     << t.elapsed()
     << "ms";
 
 
 }
 
 void KisPaintDeviceTest::testDeviceDuplication()
 {
     QRect fillRect(0,0,64,64);
     quint8 fillPixel[4]={255,255,255,255};
     QRect clearRect(10,10,20,20);
     QImage referenceImage;
     QImage resultImage;
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP device = new KisPaintDevice(cs);
 
 //    dbgKrita<<"FILLING";
     device->fill(fillRect.left(), fillRect.top(),
                  fillRect.width(), fillRect.height(),fillPixel);
     referenceImage = device->convertToQImage(0);
 
 
     KisTransaction transaction1(device);
 //    dbgKrita<<"CLEARING";
     device->clear(clearRect);
 
     transaction1.revert();
 
     resultImage = device->convertToQImage(0);
     QVERIFY(resultImage == referenceImage);
 
     KisPaintDeviceSP clone =  new KisPaintDevice(*device);
 
     KisTransaction transaction(clone);
 //    dbgKrita<<"CLEARING";
     clone->clear(clearRect);
 
     transaction.revert();
 
     resultImage = clone->convertToQImage(0);
     QVERIFY(resultImage == referenceImage);
 
 }
 
 void KisPaintDeviceTest::testTranslate()
 {
     QRect fillRect(0,0,64,64);
     quint8 fillPixel[4]={255,255,255,255};
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP device = new KisPaintDevice(cs);
 
     device->fill(fillRect.left(), fillRect.top(),
                  fillRect.width(), fillRect.height(),fillPixel);
 
     device->setX(-10);
     device->setY(10);
     QCOMPARE(device->exactBounds(), QRect(-10,10,64,64));
     QCOMPARE(device->extent(), QRect(-10,10,64,64));
 }
 
 void KisPaintDeviceTest::testOpacity()
 {
     // blt a semi-transparent image on a white paint device
 
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP fdev = new KisPaintDevice(cs);
     fdev->convertFromQImage(image, 0);
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->fill(0, 0, 640, 441, KoColor(Qt::white, cs).data());
     KisPainter gc(dev);
     gc.bitBlt(QPoint(0, 0), fdev, image.rect());
 
     QImage result = dev->convertToQImage(0, 0, 0, 640, 441);
     QImage checkResult(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent_result.png");
     QPoint errpoint;
 
     if (!TestUtil::compareQImages(errpoint, checkResult, result, 1)) {
         checkResult.save("kis_paint_device_test_test_blt_fixed_opactiy_expected.png");
         result.save("kis_paint_device_test_test_blt_fixed_opacity_result.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testExactBoundsWeirdNullAlphaCase()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     dev->fill(QRect(10,10,10,10), KoColor(Qt::white, cs));
 
     QCOMPARE(dev->exactBounds(), QRect(10,10,10,10));
 
     const quint8 weirdPixelData[4] = {0,10,0,0};
     KoColor weirdColor(weirdPixelData, cs);
     dev->setPixel(6,6,weirdColor);
 
     // such weird pixels should not change our opinion about
     // device's size
     QCOMPARE(dev->exactBounds(), QRect(10,10,10,10));
 }
 
 void KisPaintDeviceTest::benchmarkExactBoundsNullDefaultPixel()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     QRect fillRect(60,60, 1930, 1930);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QRect measuredRect;
 
     QBENCHMARK {
         // invalidate the cache
         dev->setDirty();
         measuredRect = dev->exactBounds();
     }
 
     QCOMPARE(measuredRect, fillRect);
 }
 
 void KisPaintDeviceTest::testAmortizedExactBounds()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     QRect fillRect(60,60, 833, 833);
     QRect extent(0,0,896,896);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QEXPECT_FAIL("", "Expecting the extent, we somehow get the fillrect", Continue);
     QCOMPARE(dev->exactBounds(), extent);
     QCOMPARE(dev->extent(), extent);
 
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 
     dev->setDirty();
     QEXPECT_FAIL("", "Expecting the fillRect, we somehow get the extent", Continue);
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 
     dev->setDirty();
     QCOMPARE(dev->exactBoundsAmortized(), extent);
 
     QTest::qSleep(1100);
     QEXPECT_FAIL("", "Expecting the fillRect, we somehow get the extent", Continue);
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 }
 
 void KisPaintDeviceTest::testNonDefaultPixelArea()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     KoColor defPixel(Qt::red, cs);
     dev->setDefaultPixel(defPixel);
 
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     QRect fillRect(10,11,18,14);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QCOMPARE(dev->nonDefaultPixelArea(), fillRect);
 
 
     // non-default pixel variant should also handle weird pixels
 
     const quint8 weirdPixelData[4] = {0,10,0,0};
     KoColor weirdColor(weirdPixelData, cs);
     dev->setPixel(100,100,weirdColor);
 
     // such weird pixels should not change our opinion about
     // device's size
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QCOMPARE(dev->nonDefaultPixelArea(), fillRect | QRect(100,100,1,1));
 }
 
 void KisPaintDeviceTest::testExactBoundsNonTransparent()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs, "merge test");
     KisPaintLayerSP layer = new KisPaintLayer(image, "bla", 125);
     KisPaintDeviceSP dev = layer->paintDevice();
 
     QVERIFY(dev);
 
     QRect imageRect(0,0,1000,1000);
 
     KoColor defPixel(Qt::red, cs);
     dev->setDefaultPixel(defPixel);
 
     QCOMPARE(dev->exactBounds(), imageRect);
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     KoColor fillPixel(Qt::white, cs);
 
     dev->fill(imageRect, KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), imageRect);
     QCOMPARE(dev->nonDefaultPixelArea(), imageRect);
 
     dev->fill(QRect(1000,0, 1, 1000), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,0,1001,1000));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,0,1001,1000));
 
     dev->fill(QRect(0,1000, 1000, 1), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,0,1001,1001));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,0,1001,1001));
 
     dev->fill(QRect(0,-1, 1000, 1), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,-1,1001,1002));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,-1,1001,1002));
 
     dev->fill(QRect(-1,0, 1, 1000), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(-1,-1,1002,1002));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(-1,-1,1002,1002));
 }
 
 KisPaintDeviceSP createWrapAroundPaintDevice(const KoColorSpace *cs)
 {
     struct TestingDefaultBounds : public KisDefaultBoundsBase {
         QRect bounds() const override {
             return QRect(0,0,20,20);
         }
         bool wrapAroundMode() const override {
             return true;
         }
         int currentLevelOfDetail() const override {
             return 0;
         }
         int currentTime() const override {
             return 0;
         }
         bool externalFrameActive() const override {
             return false;
         }
     };
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     KisDefaultBoundsBaseSP bounds = new TestingDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     return dev;
 }
 
 void checkReadWriteRoundTrip(KisPaintDeviceSP dev,
                              const QRect &rc)
 {
     KisPaintDeviceSP deviceCopy = new KisPaintDevice(*dev.data());
 
-    QRect readRect(10, 10, 20, 20);
     int bufSize = rc.width() * rc.height() * dev->pixelSize();
 
     QScopedArrayPointer<quint8> buf1(new quint8[bufSize]);
 
     deviceCopy->readBytes(buf1.data(), rc);
 
     deviceCopy->clear();
     QVERIFY(deviceCopy->extent().isEmpty());
 
 
     QScopedArrayPointer<quint8> buf2(new quint8[bufSize]);
     deviceCopy->writeBytes(buf1.data(), rc);
     deviceCopy->readBytes(buf2.data(), rc);
 
     QVERIFY(!memcmp(buf1.data(), buf2.data(), bufSize));
 }
 
 
 void KisPaintDeviceTest::testReadBytesWrapAround()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     const int pixelSize = dev->pixelSize();
 
     {
         QRect readRect(10, 10, 20, 20);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final1.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check weird case when the read rect is larger than wrap rect
         QRect readRect(10, 10, 30, 30);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final2.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // even more large
         QRect readRect(10, 10, 40, 40);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final3.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (32 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (33 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 32) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 33) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (32 + readRect.width() * 32) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (33 + readRect.width() * 33) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap rect contains the read rect entirely
         QRect readRect(1, 1, 10, 10);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final4.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap happens only on vertical side of the rect
         QRect readRect(1, 1, 29, 10);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final5.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (21 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (22 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap happens only on horizontal side of the rect
         QRect readRect(1, 1, 10, 29);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final6.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 21) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 22) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 }
 
 #include "kis_random_accessor_ng.h"
 
 void KisPaintDeviceTest::testWrappedRandomAccessor()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     const int pixelSize = dev->pixelSize();
 
     int x;
     int y;
 
     x = 3;
     y = 3;
     KisRandomAccessorSP dstIt = dev->createRandomAccessorNG(x, y);
 
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 23;
     y = 23;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 3;
     y = 23;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 23;
     y = 3;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = -17;
     y = 3;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 3;
     y = -17;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = -17;
     y = -17;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 }
 
 #include "kis_iterator_ng.h"
 
 static bool nextRowGeneral(KisHLineIteratorSP it, int y, const QRect &rc) {
     it->nextRow();
     return y < rc.height();
 }
 
 static bool nextRowGeneral(KisVLineIteratorSP it, int y, const QRect &rc) {
     it->nextColumn();
     return y < rc.width();
 }
 
 template <class T>
 bool checkXY(const QPoint &pt, const QPoint &realPt) {
     Q_UNUSED(pt);
     Q_UNUSED(realPt);
     return false;
 }
 
 template <>
 bool checkXY<KisHLineIteratorSP>(const QPoint &pt, const QPoint &realPt) {
     return pt == realPt;
 }
 
 template <>
 bool checkXY<KisVLineIteratorSP>(const QPoint &pt, const QPoint &realPt) {
     return pt.x() == realPt.y() && pt.y() == realPt.x();
 }
 #include <kis_wrapped_rect.h>
 template <class T>
 bool checkConseqPixels(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     Q_UNUSED(value);
     Q_UNUSED(pt);
     Q_UNUSED(wrappedRect);
     return false;
 }
 
 template <>
 bool checkConseqPixels<KisHLineIteratorSP>(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     int x = KisWrappedRect::xToWrappedX(pt.x(), wrappedRect.wrapRect());
     int borderX = wrappedRect.originalRect().x() + wrappedRect.wrapRect().width();
     int conseq = x >= borderX ? wrappedRect.wrapRect().right() - x + 1 : borderX - x;
     conseq = qMin(conseq, wrappedRect.originalRect().right() - pt.x() + 1);
 
     return value == conseq;
 }
 
 template <>
 bool checkConseqPixels<KisVLineIteratorSP>(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     Q_UNUSED(pt);
     Q_UNUSED(wrappedRect);
     return value == 1;
 }
 
 template <class IteratorSP>
 IteratorSP createIterator(KisPaintDeviceSP dev, const QRect &rc) {
     Q_UNUSED(dev);
     Q_UNUSED(rc);
     return 0;
 }
 
 template <>
 KisHLineIteratorSP createIterator(KisPaintDeviceSP dev,
                                   const QRect &rc) {
     return dev->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
 }
 
 template <>
 KisVLineIteratorSP createIterator(KisPaintDeviceSP dev,
                                   const QRect &rc) {
     return dev->createVLineIteratorNG(rc.x(), rc.y(), rc.height());
 }
 
 template <class IteratorSP>
 void testWrappedLineIterator(QString testName, const QRect &rect)
 {
     testName = QString("%1_%2_%3_%4_%5")
         .arg(testName)
         .arg(rect.x())
         .arg(rect.y())
         .arg(rect.width())
         .arg(rect.height());
 
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     // test rect fits the wrap rect in both dimensions
     IteratorSP it = createIterator<IteratorSP>(dev, rect);
 
     int y = 0;
     do {
         int x = 0;
         do {
             quint8 *data = it->rawData();
 
             data[0] = 10 * x;
             data[1] = 10 * y;
             data[2] = 0;
             data[3] = 255;
 
             x++;
         } while (it->nextPixel());
     } while (nextRowGeneral(it, ++y, rect));
 
     QRect rc = dev->defaultBounds()->bounds() | dev->exactBounds();
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
 
     QVERIFY(TestUtil::checkQImage(result, "paint_device_test", "wrapped_iterators", testName));
 }
 
 template <class IteratorSP>
 void testWrappedLineIterator(const QString &testName)
 {
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,20,20));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,10,20));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,20,10));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,10,10));
     testWrappedLineIterator<IteratorSP>(testName, QRect(0,0,20,20));
 }
 
 void KisPaintDeviceTest::testWrappedHLineIterator()
 {
     testWrappedLineIterator<KisHLineIteratorSP>("hline_iterator");
 }
 
 void KisPaintDeviceTest::testWrappedVLineIterator()
 {
     testWrappedLineIterator<KisVLineIteratorSP>("vline_iterator");
 }
 
 template <class IteratorSP>
 void testWrappedLineIteratorReadMoreThanBounds(QString testName)
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     // fill device with a gradient
     QRect bounds = dev->defaultBounds()->bounds();
     for (int y = bounds.y(); y < bounds.y() + bounds.height(); y++) {
         for (int x = bounds.x(); x < bounds.x() + bounds.width(); x++) {
             QColor c((10 * x) % 255, (10 * y) % 255, 0, 255);
             dev->setPixel(x, y, c);
         }
     }
 
     // test rect doesn't fit the wrap rect in both dimensions
     const QRect &rect(bounds.adjusted(-6,-6,8,8));
     KisRandomAccessorSP dstIt = dst->createRandomAccessorNG(rect.x(), rect.y());
     IteratorSP it = createIterator<IteratorSP>(dev, rect);
 
     for (int y = rect.y(); y < rect.y() + rect.height(); y++) {
         for (int x = rect.x(); x < rect.x() + rect.width(); x++) {
             quint8 *data = it->rawData();
 
             QVERIFY(checkConseqPixels<IteratorSP>(it->nConseqPixels(), QPoint(x, y), KisWrappedRect(rect, bounds)));
 
             dstIt->moveTo(x, y);
             memcpy(dstIt->rawData(), data, cs->pixelSize());
 
             QVERIFY(checkXY<IteratorSP>(QPoint(it->x(), it->y()), QPoint(x,y)));
 
             bool stepDone = it->nextPixel();
             QCOMPARE(stepDone, x < rect.x() + rect.width() - 1);
         }
         if (!nextRowGeneral(it, y, rect)) break;
     }
 
     testName = QString("%1_%2_%3_%4_%5")
         .arg(testName)
         .arg(rect.x())
         .arg(rect.y())
         .arg(rect.width())
         .arg(rect.height());
 
     QRect rc = rect;
     QImage result = dst->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QImage ref = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
 
     QVERIFY(TestUtil::checkQImage(result, "paint_device_test", "wrapped_iterators_huge", testName, 1));
 }
 
 void KisPaintDeviceTest::testWrappedHLineIteratorReadMoreThanBounds()
 {
     testWrappedLineIteratorReadMoreThanBounds<KisHLineIteratorSP>("hline_iterator");
 }
 
 void KisPaintDeviceTest::testWrappedVLineIteratorReadMoreThanBounds()
 {
     testWrappedLineIteratorReadMoreThanBounds<KisVLineIteratorSP>("vline_iterator");
 }
 
 void KisPaintDeviceTest::testMoveWrapAround()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     // QRect rc = dev->defaultBounds()->bounds();
 
     //dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height()).save("move0.png");
     QCOMPARE(dev->exactBounds(), QRect(3,3,16,16));
     dev->moveTo(QPoint(10,10));
     QCOMPARE(dev->exactBounds(), QRect(8,8,6,6));
     //dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height()).save("move1.png");
 
 }
 
 #include "kis_lock_free_cache.h"
 
 #define NUM_TYPES 3
 
 // high-concurrency
 #define NUM_CYCLES 500000
 #define NUM_THREADS 4
 
 
 struct TestingCache : KisLockFreeCache<int> {
     int calculateNewValue() const override {
         return m_realValue;
     }
 
     QAtomicInt m_realValue;
 };
 
 class CacheStressJob : public QRunnable
 {
 public:
     CacheStressJob(TestingCache &cache)
         : m_cache(cache),
           m_oldValue(0)
     {
     }
 
     void run() override {
         for(qint32 i = 0; i < NUM_CYCLES; i++) {
             qint32 type = i % NUM_TYPES;
 
             switch(type) {
             case 0:
                 m_cache.m_realValue.ref();
                 m_oldValue = m_cache.m_realValue;
                 m_cache.invalidate();
                 break;
             case 1:
             {
                 int newValue = m_cache.getValue();
                 Q_ASSERT(newValue >= m_oldValue);
                 Q_UNUSED(newValue);
             }
                 break;
             case 3:
                 QTest::qSleep(3);
                 break;
             }
         }
     }
 
 private:
     TestingCache &m_cache;
     int m_oldValue;
 };
 
 void KisPaintDeviceTest::testCacheState()
 {
     TestingCache cache;
 
     QList<CacheStressJob*> jobsList;
     CacheStressJob *job;
 
     for(qint32 i = 0; i < NUM_THREADS; i++) {
         //job = new CacheStressJob(value, cacheValue, cacheState);
         job = new CacheStressJob(cache);
         job->setAutoDelete(true);
         jobsList.append(job);
     }
 
     QThreadPool pool;
     pool.setMaxThreadCount(NUM_THREADS);
 
     Q_FOREACH (job, jobsList) {
         pool.start(job);
     }
 
     pool.waitForDone();
 }
 
 struct TestingLodDefaultBounds : public KisDefaultBoundsBase {
     TestingLodDefaultBounds(const QRect &bounds = QRect(0,0,100,100))
         : m_lod(0), m_bounds(bounds) {}
 
     QRect bounds() const override {
         return m_bounds;
     }
     bool wrapAroundMode() const override {
         return false;
     }
 
     int currentLevelOfDetail() const override {
         return m_lod;
     }
 
     int currentTime() const override {
         return 0;
     }
     bool externalFrameActive() const override {
         return false;
     }
 
     void testingSetLevelOfDetail(int lod) {
         m_lod = lod;
     }
 
 private:
     int m_lod;
     QRect m_bounds;
 };
 
 void fillGradientDevice(KisPaintDeviceSP dev, const QRect &rect, bool flat = false)
 {
     if (flat) {
         dev->fill(rect, KoColor(Qt::red, dev->colorSpace()));
     } else {
         // fill device with a gradient
         KisSequentialIterator it(dev, rect);
         while (it.nextPixel()) {
             QColor c((10 * it.x()) & 0xFF, (10 * it.y()) & 0xFF, 0, 255);
             KoColor color(c, dev->colorSpace());
             memcpy(it.rawData(), color.data(), dev->pixelSize());
         }
     }
 }
 #include "kis_lod_transform.h"
 void KisPaintDeviceTest::testLodTransform()
 {
     const int lod = 2; // round to 4
     KisLodTransform t(lod);
 
     QRect rc1(-16, -16, 8, 8);
     QRect rc2(-16, -16, 7, 7);
     QRect rc3(-15, -15, 7, 7);
 
     QCOMPARE(t.alignedRect(rc1, lod), rc1);
     QCOMPARE(t.alignedRect(rc2, lod), rc1);
     QCOMPARE(t.alignedRect(rc3, lod), rc1);
 }
 
 #include "krita_utils.h"
 void syncLodCache(KisPaintDeviceSP dev, int levelOfDetail)
 {
     KisPaintDevice::LodDataStruct* s = dev->createLodDataStruct(levelOfDetail);
 
     QRegion region = dev->regionForLodSyncing();
     Q_FOREACH(QRect rect2, KritaUtils::splitRegionIntoPatches(region, KritaUtils::optimalPatchSize())) {
         dev->updateLodDataStruct(s, rect2);
     }
 
     dev->uploadLodDataStruct(s);
 }
 
 void KisPaintDeviceTest::testLodDevice()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     // QRect rect = dev->defaultBounds()->bounds();
     // fillGradientDevice(dev, rect);
     fillGradientDevice(dev, QRect(50,50,30,30));
 
     QCOMPARE(dev->exactBounds(), QRect(50,50,30,30));
 
     QImage result;
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "initial"));
 
     bounds->testingSetLevelOfDetail(1);
     syncLodCache(dev, 1);
     QCOMPARE(dev->exactBounds(), QRect(25,25,15,15));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1"));
 
     bounds->testingSetLevelOfDetail(2);
     QCOMPARE(dev->exactBounds(), QRect(25,25,15,15));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1"));
 
     syncLodCache(dev, 2);
     QCOMPARE(dev->exactBounds(), QRect(12,12,8,8));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod2"));
 
     bounds->testingSetLevelOfDetail(0);
 
     dev->setX(20);
     dev->setY(10);
 
     bounds->testingSetLevelOfDetail(1);
     syncLodCache(dev, 1);
 
     QCOMPARE(dev->exactBounds(), QRect(35,30,15,15));
 
 
     qDebug() << ppVar(dev->exactBounds()) << ppVar(dev->x()) << ppVar(dev->y());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1-offset-6-14"));
 }
 
 void KisPaintDeviceTest::benchmarkLod1Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,6000,4000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(1);
         syncLodCache(dev, 1);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod2Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,6000,4000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(2);
         syncLodCache(dev, 2);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod3Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,3000,2000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(3);
         syncLodCache(dev, 3);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod4Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,3000,2000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(4);
         syncLodCache(dev, 4);
     }
 }
 
 #include "kis_keyframe_channel.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 #include "testing_timed_default_bounds.h"
 
 void KisPaintDeviceTest::testFramesLeaking()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data is kept separate
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add keyframe at position 10
     channel->addKeyframe(10);
 
     // two frames, m_data has a default empty value
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add keyframe at position 20
     channel->addKeyframe(20);
 
     // three frames, m_data is default, current frame is 0
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 3);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // switch to frame 10
     bounds->testingSetTime(10);
 
     // three frames, m_data is default, current frame is 10
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[1]);
     QCOMPARE(o.m_frames.size(), 3);
 
     // switch to frame 20
     bounds->testingSetTime(20);
 
     // three frames, m_data is default, current frame is 20
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[2]);
     QCOMPARE(o.m_frames.size(), 3);
 
     // switch to frame 15
     bounds->testingSetTime(15);
 
     // three frames, m_data is default, current frame is 10
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[1]);
     QCOMPARE(o.m_frames.size(), 3);
 
     KisKeyframeSP key;
 
     // deletion of frame 0 is forbidden
     key = channel->keyframeAt(0);
     QVERIFY(key);
     QVERIFY(channel->deleteKeyframe(key));
 
     // delete keyframe at position 11
     key = channel->activeKeyframeAt(11);
     QVERIFY(key);
     QCOMPARE(key->time(), 10);
     QVERIFY(channel->deleteKeyframe(key));
 
     // two frames, m_data is default, current frame is 0
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 2);
 
     // deletion of frame 0 is forbidden
     key = channel->activeKeyframeAt(11);
     QVERIFY(key);
     QCOMPARE(key->time(), 0);
     QVERIFY(channel->deleteKeyframe(key));
 
     // nothing changed
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 2);
 
     // delete keyframe at position 20
     key = channel->activeKeyframeAt(20);
     QVERIFY(key);
     QCOMPARE(key->time(), 20);
     QVERIFY(channel->deleteKeyframe(key));
 
     // one keyframe is left at position 0, m_data is default
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 1);
 
     // ensure all the objects in the list of all objects are unique
     QList<KisPaintDeviceData*> allObjects = i->testingGetDataObjectsList();
     QSet<KisPaintDeviceData*> uniqueObjects;
     Q_FOREACH (KisPaintDeviceData *obj, allObjects) {
         if (!obj) continue;
         QVERIFY(!uniqueObjects.contains(obj));
         uniqueObjects.insert(obj);
     }
 }
 
 void KisPaintDeviceTest::testFramesUndoRedo()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
     int frameId = -1;
     const int time = 1;
 
     channel->addKeyframe(time, &cmdAdd);
     frameId = channel->frameIdAt(time);
     //int frameId = i->createFrame(false, 0, QPoint(), &cmdAdd);
 
     QCOMPARE(frameId, 1);
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.undo();
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.redo();
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdRemove;
     KisKeyframeSP keyframe = channel->keyframeAt(time);
     QVERIFY(keyframe);
 
     channel->deleteKeyframe(keyframe, &cmdRemove);
 
     //i->deleteFrame(1, &cmdRemove);
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.redo();
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 }
 
 void KisPaintDeviceTest::testFramesUndoRedoWithChannel()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
 
     KisKeyframeSP frame = channel->addKeyframe(10, &cmdAdd);
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.undo();
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.redo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdRemove;
     channel->deleteKeyframe(frame, &cmdRemove);
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.redo();
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdMove;
     channel->moveKeyframe(frame, 12, &cmdMove);
 
     QVERIFY(!channel->keyframeAt(10));
     QVERIFY(channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdMove.undo();
 
     QVERIFY(channel->keyframeAt(10));
     QVERIFY(!channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdMove.redo();
 
     QVERIFY(!channel->keyframeAt(10));
     QVERIFY(channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 }
 
 void fillRect(KisPaintDeviceSP dev, int time, const QRect &rc, TestUtil::TestingTimedDefaultBounds *bounds)
 {
     KUndo2Command parentCommand;
     KisRasterKeyframeChannel *channel = dev->keyframeChannel();
     KisKeyframeSP frame = channel->addKeyframe(time, &parentCommand);
 
     const int oldTime = bounds->currentTime();
     bounds->testingSetTime(time);
 
     KoColor color(Qt::red, dev->colorSpace());
     dev->fill(rc, color);
 
     bounds->testingSetTime(oldTime);
 }
 
 bool checkRect(KisPaintDeviceSP dev, int time, const QRect &rc, TestUtil::TestingTimedDefaultBounds *bounds)
 {
     const int oldTime = bounds->currentTime();
     bounds->testingSetTime(time);
 
     bool result = dev->exactBounds() == rc;
 
     if (!result) {
         qDebug() << "Failed to check frame:" << ppVar(time) << ppVar(rc) << ppVar(dev->exactBounds());
     }
 
     bounds->testingSetTime(oldTime);
 
     return result;
 }
 
 void testCrossDeviceFrameCopyImpl(bool useChannel)
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev1 = new KisPaintDevice(cs);
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
 
     const KoColorSpace *cs3 = KoColorSpaceRegistry::instance()->rgb16();
     KisPaintDeviceSP dev3 = new KisPaintDevice(cs3);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev1->setDefaultBounds(bounds);
     dev2->setDefaultBounds(bounds);
     dev3->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel1 = dev1->createKeyframeChannel(KisKeyframeChannel::Content);
     KisPaintDeviceFramesInterface *i1 = dev1->framesInterface();
     QVERIFY(channel1);
     QVERIFY(i1);
 
     KisRasterKeyframeChannel *channel2 = dev2->createKeyframeChannel(KisKeyframeChannel::Content);
     KisPaintDeviceFramesInterface *i2 = dev2->framesInterface();
     QVERIFY(channel2);
     QVERIFY(i2);
 
     KisRasterKeyframeChannel *channel3 = dev3->createKeyframeChannel(KisKeyframeChannel::Content);
     KisPaintDeviceFramesInterface *i3 = dev3->framesInterface();
     QVERIFY(channel3);
     QVERIFY(i3);
 
     fillRect(dev1, 10, QRect(100,100,100,100), bounds);
     fillRect(dev2, 20, QRect(200,200,100,100), bounds);
     fillRect(dev3, 30, QRect(300,300,100,100), bounds);
 
     QCOMPARE(dev1->exactBounds(), QRect());
 
     const int dstFrameId1 = channel1->frameIdAt(10);
     const int srcFrameId2 = channel2->frameIdAt(20);
     const int srcFrameId3 = channel3->frameIdAt(30);
 
     KUndo2Command cmd1;
     if (!useChannel) {
         dev1->framesInterface()->uploadFrame(srcFrameId2, dstFrameId1, dev2);
     } else {
         KisKeyframeSP k = channel1->copyExternalKeyframe(channel2, 20, 10, &cmd1);
     }
 
     QCOMPARE(dev1->exactBounds(), QRect());
     QVERIFY(checkRect(dev1, 10, QRect(200,200,100,100), bounds));
 
     if (useChannel) {
         cmd1.undo();
         QVERIFY(checkRect(dev1, 10, QRect(100,100,100,100), bounds));
     }
 
     KUndo2Command cmd2;
     if (!useChannel) {
         dev1->framesInterface()->uploadFrame(srcFrameId3, dstFrameId1, dev3);
     } else {
         KisKeyframeSP k = channel1->copyExternalKeyframe(channel3, 30, 10, &cmd2);
     }
 
     QCOMPARE(dev1->exactBounds(), QRect());
     QVERIFY(checkRect(dev1, 10, QRect(300,300,100,100), bounds));
 
     if (useChannel) {
         cmd2.undo();
         QVERIFY(checkRect(dev1, 10, QRect(100,100,100,100), bounds));
     }
 }
 
 void KisPaintDeviceTest::testCrossDeviceFrameCopyDirect()
 {
     testCrossDeviceFrameCopyImpl(false);
 }
 
 void KisPaintDeviceTest::testCrossDeviceFrameCopyChannel()
 {
     testCrossDeviceFrameCopyImpl(true);
 }
 
 #include "kis_surrogate_undo_adapter.h"
 
 void KisPaintDeviceTest::testLazyFrameCreation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     bounds->testingSetTime(10);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisSurrogateUndoAdapter undoAdapter;
 
     {
         KisTransaction transaction1(dev);
         transaction1.commit(&undoAdapter);
     }
 
     QCOMPARE(i->frames().size(), 2);
 
     undoAdapter.undoAll();
 
     QCOMPARE(i->frames().size(), 1);
 
     undoAdapter.redoAll();
 
     QCOMPARE(i->frames().size(), 2);
 }
 
 void KisPaintDeviceTest::testCopyPaintDeviceWithFrames()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
     QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
 
     KisKeyframeSP frame = channel->addKeyframe(10, &cmdAdd);
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
     QVERIFY(o.m_data); // m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
 
     KisPaintDeviceSP newDev = new KisPaintDevice(*dev, KritaUtils::CopyAllFrames);
 
     QVERIFY(channel->keyframeAt(0));
     QVERIFY(channel->keyframeAt(10));
 }
 
 #include <boost/accumulators/accumulators.hpp>
 #include <boost/accumulators/statistics/stats.hpp>
 #include <boost/accumulators/statistics/variance.hpp>
 #include <boost/accumulators/statistics/min.hpp>
 #include <boost/accumulators/statistics/max.hpp>
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/uniform_smallint.hpp>
 
 #include "KoCompositeOpRegistry.h"
 
 
 using namespace boost::accumulators;
 
 accumulator_set<qreal, stats<tag::variance, tag::max, tag::min> > accum;
 
 
 void KisPaintDeviceTest::testCompositionAssociativity()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
 
     qsrand(500);
 
     boost::mt11213b _rnd0(qrand());
     boost::mt11213b _rnd1(qrand());
     boost::mt11213b _rnd2(qrand());
     boost::mt11213b _rnd3(qrand());
 
     boost::uniform_smallint<int> rnd0(0, 255);
     boost::uniform_smallint<int> rnd1(0, 255);
     boost::uniform_smallint<int> rnd2(0, 255);
     boost::uniform_smallint<int> rnd3(0, 255);
 
     QList<KoCompositeOp*> allCompositeOps = cs->compositeOps();
 
     Q_FOREACH (const KoCompositeOp *op, allCompositeOps) {
 
         accumulator_set<qreal, stats<tag::variance, tag::max, tag::min> > accum;
 
         const int numIterations = 10000;
 
         for (int j = 0; j < numIterations; j++) {
             KoColor c1(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             KoColor c2(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             KoColor c3(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             //KoColor c4(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             //KoColor c5(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
 
             KoColor r1(QColor(Qt::transparent), cs);
             KoColor r2(QColor(Qt::transparent), cs);
             KoColor r3(QColor(Qt::transparent), cs);
 
             op->composite(r1.data(), 0, c1.data(), 0, 0,0, 1,1, 255);
             op->composite(r1.data(), 0, c2.data(), 0, 0,0, 1,1, 255);
             op->composite(r1.data(), 0, c3.data(), 0, 0,0, 1,1, 255);
             //op->composite(r1.data(), 0, c4.data(), 0, 0,0, 1,1, 255);
             //op->composite(r1.data(), 0, c5.data(), 0, 0,0, 1,1, 255);
 
             op->composite(r3.data(), 0, c2.data(), 0, 0,0, 1,1, 255);
             op->composite(r3.data(), 0, c3.data(), 0, 0,0, 1,1, 255);
             //op->composite(r3.data(), 0, c4.data(), 0, 0,0, 1,1, 255);
             //op->composite(r3.data(), 0, c5.data(), 0, 0,0, 1,1, 255);
 
             op->composite(r2.data(), 0, c1.data(), 0, 0,0, 1,1, 255);
             op->composite(r2.data(), 0, r3.data(), 0, 0,0, 1,1, 255);
 
             const quint8 *p1 = r1.data();
             const quint8 *p2 = r2.data();
 
             if (memcmp(p1, p2, 4) != 0) {
                 for (int i = 0; i < 4; i++) {
                     accum(qAbs(p1[i] - p2[i]));
                 }
             }
 
         }
 
         qDebug("Errors for op %25s err rate %7.2f var %7.2f max %7.2f",
                op->id().toLatin1().data(),
                (qreal(count(accum)) / (4 * numIterations)),
                variance(accum),
                count(accum) > 0 ? (max)(accum) : 0);
     }
 }
 
 #include <kundo2stack.h>
 
 struct FillWorker : public QRunnable
 {
     FillWorker(KisPaintDeviceSP dev, const QRect &fillRect, bool clear)
         : m_dev(dev), m_fillRect(fillRect), m_clear(clear)
     {
         setAutoDelete(true);
     }
 
     void run() {
         if (m_clear) {
             m_dev->clear(m_fillRect);
         } else {
             const KoColor fillColor(Qt::red, m_dev->colorSpace());
             const int pixelSize = m_dev->colorSpace()->pixelSize();
 
             KisSequentialIterator it(m_dev, m_fillRect);
             while (it.nextPixel()) {
                 memcpy(it.rawData(), fillColor.data(), pixelSize);
             }
         }
     }
 
 private:
     KisPaintDeviceSP m_dev;
     QRect m_fillRect;
     bool m_clear;
 };
 
 #ifdef Q_OS_LINUX
 #include <malloc.h>
 #endif
 
 void KisPaintDeviceTest::stressTestMemoryFragmentation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     KUndo2Stack undoStack;
 
 #ifdef LIMIT_LONG_TESTS
     const int numCycles = 3;
     undoStack.setUndoLimit(1);
 #else
     const int numCycles = 200;
     undoStack.setUndoLimit(10);
 #endif
 
     const int numThreads = 16;
     const int desiredWidth = 10000;
     const int patchSize = 81;
     const int numSidePatches = desiredWidth / patchSize;
 
     QThreadPool pool;
     pool.setMaxThreadCount(numThreads);
 
 
     for (int i = 0; i < numCycles; i++) {
         qDebug() << "iteration"<< i;
         // KisTransaction t(dev);
 
         for (int y = 0; y < numSidePatches; y++) {
             for (int x = 0; x < numSidePatches; x++) {
                 const QRect workerRect(x * patchSize, y * patchSize, patchSize, patchSize);
                 pool.start(new FillWorker(dev, workerRect, (i + x + y) & 0x1));
             }
         }
 
         pool.waitForDone();
         // undoStack.push(t.endAndTake());
 
         qDebug() << "Iteration:" << i;
 
 #ifdef Q_OS_LINUX
         struct mallinfo info = mallinfo();
         qDebug() << "Allocated on heap:" << (info.arena >> 20) << "MiB";
         qDebug() << "Mmaped regions:" << info.hblks << (info.hblkhd >> 20) << "MiB";
         qDebug() << "Free fastbin chunks:" << info.smblks << (info.fsmblks >> 10)  << "KiB";
         qDebug() << "Allocated in ordinary blocks" << (info.uordblks >> 20) << "MiB";
         qDebug() << "Free in ordinary blockes" << info.ordblks << (info.fordblks >> 20) << "MiB";
 #endif
         qDebug() << "========================================";
     }
 
     undoStack.clear();
 }
 
 KISTEST_MAIN(KisPaintDeviceTest)
diff --git a/libs/image/tiles3/tests/kis_tiled_data_manager_test.cpp b/libs/image/tiles3/tests/kis_tiled_data_manager_test.cpp
index 96c399a7ec..4820f3b862 100644
--- a/libs/image/tiles3/tests/kis_tiled_data_manager_test.cpp
+++ b/libs/image/tiles3/tests/kis_tiled_data_manager_test.cpp
@@ -1,947 +1,946 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@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_tiled_data_manager_test.h"
 #include <QTest>
 
 #include "tiles3/kis_tiled_data_manager.h"
 
 #include "tiles_test_utils.h"
 #include "config-limit-long-tests.h"
 
 bool KisTiledDataManagerTest::checkHole(quint8* buffer,
                                         quint8 holeColor, QRect holeRect,
                                         quint8 backgroundColor, QRect backgroundRect)
 {
     for(qint32 y = backgroundRect.y(); y <= backgroundRect.bottom(); y++) {
         for(qint32 x = backgroundRect.x(); x <= backgroundRect.right(); x++) {
             quint8 expectedColor = holeRect.contains(x,y) ? holeColor : backgroundColor;
 
             if(*buffer != expectedColor) {
                 qDebug() << "Expected" << expectedColor << "but found" << *buffer;
                 return false;
             }
 
             buffer++;
         }
     }
     return true;
 }
 
 bool KisTiledDataManagerTest::checkTilesShared(KisTiledDataManager *srcDM,
                                                KisTiledDataManager *dstDM,
                                                bool takeOldSrc,
                                                bool takeOldDst,
                                                QRect tilesRect)
 {
     for(qint32 row = tilesRect.y(); row <= tilesRect.bottom(); row++) {
         for(qint32 col = tilesRect.x(); col <= tilesRect.right(); col++) {
             KisTileSP srcTile = takeOldSrc ? srcDM->getOldTile(col, row)
                 : srcDM->getTile(col, row, false);
             KisTileSP dstTile = takeOldDst ? dstDM->getOldTile(col, row)
                 : dstDM->getTile(col, row, false);
 
             if(srcTile->tileData() != dstTile->tileData()) {
                 qDebug() << "Expected tile data (" << col << row << ")"
                          << srcTile->extent()
                          << srcTile->tileData()
                          << "but found" << dstTile->tileData();
                 qDebug() << "Expected" << srcTile->data()[0] << "but found" << dstTile->data()[0];
                 return false;
             }
         }
     }
     return true;
 }
 
 bool KisTiledDataManagerTest::checkTilesNotShared(KisTiledDataManager *srcDM,
                                                   KisTiledDataManager *dstDM,
                                                   bool takeOldSrc,
                                                   bool takeOldDst,
                                                   QRect tilesRect)
 {
     for(qint32 row = tilesRect.y(); row <= tilesRect.bottom(); row++) {
         for(qint32 col = tilesRect.x(); col <= tilesRect.right(); col++) {
             KisTileSP srcTile = takeOldSrc ? srcDM->getOldTile(col, row)
                 : srcDM->getTile(col, row, false);
             KisTileSP dstTile = takeOldDst ? dstDM->getOldTile(col, row)
                 : dstDM->getTile(col, row, false);
 
             if(srcTile->tileData() == dstTile->tileData()) {
                 qDebug() << "Expected tiles not be shared:"<< srcTile->extent();
                 return false;
             }
         }
     }
     return true;
 }
 
 void KisTiledDataManagerTest::testUndoingNewTiles()
 {
     // "growing extent bug"
 
     const QRect nullRect(qint32_MAX,qint32_MAX,0,0);
 
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
 
     KisTileSP emptyTile = srcDM.getTile(0, 0, false);
 
     QCOMPARE(srcDM.extent(), nullRect);
 
     KisMementoSP memento0 = srcDM.getMemento();
     KisTileSP createdTile = srcDM.getTile(0, 0, true);
     srcDM.commit();
 
     QCOMPARE(srcDM.extent(), QRect(0,0,64,64));
 
     srcDM.rollback(memento0);
     QCOMPARE(srcDM.extent(), nullRect);
 }
 
 void KisTiledDataManagerTest::testPurgedAndEmptyTransactions()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
 
     QRect rect(0,0,512,512);
     QRect clearRect1(50,50,100,100);
     QRect clearRect2(150,50,100,100);
 
     quint8 *buffer = new quint8[rect.width()*rect.height()];
 
     // purged transaction
 
     KisMementoSP memento0 = srcDM.getMemento();
     srcDM.clear(clearRect1, &oddPixel1);
     srcDM.purgeHistory(memento0);
     memento0 = 0;
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1,
                       defaultPixel, rect));
 
     // one more purged transaction
 
     KisMementoSP memento1 = srcDM.getMemento();
     srcDM.clear(clearRect2, &oddPixel1);
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1 | clearRect2,
                       defaultPixel, rect));
 
     srcDM.purgeHistory(memento1);
     memento1 = 0;
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1 | clearRect2,
                       defaultPixel, rect));
 
     // empty one
 
     KisMementoSP memento2 = srcDM.getMemento();
     srcDM.commit();
     srcDM.rollback(memento2);
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1 | clearRect2,
                       defaultPixel, rect));
 
 
     // now check that everything works still
 
     KisMementoSP memento3 = srcDM.getMemento();
     srcDM.setExtent(clearRect2);
     srcDM.commit();
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect2,
                       defaultPixel, rect));
 
     srcDM.rollback(memento3);
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1 | clearRect2,
                       defaultPixel, rect));
 
 
 }
 void KisTiledDataManagerTest::testUnversionedBitBlt()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
 
     QRect rect(0,0,512,512);
     QRect cloneRect(81,80,250,250);
     QRect tilesRect(2,2,3,3);
 
     srcDM.clear(rect, &oddPixel1);
     dstDM.clear(rect, &oddPixel2);
 
     dstDM.bitBlt(&srcDM, cloneRect);
 
     quint8 *buffer = new quint8[rect.width()*rect.height()];
 
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
 
     QVERIFY(checkHole(buffer, oddPixel1, cloneRect,
                       oddPixel2, rect));
 
     delete[] buffer;
 
     // Test whether tiles became shared
     QVERIFY(checkTilesShared(&srcDM, &dstDM, false, false, tilesRect));
 }
 
 void KisTiledDataManagerTest::testVersionedBitBlt()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM1(1, &defaultPixel);
     KisTiledDataManager srcDM2(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
     quint8 oddPixel3 = 130;
 
     quint8 oddPixel4 = 131;
 
     QRect rect(0,0,512,512);
     QRect cloneRect(81,80,250,250);
     QRect tilesRect(2,2,3,3);
 
 
     KisMementoSP memento1 = srcDM1.getMemento();
     srcDM1.clear(rect, &oddPixel1);
 
     srcDM2.clear(rect, &oddPixel2);
     dstDM.clear(rect, &oddPixel3);
 
     KisMementoSP memento2 = dstDM.getMemento();
     dstDM.bitBlt(&srcDM1, cloneRect);
 
     QVERIFY(checkTilesShared(&srcDM1, &dstDM, false, false, tilesRect));
     QVERIFY(checkTilesNotShared(&srcDM1, &srcDM1, true, false, tilesRect));
     QVERIFY(checkTilesNotShared(&dstDM, &dstDM, true, false, tilesRect));
 
     dstDM.commit();
     QVERIFY(checkTilesShared(&dstDM, &dstDM, true, false, tilesRect));
 
     KisMementoSP memento3 = srcDM2.getMemento();
     srcDM2.clear(rect, &oddPixel4);
 
     KisMementoSP memento4 = dstDM.getMemento();
     dstDM.bitBlt(&srcDM2, cloneRect);
 
     QVERIFY(checkTilesShared(&srcDM2, &dstDM, false, false, tilesRect));
     QVERIFY(checkTilesNotShared(&srcDM2, &srcDM2, true, false, tilesRect));
     QVERIFY(checkTilesNotShared(&dstDM, &dstDM, true, false, tilesRect));
 
     dstDM.commit();
     QVERIFY(checkTilesShared(&dstDM, &dstDM, true, false, tilesRect));
 
     dstDM.rollback(memento4);
     QVERIFY(checkTilesShared(&srcDM1, &dstDM, false, false, tilesRect));
     QVERIFY(checkTilesShared(&dstDM, &dstDM, true, false, tilesRect));
     QVERIFY(checkTilesNotShared(&srcDM1, &srcDM1, true, false, tilesRect));
 
     dstDM.rollforward(memento4);
     QVERIFY(checkTilesShared(&srcDM2, &dstDM, false, false, tilesRect));
     QVERIFY(checkTilesShared(&dstDM, &dstDM, true, false, tilesRect));
     QVERIFY(checkTilesNotShared(&srcDM1, &srcDM1, true, false, tilesRect));
 }
 
 void KisTiledDataManagerTest::testBitBltOldData()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
 
     QRect rect(0,0,512,512);
     QRect cloneRect(81,80,250,250);
-    QRect tilesRect(2,2,3,3);
 
     quint8 *buffer = new quint8[rect.width()*rect.height()];
 
     KisMementoSP memento1 = srcDM.getMemento();
     srcDM.clear(rect, &oddPixel1);
     srcDM.commit();
 
     dstDM.bitBltOldData(&srcDM, cloneRect);
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, cloneRect,
                       defaultPixel, rect));
 
     KisMementoSP memento2 = srcDM.getMemento();
     srcDM.clear(rect, &oddPixel2);
     dstDM.bitBltOldData(&srcDM, cloneRect);
     srcDM.commit();
 
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, cloneRect,
                       defaultPixel, rect));
 
     delete[] buffer;
 }
 
 void KisTiledDataManagerTest::testBitBltRough()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
     quint8 oddPixel3 = 130;
 
     QRect rect(0,0,512,512);
     QRect cloneRect(81,80,250,250);
     QRect actualCloneRect(64,64,320,320);
     QRect tilesRect(1,1,4,4);
 
     srcDM.clear(rect, &oddPixel1);
     dstDM.clear(rect, &oddPixel2);
 
     dstDM.bitBltRough(&srcDM, cloneRect);
 
     quint8 *buffer = new quint8[rect.width()*rect.height()];
 
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
 
     QVERIFY(checkHole(buffer, oddPixel1, actualCloneRect,
                       oddPixel2, rect));
 
     // Test whether tiles became shared
     QVERIFY(checkTilesShared(&srcDM, &dstDM, false, false, tilesRect));
 
     // check bitBltRoughOldData
     KisMementoSP memento1 = srcDM.getMemento();
     srcDM.clear(rect, &oddPixel3);
     dstDM.bitBltRoughOldData(&srcDM, cloneRect);
     srcDM.commit();
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, actualCloneRect,
                       oddPixel2, rect));
 
     delete[] buffer;
 }
 
 void KisTiledDataManagerTest::testTransactions()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
     quint8 oddPixel3 = 130;
 
     KisTileSP tile00;
     KisTileSP oldTile00;
 
     // Create a named transaction: versioning is enabled
     KisMementoSP memento1 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel1);
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     // Create an anonymous transaction: versioning is disabled
     dm.commit();
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel1, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     dm.clear(0, 0, 64, 64, &oddPixel2);
 
     // Versioning is disabled, i said! >:)
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel2, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     // And the last round: named transaction:
     KisMementoSP memento2 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel3);
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel3, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
 }
 
 void KisTiledDataManagerTest::testPurgeHistory()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
     quint8 oddPixel3 = 130;
     quint8 oddPixel4 = 131;
 
     KisMementoSP memento1 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel1);
     dm.commit();
 
     KisMementoSP memento2 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel2);
 
     KisTileSP tile00;
     KisTileSP oldTile00;
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel2, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel1, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     dm.purgeHistory(memento1);
 
     /**
      * Nothing nas changed in the visible state of the data manager
      */
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel2, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel1, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     dm.commit();
 
     dm.purgeHistory(memento2);
 
     /**
      * We've removed all the history of the device, so it
      * became "unversioned".
      * NOTE: the return value for getOldTile() when there is no
      * history present is a subject for change
      */
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel2, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     /**
      * Just test we won't crash when the memento is not
      * present in history anymore
      */
 
     KisMementoSP memento3 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel3);
     dm.commit();
 
     KisMementoSP memento4 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel4);
     dm.commit();
 
     dm.rollback(memento4);
 
     dm.purgeHistory(memento3);
     dm.purgeHistory(memento4);
 }
 
 void KisTiledDataManagerTest::testUndoSetDefaultPixel()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
 
     QRect fillRect(0,0,64,64);
 
     KisTileSP tile00;
     KisTileSP tile10;
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(defaultPixel, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     KisMementoSP memento1 = dm.getMemento();
     dm.clear(fillRect, &oddPixel1);
     dm.commit();
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     KisMementoSP memento2 = dm.getMemento();
     dm.setDefaultPixel(&oddPixel2);
     dm.commit();
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, tile10->data(), TILESIZE));
 
     dm.rollback(memento2);
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     dm.rollback(memento1);
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(defaultPixel, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     dm.rollforward(memento1);
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     dm.rollforward(memento2);
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, tile10->data(), TILESIZE));
 }
 
 //#include <valgrind/callgrind.h>
 
 void KisTiledDataManagerTest::benchmarkReadOnlyTileLazy()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
 
     /*
      * See KisTileHashTableTraits2 for more details
      */
 
     const qint32 numTilesToTest = 0x7fff;
 
     //CALLGRIND_START_INSTRUMENTATION;
 
     QBENCHMARK_ONCE {
         for(qint32 i = 0; i < numTilesToTest; i++) {
             KisTileSP tile = dm.getTile(i, i, false);
         }
     }
 
     //CALLGRIND_STOP_INSTRUMENTATION;
 }
 
 class KisSimpleClass : public KisShared
 {
     qint64 m_int;
 public:
     KisSimpleClass() {
         Q_UNUSED(m_int);
     }
 };
 
 typedef KisSharedPtr<KisSimpleClass> KisSimpleClassSP;
 void KisTiledDataManagerTest::benchmarkSharedPointers()
 {
     const qint32 numIterations = 2 * 1000000;
 
     //CALLGRIND_START_INSTRUMENTATION;
 
     QBENCHMARK_ONCE {
         for(qint32 i = 0; i < numIterations; i++) {
             KisSimpleClassSP pointer = new KisSimpleClass;
             pointer = 0;
         }
     }
 
     //CALLGRIND_STOP_INSTRUMENTATION;
 }
 
 void KisTiledDataManagerTest::benchmarkCOWImpl()
 {
     const int pixelSize = 8;
     quint8 defaultPixel[pixelSize];
     memset(defaultPixel, 1, pixelSize);
 
     KisTiledDataManager dm(pixelSize, defaultPixel);
 
 
     KisMementoSP memento1 = dm.getMemento();
 
     /**
      * Imagine a regular image of 4096x2048 pixels
      * (64x32 tiles)
      */
     for (int i = 0; i < 32; i++) {
         for (int j = 0; j < 64; j++) {
             KisTileSP tile = dm.getTile(j, i, true);
             tile->lockForWrite();
             tile->unlockForWrite();
         }
     }
 
     dm.commit();
 
     QTest::qSleep(200);
 
     KisMementoSP memento2 = dm.getMemento();
     QTest::qSleep(200);
     QBENCHMARK_ONCE {
 
         for (int i = 0; i < 32; i++) {
             for (int j = 0; j < 64; j++) {
                 KisTileSP tile = dm.getTile(j, i, true);
                 tile->lockForWrite();
                 tile->unlockForWrite();
             }
         }
 
     }
     dm.commit();
 }
 
 void KisTiledDataManagerTest::benchmarkCOWNoPooler()
 {
     KisTileDataStore::instance()->testingSuspendPooler();
     QTest::qSleep(200);
 
     benchmarkCOWImpl();
 
     KisTileDataStore::instance()->testingResumePooler();
     QTest::qSleep(200);
 }
 
 void KisTiledDataManagerTest::benchmarkCOWWithPooler()
 {
     benchmarkCOWImpl();
 }
 
 /******************* Stress job ***********************/
 
 #ifdef LIMIT_LONG_TESTS
 #define NUM_CYCLES 10000
 #else
 #define NUM_CYCLES 100000
 #endif
 
 #define NUM_TYPES 12
 
 #define TILE_DIMENSION 64
 
 
 /**
  * The data manager has partial guarantees of reentrancy. That is
  * you can call any arbitrary number of methods concurrently as long
  * as their access areas do not intersect.
  *
  * Though the rule can be quite tricky -- some of the methods always
  * use entire image as their access area, so they cannot be called
  * concurrently in any circumstances.
  * The examples are: clear(), commit(), rollback() and etc...
  */
 
 #define run_exclusive(lock, _i) for(_i = 0, (lock).lockForWrite(); _i < 1; _i++, (lock).unlock())
 #define run_concurrent(lock, _i) for(_i = 0, (lock).lockForRead(); _i < 1; _i++, (lock).unlock())
 //#define run_exclusive(lock, _i) while(0)
 //#define run_concurrent(lock, _i) while(0)
 
 
 class KisStressJob : public QRunnable
 {
 public:
     KisStressJob(KisTiledDataManager &dataManager, QRect rect, QReadWriteLock &_lock)
         : m_accessRect(rect), dm(dataManager), lock(_lock)
     {
     }
 
     void run() override {
         qsrand(QTime::currentTime().msec());
         for(qint32 i = 0; i < NUM_CYCLES; i++) {
             qint32 type = qrand() % NUM_TYPES;
 
             qint32 t;
 
             switch(type) {
             case 0:
                 run_concurrent(lock,t) {
                     quint8 *buf;
                     buf = new quint8[dm.pixelSize()];
                     memcpy(buf, dm.defaultPixel(), dm.pixelSize());
                     dm.setDefaultPixel(buf);
                     delete[] buf;
                 }
                 break;
             case 1:
             case 2:
                 run_concurrent(lock,t) {
                     KisTileSP tile;
 
                     tile = dm.getTile(m_accessRect.x() / TILE_DIMENSION,
                                       m_accessRect.y() / TILE_DIMENSION, false);
                     tile->lockForRead();
                     tile->unlockForRead();
                     tile = dm.getTile(m_accessRect.x() / TILE_DIMENSION,
                                       m_accessRect.y() / TILE_DIMENSION, true);
                     tile->lockForWrite();
                     tile->unlockForWrite();
 
                     tile = dm.getOldTile(m_accessRect.x() / TILE_DIMENSION,
                                          m_accessRect.y() / TILE_DIMENSION);
                     tile->lockForRead();
                     tile->unlockForRead();
                 }
                 break;
             case 3:
                 run_concurrent(lock,t) {
                     QRect newRect = dm.extent();
 		    Q_UNUSED(newRect);
                 }
                 break;
             case 4:
                 run_concurrent(lock,t) {
                     dm.clear(m_accessRect.x(), m_accessRect.y(),
                              m_accessRect.width(), m_accessRect.height(), 4);
                 }
                 break;
             case 5:
                 run_concurrent(lock,t) {
                     quint8 *buf;
 
                     buf = new quint8[m_accessRect.width() * m_accessRect.height() *
                                      dm.pixelSize()];
                     dm.readBytes(buf, m_accessRect.x(), m_accessRect.y(),
                                  m_accessRect.width(), m_accessRect.height());
                     dm.writeBytes(buf, m_accessRect.x(), m_accessRect.y(),
                                   m_accessRect.width(), m_accessRect.height());
                     delete[] buf;
                     }
                 break;
             case 6:
                 run_concurrent(lock,t) {
                     quint8 oddPixel = 13;
                     KisTiledDataManager srcDM(1, &oddPixel);
                     dm.bitBlt(&srcDM, m_accessRect);
                 }
                 break;
             case 7:
             case 8:
                 run_exclusive(lock,t) {
                     m_memento = dm.getMemento();
                     dm.clear(m_accessRect.x(), m_accessRect.y(),
                              m_accessRect.width(), m_accessRect.height(), 2);
                     dm.commit();
 
                     dm.rollback(m_memento);
                     dm.rollforward(m_memento);
 
                     dm.purgeHistory(m_memento);
                     m_memento = 0;
                 }
                 break;
             case 9:
                 run_exclusive(lock,t) {
                     bool b = dm.hasCurrentMemento();
                     Q_UNUSED(b);
                 }
                 break;
             case 10:
                 run_exclusive(lock,t) {
                     dm.clear();
                 }
                 break;
             case 11:
                 run_exclusive(lock,t) {
                     dm.setExtent(m_accessRect);
                 }
                 break;
             }
         }
     }
 
 private:
     KisMementoSP m_memento;
     QRect m_accessRect;
     KisTiledDataManager &dm;
     QReadWriteLock &lock;
 };
 
 void KisTiledDataManagerTest::stressTest()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
     QReadWriteLock lock;
 
 #ifdef LIMIT_LONG_TESTS
     const int numThreads = 8;
     const int numWorkers = 8;
 #else
     const int numThreads = 16;
     const int numWorkers = 48;
 #endif
 
     QThreadPool pool;
     pool.setMaxThreadCount(numThreads);
 
     QRect accessRect(0,0,512,512);
     for(qint32 i = 0; i < numWorkers; i++) {
         KisStressJob *job = new KisStressJob(dm, accessRect, lock);
         pool.start(job);
         accessRect.translate(512, 0);
     }
     pool.waitForDone();
 }
 
 template <typename Func>
 void applyToRect(const QRect &rc, Func func) {
     for (int y = rc.y(); y < rc.y() + rc.height(); y += KisTileData::HEIGHT) {
         for (int x = rc.x(); x < rc.x() + rc.width(); x += KisTileData::WIDTH) {
             const int col = x / KisTileData::WIDTH;
             const int row = y / KisTileData::HEIGHT;
 
             func(col, row);
         }
     }
 }
 
 
 class LazyCopyingStressJob : public QRunnable
 {
 public:
     LazyCopyingStressJob(KisTiledDataManager &dataManager,
                          const QRect &rect,
                          QReadWriteLock &dmExclusiveLock,
                          QReadWriteLock &tileExclusiveLock,
                          int numCycles,
                          bool isWriter)
         : m_accessRect(rect),
           dm(dataManager),
           m_dmExclusiveLock(dmExclusiveLock),
           m_tileExclusiveLock(tileExclusiveLock),
           m_numCycles(numCycles),
           m_isWriter(isWriter)
     {
     }
 
     void run() override {
         for(qint32 i = 0; i < m_numCycles; i++) {
 
             //const int epoch = i % 100;
             int t;
 
             if (m_isWriter && 0) {
 
             } else {
                 const bool shouldClear = i % 5 <= 1; // 40% of requests are clears
                 const bool shouldWrite = i % 5 <= 3; // other 40% of requests are writes
 
                 run_concurrent(m_dmExclusiveLock, t) {
                     if (shouldClear) {
                         QWriteLocker locker(&m_tileExclusiveLock);
                         dm.clear(m_accessRect, 4);
                     } else {
                         auto readFunc = [this] (int col, int row) {
                             KisTileSP tile = dm.getTile(col, row, false);
                             tile->lockForRead();
                             tile->unlockForRead();
                         };
 
                         auto writeFunc = [this] (int col, int row) {
                             KisTileSP tile = dm.getTile(col, row, true);
                             tile->lockForWrite();
                             tile->unlockForWrite();
                         };
 
                         auto readOldFunc = [this] (int col, int row) {
                             KisTileSP tile = dm.getOldTile(col, row);
                             tile->lockForRead();
                             tile->unlockForRead();
                         };
 
                         applyToRect(m_accessRect, readFunc);
                         if (shouldWrite) {
                             QReadLocker locker(&m_tileExclusiveLock);
                             applyToRect(m_accessRect, writeFunc);
                         }
                         applyToRect(m_accessRect, readOldFunc);
                     }
                 }
             }
         }
     }
 
 private:
     KisMementoSP m_memento;
     QRect m_accessRect;
     KisTiledDataManager &dm;
     QReadWriteLock &m_dmExclusiveLock;
     QReadWriteLock &m_tileExclusiveLock;
     const int m_numCycles;
     const bool m_isWriter;
 };
 
 void KisTiledDataManagerTest::stressTestLazyCopying()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
     QReadWriteLock dmLock;
     QReadWriteLock tileLock;
 
 #ifdef LIMIT_LONG_TESTS
     const int numCycles = 10000;
     const int numThreads = 8;
     const int numWorkers = 8;
 #else
     const int numThreads = 16;
     const int numWorkers = 32;
     const int numCycles = 100000;
 #endif
 
     QThreadPool pool;
     pool.setMaxThreadCount(numThreads);
 
     const QRect accessRect(0,0,512,256);
     for(qint32 i = 0; i < numWorkers; i++) {
         const bool isWriter = i == 0;
         LazyCopyingStressJob *job = new LazyCopyingStressJob(dm, accessRect,
                                                              dmLock, tileLock,
                                                              numCycles, isWriter);
         pool.start(job);
     }
     pool.waitForDone();
 }
 
 QTEST_MAIN(KisTiledDataManagerTest)