diff --git a/libs/flake/tests/TestSvgParser.cpp b/libs/flake/tests/TestSvgParser.cpp
index 1592fae5e7..05b9f2f332 100644
--- a/libs/flake/tests/TestSvgParser.cpp
+++ b/libs/flake/tests/TestSvgParser.cpp
@@ -1,3218 +1,3219 @@
 /*
  *  Copyright (c) 2016 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 "TestSvgParser.h"
 
 
 #include <QTest>
 #include <svg/SvgUtil.h>
 #include <KoShapeStrokeModel.h>
 
 
 #include "SvgParserTestingUtils.h"
 
 #include "../../sdk/tests/qimage_test_util.h"
 
 #ifdef USE_ROUND_TRIP
 #include "SvgWriter.h"
 #include <QBuffer>
 #include <QDomDocument>
 #endif
 
 
 void TestSvgParser::testUnitPx()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), kisGrowRect(QRectF(0,0,10,20), 0.5));
     QCOMPARE(shape->absoluteTransformation(0), QTransform());
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(0,0));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(10,20));
 }
 
 void TestSvgParser::testUnitPxResolution()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 144 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), kisGrowRect(QRectF(0,0,5,10), 0.25));
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(0,0));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(5,10));
 }
 
 
 void TestSvgParser::testUnitPt()
 {
     const QString data =
             "<svg width=\"10pt\" height=\"20pt\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 666 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), kisGrowRect(QRectF(0,0,10,20), 0.5));
     QCOMPARE(shape->absoluteTransformation(0), QTransform());
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(0,0));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(10,20));
 }
 
 void TestSvgParser::testUnitIn()
 {
     const QString data =
             "<svg width=\"10in\" height=\"20in\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 666 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), kisGrowRect(QRectF(0,0,720,1440), 36));
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromScale(72, 72));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(0,0));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(720,1440));
 }
 
 void TestSvgParser::testUnitPercentInitial()
 {
     const QString data =
             "<svg width=\"12.5%\" height=\"25%\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 80, 80) /* px */, 144 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), kisGrowRect(QRectF(0,0,5,10), 0.25));
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(0,0));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(5,10));
 }
 
 void TestSvgParser::testScalingViewport()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"60 70 20 40\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"64\" y=\"74\" width=\"12\" height=\"32\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(4, 4) * QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(2,2));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(8,2));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(2,18));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(8,18));
 }
 
 void TestSvgParser::testScalingViewportKeepMeet1()
 {
     const QString data =
             "<svg width=\"10px\" height=\"30px\" viewBox=\"60 70 20 40\""
             "    preserveAspectRatio=\" xMinYMin meet\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"64\" y=\"74\" width=\"12\" height=\"32\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(4, 4) * QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(2,2));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(8,2));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(2,18));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(8,18));
 }
 
 void TestSvgParser::testScalingViewportKeepMeet2()
 {
     const QString data =
             "<svg width=\"15px\" height=\"20px\" viewBox=\"60 70 20 40\""
             "    preserveAspectRatio=\" xMinYMin meet\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"64\" y=\"74\" width=\"12\" height=\"32\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(4, 4) * QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(2,2));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(8,2));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(2,18));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(8,18));
 }
 
 void TestSvgParser::testScalingViewportKeepMeetAlign()
 {
     const QString data =
             "<svg width=\"10px\" height=\"30px\" viewBox=\"60 70 20 40\""
             "    preserveAspectRatio=\" xMaxYMax meet\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"64\" y=\"74\" width=\"12\" height=\"32\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(4, 24) * QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(2,12));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(8,12));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(2,28));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(8,28));
 }
 
 void TestSvgParser::testScalingViewportKeepSlice1()
 {
     const QString data =
             "<svg width=\"5px\" height=\"20px\" viewBox=\"60 70 20 40\""
             "    preserveAspectRatio=\" xMinYMin slice\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"64\" y=\"74\" width=\"12\" height=\"32\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(4, 4) * QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(2,2));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(8,2));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(2,18));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(8,18));
 }
 
 void TestSvgParser::testScalingViewportKeepSlice2()
 {
     const QString data =
             "<svg width=\"10px\" height=\"15px\" viewBox=\"60 70 20 40\""
             "    preserveAspectRatio=\" xMinYMin slice\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"64\" y=\"74\" width=\"12\" height=\"32\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(4, 4) * QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(2,2));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(8,2));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(2,18));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(8,18));
 }
 
 void TestSvgParser::testScalingViewportResolution()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"60 70 20 40\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"64\" y=\"74\" width=\"12\" height=\"32\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 144 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(4, 4) * QTransform::fromScale(0.25, 0.25));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(1,1));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(4,1));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(1,9));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(4,9));
 }
 
 void TestSvgParser::testScalingViewportPercentInternal()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"60 70 20 40\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"320%\" y=\"185%\" width=\"60%\" height=\"80%\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(4, 4) * QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(2,2));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(8,2));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(2,18));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(8,18));
 }
 
 
 void TestSvgParser::testParsePreserveAspectRatio()
 {
     {
         SvgUtil::PreserveAspectRatioParser p(" defer  xMinYMax meet");
         QCOMPARE(p.defer, true);
         QCOMPARE(p.mode, Qt::KeepAspectRatio);
         QCOMPARE(p.xAlignment, SvgUtil::PreserveAspectRatioParser::Min);
         QCOMPARE(p.yAlignment, SvgUtil::PreserveAspectRatioParser::Max);
     }
 
     {
         SvgUtil::PreserveAspectRatioParser p(" xMinYMid slice");
         QCOMPARE(p.defer, false);
         QCOMPARE(p.mode, Qt::KeepAspectRatioByExpanding);
         QCOMPARE(p.xAlignment, SvgUtil::PreserveAspectRatioParser::Min);
         QCOMPARE(p.yAlignment, SvgUtil::PreserveAspectRatioParser::Middle);
     }
 
     {
         SvgUtil::PreserveAspectRatioParser p(" xmidYMid ");
         QCOMPARE(p.defer, false);
         QCOMPARE(p.mode, Qt::KeepAspectRatio);
         QCOMPARE(p.xAlignment, SvgUtil::PreserveAspectRatioParser::Middle);
         QCOMPARE(p.yAlignment, SvgUtil::PreserveAspectRatioParser::Middle);
     }
 
     {
         SvgUtil::PreserveAspectRatioParser p(" NoNe ");
         QCOMPARE(p.defer, false);
         QCOMPARE(p.mode, Qt::IgnoreAspectRatio);
         QCOMPARE(p.xAlignment, SvgUtil::PreserveAspectRatioParser::Min);
         QCOMPARE(p.yAlignment, SvgUtil::PreserveAspectRatioParser::Min);
     }
 
     {
         SvgUtil::PreserveAspectRatioParser p("defer NoNe ");
         QCOMPARE(p.defer, true);
         QCOMPARE(p.mode, Qt::IgnoreAspectRatio);
         QCOMPARE(p.xAlignment, SvgUtil::PreserveAspectRatioParser::Min);
         QCOMPARE(p.yAlignment, SvgUtil::PreserveAspectRatioParser::Min);
     }
 
     {
         SvgUtil::PreserveAspectRatioParser p("sweet brown fox jumps over a nice svg file");
         QCOMPARE(p.defer, false);
         QCOMPARE(p.mode, Qt::IgnoreAspectRatio);
         QCOMPARE(p.xAlignment, SvgUtil::PreserveAspectRatioParser::Min);
         QCOMPARE(p.yAlignment, SvgUtil::PreserveAspectRatioParser::Min);
     }
 }
 
 #include "parsers/SvgTransformParser.h"
 
 void TestSvgParser::testParseTransform()
 {
     {
         QString str("translate(-111.0, 33) translate(-111.0, 33) matrix (1 1 0 0 1, 3), translate(1)"
                     "scale(0.5) rotate(10) rotate(10, 3 3) skewX(1) skewY(2)");
 
         SvgTransformParser p(str);
         QCOMPARE(p.isValid(), true);
     }
 
     {
         // forget about one brace
         QString str("translate(-111.0, 33) translate(-111.0, 33 matrix (1 1 0 0 1, 3), translate(1)"
                     "scale(0.5) rotate(10) rotate(10, 3 3) skewX(1) skewY(2)");
 
         SvgTransformParser p(str);
         QCOMPARE(p.isValid(), false);
     }
 
     {
         SvgTransformParser p("translate(100, 50)");
         QCOMPARE(p.isValid(), true);
         QCOMPARE(p.transform(), QTransform::fromTranslate(100, 50));
     }
 
     {
         SvgTransformParser p("translate(100 50)");
         QCOMPARE(p.isValid(), true);
         QCOMPARE(p.transform(), QTransform::fromTranslate(100, 50));
     }
 
     {
         SvgTransformParser p("translate(100)");
         QCOMPARE(p.isValid(), true);
         QCOMPARE(p.transform(), QTransform::fromTranslate(100, 0));
     }
 
     {
         SvgTransformParser p("scale(100, 50)");
         QCOMPARE(p.isValid(), true);
         QCOMPARE(p.transform(), QTransform::fromScale(100, 50));
     }
 
     {
         SvgTransformParser p("scale(100)");
         QCOMPARE(p.isValid(), true);
         QCOMPARE(p.transform(), QTransform::fromScale(100, 100));
     }
 
     {
         SvgTransformParser p("rotate(90 70 74.0)");
         QCOMPARE(p.isValid(), true);
         QTransform t;
         t.rotate(90);
         t = QTransform::fromTranslate(-70, -74) * t * QTransform::fromTranslate(70, 74);
         qDebug() << ppVar(p.transform());
         QCOMPARE(p.transform(), t);
     }
 }
 
 void TestSvgParser::testScalingViewportTransform()
 {
     /**
      * Note: 'transform' affects all the attributes of the *current*
      * element, while 'viewBox' affects only the descendants!
      */
 
     const QString data =
             "<svg width=\"5px\" height=\"10px\" viewBox=\"60 70 20 40\""
             "    transform=\"scale(2)\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"64\" y=\"74\" width=\"12\" height=\"32\""
             "    transform=\"translate(6)\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->absoluteTransformation(0), QTransform::fromTranslate(10, 4) * QTransform::fromScale(0.5, 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,12,32));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(5,2));
     QCOMPARE(shape->absolutePosition(KoFlake::TopRight), QPointF(11,2));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomLeft), QPointF(5,18));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(11,18));
 }
 
 void TestSvgParser::testTransformNesting()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    transform=\"translate(10,10), scale(2, 1)\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), QRectF(10 - 1,10 - 0.5, 20 + 2, 20 + 1));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(10,10));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(30,30));
 }
 
 void TestSvgParser::testTransformNestingGroups()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g transform=\"translate(10,10)\">"
             "    <rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "        transform=\"scale(2, 1)\""
             "        fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
             "</g>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), QRectF(10 - 1,10 - 0.5, 20 + 2, 20 + 1));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(10,10));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(30,30));
 }
 
 void TestSvgParser::testTransformRotation1()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    transform=\"rotate(90)\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), kisGrowRect(QRectF(-20,0,20,10), 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(0,0));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(-20,10));
 }
 
 void TestSvgParser::testTransformRotation2()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    transform=\"rotate(-90 10 5)\""
             "    fill=\"none\" stroke=\"none\" stroke-width=\"10\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 72 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->boundingRect(), kisGrowRect(QRectF(5,5,20,10), 0.5));
     QCOMPARE(shape->outlineRect(), QRectF(0,0,10,20));
     QCOMPARE(shape->absolutePosition(KoFlake::TopLeft), QPointF(5,15));
     QCOMPARE(shape->absolutePosition(KoFlake::BottomRight), QPointF(25,5));
 }
 
 
 
 void TestSvgParser::testRenderStrokeNone()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"none\" stroke-width=\"1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_none");
 }
 
 void TestSvgParser::testRenderStrokeColorName()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue");
 }
 
 void TestSvgParser::testRenderStrokeColorHex3()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"#00f\" stroke-width=\"1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue");
 }
 
 void TestSvgParser::testRenderStrokeColorHex6()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"#0000ff\" stroke-width=\"1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue");
 }
 
 void TestSvgParser::testRenderStrokeColorRgbValues()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"rgb(0, 0 ,255)\" stroke-width=\"1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue");
 }
 
 void TestSvgParser::testRenderStrokeColorRgbPercent()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"rgb(0, 0 ,100%)\" stroke-width=\"1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue");
 }
 
 void TestSvgParser::testRenderStrokeColorCurrent()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g color=\"blue\">"
             "    <rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "        fill=\"cyan\" stroke=\"currentColor\" stroke-width=\"1\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue");
 }
 
 void TestSvgParser::testRenderStrokeColorNonexistentIri()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"url(notexists) blue\" stroke-width=\"1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue");
 }
 
 void TestSvgParser::testRenderStrokeWidth()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"2\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_width_2");
 }
 
 void TestSvgParser::testRenderStrokeZeroWidth()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"0\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_none");
 }
 
 void TestSvgParser::testRenderStrokeOpacity()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"4\" stroke-opacity=\"0.3\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(1);
     t.test_standard_30px_72ppi("stroke_blue_0_3_opacity");
 }
 
 void TestSvgParser::testRenderStrokeJointRound()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"4\" stroke-linejoin=\"round\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_join_round");
 }
 
 void TestSvgParser::testRenderStrokeLinecap()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<polyline id=\"testRect\" points=\"5,5 10,25 15,5\""
             "    fill=\"none\" stroke=\"blue\" stroke-width=\"5\" stroke-linecap=\"round\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_linecap_round");
 }
 
 void TestSvgParser::testRenderStrokeMiterLimit()
 {
     // TODO:seems like doesn't work!!
     qWarning() << "WARNING: Miter limit test is skipped!!!";
     return;
 
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<polyline id=\"testRect\" points=\"5,5 10,25 15,5\""
             "    fill=\"none\" stroke=\"blue\" stroke-width=\"5\" stroke-miterlimit=\"1.114\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_miter_limit");
 }
 
 void TestSvgParser::testRenderStrokeDashArrayEven()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"2\" stroke-dasharray=\"3 2, 5 2\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_dasharray_even");
 }
 
 void TestSvgParser::testRenderStrokeDashArrayEvenOffset()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"2\" stroke-dasharray=\"3 2, 5 2\""
             "    stroke-dashoffset=\"1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_dasharray_even_offset");
 }
 
 void TestSvgParser::testRenderStrokeDashArrayOdd()
 {
     // SVG 1.1: if the dasharray is odd, repeat it
 
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"2\" stroke-dasharray=\"3 2, 5\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_dasharray_odd");
 }
 
 void TestSvgParser::testRenderStrokeDashArrayRelative()
 {
     // SVG 1.1: relative to view box
     // (40 x 50) * sqrt(2) => dash length = 5 px
 
     const QString data =
             "<svg width=\"42.4264px\" height=\"56.56854px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" stroke=\"blue\" stroke-width=\"2\" stroke-dasharray=\"10% 10%\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_dasharray_relative");
 }
 
 void TestSvgParser::testRenderFillDefault()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_black");
 }
 
 void TestSvgParser::testRenderFillRuleNonZero()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<polyline id=\"testRect\" points=\"5,5 15,11 15,19 5,25 5,19 15,5 15,25 5,11 5,5\""
             "    fill=\"black\" fill-rule=\"nonzero\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_non_zero");
 }
 
 void TestSvgParser::testRenderFillRuleEvenOdd()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<polyline id=\"testRect\" points=\"5,5 15,11 15,19 5,25 5,19 15,5 15,25 5,11 5,5\""
             "    fill=\"black\" fill-rule=\"evenodd\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_even_odd");
 }
 
 void TestSvgParser::testRenderFillOpacity()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    fill=\"cyan\" fill-opacity=\"0.3\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(1);
     t.test_standard_30px_72ppi("fill_opacity_0_3");
 }
 
 void TestSvgParser::testRenderDisplayAttribute()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "    fill=\"black\" display=\"none\"/>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 144 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->isVisible(), false);
 }
 
 void TestSvgParser::testRenderVisibilityAttribute()
 {
     {
         const QString data =
                 "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
                 "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
                 "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
                 "    fill=\"black\" visibility=\"visible\"/>"
 
                 "</svg>";
 
         SvgTester t (data);
         t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 144 /* ppi */);
         t.run();
 
         KoShape *shape = t.findShape("testRect");
         QVERIFY(shape);
 
         QCOMPARE(shape->isVisible(), true);
     }
 
     {
         const QString data =
                 "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
                 "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
                 "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
                 "    fill=\"black\" visibility=\"hidden\"/>"
 
                 "</svg>";
 
         SvgTester t (data);
         t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 144 /* ppi */);
         t.run();
 
         KoShape *shape = t.findShape("testRect");
         QVERIFY(shape);
 
         QCOMPARE(shape->isVisible(), false);
     }
 
     {
         const QString data =
                 "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
                 "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
                 "<rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
                 "    fill=\"black\" visibility=\"collapse\"/>"
 
                 "</svg>";
 
         SvgTester t (data);
         t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 144 /* ppi */);
         t.run();
 
         KoShape *shape = t.findShape("testRect");
         QVERIFY(shape);
 
         QCOMPARE(shape->isVisible(), false);
     }
 }
 
 void TestSvgParser::testRenderVisibilityInheritance()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g visibility=\"none\">"
             "    <rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "        fill=\"black\" visibility=\"visible\"/>"
             "</g>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 144 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->isVisible(false), true);
     QCOMPARE(shape->isVisible(true), false);
 }
 
 void TestSvgParser::testRenderDisplayInheritance()
 {
     const QString data =
             "<svg width=\"10px\" height=\"20px\" viewBox=\"0 0 10 20\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g display=\"none\">"
             "    <rect id=\"testRect\" x=\"0\" y=\"0\" width=\"10\" height=\"20\""
             "        fill=\"black\" visibility=\"visible\"/>"
             "</g>"
 
             "</svg>";
 
     SvgTester t (data);
     t.parser.setResolution(QRectF(0, 0, 600, 400) /* px */, 144 /* ppi */);
     t.run();
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(shape);
 
     QCOMPARE(shape->isVisible(false), true);
     QEXPECT_FAIL("", "TODO: Fix 'display' attribute not to be inherited in shapes hierarchy!", Continue);
     QCOMPARE(shape->isVisible(true), true);
 }
 
 void TestSvgParser::testRenderStrokeWithInlineStyle()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"fill: cyan; stroke :blue; stroke-width:2;\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_blue_width_2");
 }
 
 void TestSvgParser::testIccColor()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g xml:base=\"icc\">"
             "    <color-profile xlink:href=\"sRGB-elle-V4-srgbtrc.icc\""
             "        local=\"133a66607cffeebdd64dd433ada9bf4e\" name=\"default-profile\"/>"
 
             "    <color-profile xlink:href=\"sRGB-elle-V4-srgbtrc.icc\""
             "        local=\"133a66607cffeebdd64dd433ada9bf4e\" name=\"some-other-name\"/>"
 
             "    <rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "        style = \"fill: cyan; stroke :blue; stroke-width:2;\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     int numFetches = 0;
 
     t.parser.setFileFetcher(
         [&numFetches](const QString &name) {
             numFetches++;
             const QString fileName = TestUtil::fetchDataFileLazy(name);
             QFile file(fileName);
             KIS_ASSERT(file.exists());
             file.open(QIODevice::ReadOnly);
             return file.readAll();
         });
 
     t.test_standard_30px_72ppi("stroke_blue_width_2");
     QCOMPARE(numFetches, 1);
 }
 
 void TestSvgParser::testRenderFillLinearGradientRelativePercent()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <linearGradient id=\"testGrad\" x1=\"0%\" y1=\"50%\" x2=\"100%\" y2=\"50%\">"
             "        <stop offset=\"20%\" stop-color=\"#F60\" />"
             "        <stop offset=\"80%\" stop-color=\"#FF6\" />"
             "    </linearGradient>"
             "</defs>"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"fill:url(#testGrad) magenta; stroke:none; stroke-width:2;\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient");
 }
 
 void TestSvgParser::testRenderFillLinearGradientRelativePortion()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<linearGradient id=\"testGrad\" x1=\"0\" y1=\"0.5\" x2=\"1.0\" y2=\"0.5\">"
             "    <stop offset=\"20%\" stop-color=\"#F60\" />"
             "    <stop offset=\"80%\" stop-color=\"#FF6\" />"
             "</linearGradient>"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"fill:url(#testGrad) magenta; stroke:none; stroke-width:2;\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient");
 }
 
 void TestSvgParser::testRenderFillLinearGradientUserCoord()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\" viewBox=\"60 70 60 90\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<linearGradient id=\"testGrad\" x1=\"70\" y1=\"115\" x2=\"90\" y2=\"115\""
             "    gradientUnits=\"userSpaceOnUse\">"
             "    <stop offset=\"20%\" stop-color=\"#F60\" />"
             "    <stop offset=\"80%\" stop-color=\"#FF6\" />"
             "</linearGradient>"
 
             "<rect id=\"testRect\" x=\"70\" y=\"85\" width=\"20\" height=\"60\""
             "    fill=\"url(#testGrad) magenta\" stroke=\"none\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient");
 }
 
 void TestSvgParser::testRenderFillLinearGradientStopPortion()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<linearGradient id=\"testGrad\" x1=\"0\" y1=\"0.5\" x2=\"1.0\" y2=\"0.5\">"
             "    <stop offset=\"0.2\" stop-color=\"#F60\" />"
             "    <stop offset=\"0.8\" stop-color=\"#FF6\" />"
             "</linearGradient>"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"fill:url(#testGrad) magenta; stroke:none; stroke-width:2;\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient");
 }
 
 void TestSvgParser::testRenderFillLinearGradientTransform()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<linearGradient id=\"testGrad\" x1=\"0\" y1=\"0.5\" x2=\"1.0\" y2=\"0.5\""
             "    gradientTransform=\"rotate(90, 0.5, 0.5)\">"
 
             "    <stop offset=\"0.2\" stop-color=\"#F60\" />"
             "    <stop offset=\"0.8\" stop-color=\"#FF6\" />"
             "</linearGradient>"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"fill:url(#testGrad) magenta; stroke:none; stroke-width:2;\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient_vertical");
 }
 
 void TestSvgParser::testRenderFillLinearGradientTransformUserCoord()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\" viewBox=\"60 70 60 90\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<linearGradient id=\"testGrad\" x1=\"70\" y1=\"115\" x2=\"90\" y2=\"115\""
             "    gradientUnits=\"userSpaceOnUse\""
             "    gradientTransform=\"rotate(90, 80, 115)\">"
 
             "    <stop offset=\"20%\" stop-color=\"#F60\" />"
             "    <stop offset=\"80%\" stop-color=\"#FF6\" />"
             "</linearGradient>"
 
             "<rect id=\"testRect\" x=\"70\" y=\"85\" width=\"20\" height=\"60\""
             "    fill=\"url(#testGrad) magenta\" stroke=\"none\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient_vertical_in_user");
 }
 
 void TestSvgParser::testRenderFillLinearGradientRotatedShape()
 {
     // DK: I'm not sure I fully understand if it is a correct transformation,
     //     but inkscape opens the file in the same way...
 
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<linearGradient id=\"testGrad\" x1=\"0\" y1=\"0.5\" x2=\"1.0\" y2=\"0.5\""
             "    gradientTransform=\"rotate(90, 0.5, 0.5)\">"
 
             "    <stop offset=\"0.2\" stop-color=\"#F60\" />"
             "    <stop offset=\"0.8\" stop-color=\"#FF6\" />"
             "</linearGradient>"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"fill:url(#testGrad) magenta; stroke:none; stroke-width:2;\""
             "    transform=\"rotate(90, 10, 12.5)\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient_shape_rotated", false);
 }
 
 void TestSvgParser::testRenderFillLinearGradientRotatedShapeUserCoord()
 {
     // DK: I'm not sure I fully understand if it is a correct transformation,
     //     but inkscape opens the file in the same way...
 
     const QString data =
             "<svg width=\"30px\" height=\"30px\" viewBox=\"60 70 60 90\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<linearGradient id=\"testGrad\" x1=\"70\" y1=\"115\" x2=\"90\" y2=\"115\""
             "    gradientUnits=\"userSpaceOnUse\">"
 
             "    <stop offset=\"20%\" stop-color=\"#F60\" />"
             "    <stop offset=\"80%\" stop-color=\"#FF6\" />"
             "</linearGradient>"
 
             "<rect id=\"testRect\" x=\"70\" y=\"85\" width=\"20\" height=\"60\""
             "    fill=\"url(#testGrad) magenta\" stroke=\"none\""
             "    transform=\"rotate(90, 80, 115)\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient_shape_rotated_in_user", false);
 }
 
 void TestSvgParser::testRenderFillRadialGradient()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<radialGradient id=\"testGrad\" cx=\"0.5\" cy=\"0.5\" fx=\"0.2\" fy=\"0.2\" r=\"0.5\">"
             "    <stop offset=\"0.2\" stop-color=\"#F60\" />"
             "    <stop offset=\"0.8\" stop-color=\"#FF6\" />"
             "</radialGradient>"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"fill:url(#testGrad) magenta; stroke:none; stroke-width:2;\"/>"
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(1);
     t.test_standard_30px_72ppi("fill_gradient_radial");
 }
 
 void TestSvgParser::testRenderFillRadialGradientUserCoord()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<radialGradient id=\"testGrad\" cx=\"10\" cy=\"12.5\" fx=\"7\" fy=\"9\" r=\"5\""
             "    gradientUnits=\"userSpaceOnUse\">"
 
             "    <stop offset=\"0.2\" stop-color=\"#F60\" />"
             "    <stop offset=\"0.8\" stop-color=\"#FF6\" />"
             "</radialGradient>"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"fill:url(#testGrad) magenta; stroke:none; stroke-width:2;\"/>"
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(1);
     t.test_standard_30px_72ppi("fill_gradient_radial_in_user");
 }
 
 void TestSvgParser::testRenderFillLinearGradientUserCoordPercent()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\" viewBox=\"60 70 60 90\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<linearGradient id=\"testGrad\" x1=\"116.667%\" y1=\"127.778%\" x2=\"150%\" y2=\"127.778%\""
             "    gradientUnits=\"userSpaceOnUse\">"
             "    <stop offset=\"20%\" stop-color=\"#F60\" />"
             "    <stop offset=\"80%\" stop-color=\"#FF6\" />"
             "</linearGradient>"
 
             "<rect id=\"testRect\" x=\"70\" y=\"85\" width=\"20\" height=\"60\""
             "    fill=\"url(#testGrad) magenta\" stroke=\"none\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("fill_gradient");
 }
 
 void TestSvgParser::testRenderStrokeLinearGradient()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <linearGradient id=\"testGrad\" x1=\"0%\" y1=\"50%\" x2=\"100%\" y2=\"50%\">"
             "        <stop offset=\"20%\" stop-color=\"#F60\" />"
             "        <stop offset=\"80%\" stop-color=\"#FF6\" />"
             "    </linearGradient>"
             "</defs>"
 
             "<rect id=\"testRect\" x=\"5\" y=\"5\" width=\"10\" height=\"20\""
             "    style = \"grey; stroke:url(#testGrad); stroke-width:3; stroke-dasharray:3,1\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard_30px_72ppi("stroke_gradient_dashed");
 }
 
 QTransform rotateTransform(qreal degree, const QPointF &center) {
     QTransform rotate;
     rotate.rotate(degree);
     return
         QTransform::fromTranslate(-center.x(), -center.y()) *
         rotate *
         QTransform::fromTranslate(center.x(), center.y());
 }
 
 QTransform viewTransform(const QRectF &src, const QRectF &dst) {
     return QTransform::fromTranslate(-src.x(), -src.y()) *
             QTransform::fromScale(dst.width() / src.width(),
                                   dst.height() / src.height()) *
             QTransform::fromTranslate(dst.x(), dst.y());
 
 }
 
 QPainterPath bakeShape(const QPainterPath &path,
                        const QTransform &bakeTransform,
                        bool contentIsObb = false, const QRectF &shapeBoundingRect = QRectF(),
                        bool contentIsViewBox = false, const QRectF &viewBoxRect= QRectF(), const QRectF &refRect = QRectF())
 {
     const QTransform relativeToShape(shapeBoundingRect.width(), 0, 0, shapeBoundingRect.height(),
                                      shapeBoundingRect.x(), shapeBoundingRect.y());
 
     QTransform newTransform = bakeTransform;
 
     if (contentIsObb) {
         newTransform = relativeToShape * newTransform;
     }
 
     if (contentIsViewBox) {
         newTransform = viewTransform(viewBoxRect, refRect) * newTransform;
     }
 
     return newTransform.map(path);
 }
 
 #include <KoBakedShapeRenderer.h>
 
 void renderBakedPath(QPainter &painter,
                      const QPainterPath &bakedFillPath, const QTransform &bakedTransform,
                      const QRect &shapeOutline, const QTransform &shapeTransform,
                      const QRectF &referenceRect,
                      bool contentIsObb, const QRectF &bakedShapeBoundingRect,
                      bool referenceIsObb,
                      const QTransform &patternTransform,
                      QImage *stampResult)
 {
     painter.setTransform(QTransform());
     painter.setPen(Qt::NoPen);
 
     QPainterPath shapeOutlinePath;
     shapeOutlinePath.addRect(shapeOutline);
 
     KoBakedShapeRenderer renderer(
                 shapeOutlinePath,
                 shapeTransform,
                 bakedTransform,
                 referenceRect,
                 contentIsObb, bakedShapeBoundingRect,
                 referenceIsObb,
                 patternTransform);
 
     QPainter *patchPainter = renderer.bakeShapePainter();
     patchPainter->fillPath(bakedFillPath, Qt::blue);
     patchPainter->end();
 
     renderer.renderShape(painter);
 
     if (stampResult) {
         *stampResult = renderer.patchImage();
     }
 }
 
 void TestSvgParser::testManualRenderPattern_ContentUser_RefObb()
 {
     const QRectF referenceRect(0, 0, 1.0, 0.5);
 
     QPainterPath fillPath;
     fillPath.addRect(QRect(2, 2, 6, 6));
     fillPath.addRect(QRect(8, 4, 3, 2));
 
     QTransform bakedTransform = QTransform::fromTranslate(10, 10) * QTransform::fromScale(2, 2);
     QPainterPath bakedFillPath = bakeShape(fillPath, bakedTransform);
 
     QRect shape1OutlineRect(0,0,10,20);
 
     QImage stampResult;
     QImage fillResult(QSize(60,60), QImage::Format_ARGB32);
     QPainter gc(&fillResult);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape1OutlineRect, bakedTransform,
                     referenceRect,
                     false, QRectF(),
                     true,
                     QTransform(),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_user_r_obb_patch1"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_user_r_obb_fill1"));
 
     QRect shape2OutlineRect(5,5,20,10);
     QTransform shape2Transform = QTransform::fromScale(2, 2) * QTransform::fromTranslate(5, 5);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape2OutlineRect, shape2Transform,
                     referenceRect,
                     false, QRectF(),
                     true,
                     QTransform(),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_user_r_obb_patch2"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_user_r_obb_fill2"));
 }
 
 void TestSvgParser::testManualRenderPattern_ContentObb_RefObb()
 {
     const QRectF referenceRect(0.3, 0.3, 0.4, 0.4);
 
     QPainterPath fillPath;
     fillPath.addRect(QRectF(0.4, 0.4, 0.2, 0.2));
     fillPath.addRect(QRectF(0.6, 0.5, 0.1, 0.1));
     fillPath.addRect(QRectF(0.3, 0.4, 0.1, 0.1));
 
 
     const QRect bakedShapeRect(2,2,10,10);
     QTransform bakedTransform = QTransform::fromTranslate(10, 10) * QTransform::fromScale(2, 2);
 
     QPainterPath bakedFillPath = bakeShape(fillPath, bakedTransform, true, bakedShapeRect);
 
     QImage stampResult;
     QImage fillResult(QSize(60,60), QImage::Format_ARGB32);
     QPainter gc(&fillResult);
 
     // Round trip to the same shape
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     bakedShapeRect, bakedTransform,
                     referenceRect,
                     true, bakedShapeRect,
                     true,
                     QTransform(),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_obb_r_obb_patch1"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_obb_r_obb_fill1"));
 
     // Move to a different shape
 
     QRect shape2OutlineRect(5,5,20,10);
     QTransform shape2Transform = QTransform::fromScale(2, 2) * QTransform::fromTranslate(5, 5);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape2OutlineRect, shape2Transform,
                     referenceRect,
                     true, bakedShapeRect,
                     true,
                     QTransform(),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_obb_r_obb_patch2"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_obb_r_obb_fill2"));
 }
 
 void TestSvgParser::testManualRenderPattern_ContentUser_RefUser()
 {
     const QRectF referenceRect(5, 2, 8, 8);
 
     QPainterPath fillPath;
     fillPath.addRect(QRect(2, 2, 6, 6));
     fillPath.addRect(QRect(8, 4, 3, 2));
 
 
     QTransform bakedTransform = QTransform::fromTranslate(10, 10) * QTransform::fromScale(2, 2);
     QPainterPath bakedFillPath = bakeShape(fillPath, bakedTransform);
 
     QRect shape1OutlineRect(0,0,10,20);
 
     QImage stampResult;
     QImage fillResult(QSize(60,60), QImage::Format_ARGB32);
     QPainter gc(&fillResult);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape1OutlineRect, bakedTransform,
                     referenceRect,
                     false, QRectF(),
                     false,
                     QTransform(),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_user_r_user_patch1"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_user_r_user_fill1"));
 
     QRect shape2OutlineRect(5,5,20,10);
     QTransform shape2Transform = QTransform::fromScale(2, 2) * QTransform::fromTranslate(5, 5);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape2OutlineRect, shape2Transform,
                     referenceRect,
                     false, QRectF(),
                     false,
                     QTransform(),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_user_r_user_patch2"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_user_r_user_fill2"));
 }
 
 void TestSvgParser::testManualRenderPattern_ContentObb_RefObb_Transform_Rotate()
 {
     const QRectF referenceRect(0.0, 0.0, 0.4, 0.2);
 
     QPainterPath fillPath;
     fillPath.addRect(QRectF(0.0, 0.0, 0.5, 0.1));
     fillPath.addRect(QRectF(0.0, 0.1, 0.1, 0.1));
 
     const QRect bakedShapeRect(2,1,10,10);
     QTransform bakedTransform = QTransform::fromScale(2, 2) * QTransform::fromTranslate(10,10);
 
     QPainterPath bakedFillPath = bakeShape(fillPath, bakedTransform, true, bakedShapeRect);
 
     QImage stampResult;
     QImage fillResult(QSize(60,60), QImage::Format_ARGB32);
     QPainter gc(&fillResult);
 
     QTransform patternTransform;
     patternTransform.rotate(90);
     patternTransform = patternTransform * QTransform::fromTranslate(0.5, 0.0);
 
     // Round trip to the same shape
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     bakedShapeRect, bakedTransform,
                     referenceRect,
                     true, bakedShapeRect,
                     true,
                     patternTransform,
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_obb_r_obb_rotate_patch1"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_obb_r_obb_rotate_fill1"));
 
     QRect shape2OutlineRect(5,5,20,10);
     QTransform shape2Transform = QTransform::fromScale(2, 2) * QTransform::fromTranslate(5, 5);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape2OutlineRect, shape2Transform,
                     referenceRect,
                     true, bakedShapeRect,
                     true,
                     patternTransform,
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_obb_r_obb_rotate_patch2"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_obb_r_obb_rotate_fill2"));
 }
 
 
 void TestSvgParser::testManualRenderPattern_ContentView_RefObb()
 {
     const QRectF referenceRect(0, 0, 0.5, 1.0/3.0);
     const QRectF viewRect(10,10,60,90);
 
     QPainterPath fillPath;
     fillPath.addRect(QRect(30, 10, 20, 60));
     fillPath.addRect(QRect(50, 40, 20, 30));
 
 
     QRect shape1OutlineRect(10,20,40,120);
 
     QTransform bakedTransform = QTransform::fromScale(2, 0.5) * QTransform::fromTranslate(40,30);
     QPainterPath bakedFillPath = bakeShape(fillPath, bakedTransform,
                                            true, shape1OutlineRect,
                                            true, viewRect, referenceRect);
 
     QImage stampResult;
     QImage fillResult(QSize(220,160), QImage::Format_ARGB32);
     QPainter gc(&fillResult);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape1OutlineRect, bakedTransform,
                     referenceRect,
                     true, shape1OutlineRect,
                     true,
                     QTransform(),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_view_r_obb_patch1"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_view_r_obb_fill1"));
 
     QRect shape2OutlineRect(20,10,60,90);
     QTransform shape2Transform = QTransform::fromScale(2, 1) * QTransform::fromTranslate(50, 50);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape2OutlineRect, shape2Transform,
                     referenceRect,
                     true, shape1OutlineRect,
                     true,
                     rotateTransform(90, QPointF(0, 1.0 / 3.0)),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_view_r_obb_patch2"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_view_r_obb_fill2"));
 }
 
 void TestSvgParser::testManualRenderPattern_ContentView_RefUser()
 {
     const QRectF referenceRect(60, 0, 30, 20);
     const QRectF viewRect(10,10,60,90);
 
     QPainterPath fillPath;
     fillPath.addRect(QRect(30, 10, 20, 60));
     fillPath.addRect(QRect(50, 40, 20, 30));
 
 
     QRect shape1OutlineRect(10,20,40,120);
 
     QTransform bakedTransform = QTransform::fromScale(2, 0.5) * QTransform::fromTranslate(40,30);
     QPainterPath bakedFillPath = bakeShape(fillPath, bakedTransform,
                                            false, shape1OutlineRect,
                                            true, viewRect, referenceRect);
 
     QImage stampResult;
     QImage fillResult(QSize(220,160), QImage::Format_ARGB32);
     QPainter gc(&fillResult);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape1OutlineRect, bakedTransform,
                     referenceRect,
                     false, shape1OutlineRect,
                     false,
                     QTransform(),
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_view_r_user_patch1"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_view_r_user_fill1"));
 
     QRect shape2OutlineRect(20,10,60,90);
     QTransform shape2Transform = QTransform::fromScale(2, 1) * QTransform::fromTranslate(50, 50);
 
     QTransform patternTransform2 = rotateTransform(90, QPointF()) * QTransform::fromTranslate(40, 10);
 
     fillResult.fill(0);
     renderBakedPath(gc,
                     bakedFillPath, bakedTransform,
                     shape2OutlineRect, shape2Transform,
                     referenceRect,
                     false, shape1OutlineRect,
                     false,
                     patternTransform2,
                     &stampResult);
 
     QVERIFY(TestUtil::checkQImage(stampResult, "svg_render", "render", "pattern_c_view_r_user_patch2"));
     QVERIFY(TestUtil::checkQImage(fillResult, "svg_render", "render", "pattern_c_view_r_user_fill2"));
 }
 
 void TestSvgParser::testRenderPattern_r_User_c_User()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <pattern id=\"TestPattern\" patternUnits=\"userSpaceOnUse\""
             "        patternContentUnits=\"userSpaceOnUse\""
             "        x=\"60\" y=\"0\" width=\"30\" height=\"20\">"
 
             "        <g id=\"patternRect\">"
             "            <rect id=\"patternRect1\" x=\"70\" y=\"0\" width=\"10\" height=\"13.3333\""
             "                fill=\"red\" stroke=\"none\" />"
 
             "            <rect id=\"patternRect2\" x=\"80\" y=\"6.3333\" width=\"10\" height=\"6.6666\""
             "                fill=\"red\" stroke=\"none\" />"
             "        </g>"
 
             "    </pattern>"
             "</defs>"
 
             "<g>"
             "    <rect id=\"testRect\" x=\"10\" y=\"20\" width=\"40\" height=\"120\""
             "        transform=\"translate(40 30) scale(2 0.5)\""
             "        fill=\"url(#TestPattern)blue\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("fill_pattern_base", false, QSize(160, 160));
 }
 
 void TestSvgParser::testRenderPattern_InfiniteRecursionWhenInherited()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <pattern id=\"TestPattern\" patternUnits=\"userSpaceOnUse\""
             "        patternContentUnits=\"userSpaceOnUse\""
             "        x=\"60\" y=\"0\" width=\"30\" height=\"20\">"
 
             "        <g id=\"patternRect\">"
             "            <rect id=\"patternRect1\" x=\"70\" y=\"0\" width=\"10\" height=\"13.3333\""
             "                stroke=\"none\" />"
 
             "            <rect id=\"patternRect2\" x=\"80\" y=\"6.3333\" width=\"10\" height=\"6.6666\""
             "                stroke=\"none\" />"
             "        </g>"
 
             "    </pattern>"
             "</defs>"
 
             "<g>"
             "    <rect id=\"testRect\" x=\"10\" y=\"20\" width=\"40\" height=\"120\""
             "        transform=\"translate(40 30) scale(2 0.5)\""
             "        fill=\"url(#TestPattern)blue\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("fill_pattern_base_black", false, QSize(160, 160));
 }
 
 void TestSvgParser::testRenderPattern_r_User_c_View()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <pattern id=\"TestPattern\" patternUnits=\"userSpaceOnUse\""
             "        viewBox=\"10 10 60 90\""
             "        x=\"60\" y=\"0\" width=\"30\" height=\"20\">"
 
             "        <g id=\"patternRect\">"
             "            <rect id=\"patternRect1\" x=\"30\" y=\"10\" width=\"20\" height=\"60\""
             "                fill=\"red\" stroke=\"none\" />"
 
             // y is changed to 39 from 40 to fix a rounding issue!
             "            <rect id=\"patternRect2\" x=\"50\" y=\"39\" width=\"20\" height=\"30\""
             "                fill=\"red\" stroke=\"none\" />"
             "        </g>"
 
             "    </pattern>"
             "</defs>"
 
             "<g>"
             "    <rect id=\"testRect\" x=\"10\" y=\"20\" width=\"40\" height=\"120\""
             "        transform=\"translate(40 30) scale(2 0.5)\""
             "        fill=\"url(#TestPattern)blue\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("fill_pattern_base", false, QSize(160, 160));
 }
 
 void TestSvgParser::testRenderPattern_r_User_c_Obb()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <pattern id=\"TestPattern\" patternUnits=\"userSpaceOnUse\""
             "        patternContentUnits=\"objectBoundingBox\""
             "        x=\"60\" y=\"0\" width=\"30\" height=\"20\">"
 
             "        <g id=\"patternRect\">"
             "            <rect id=\"patternRect1\" x=\"1.5\" y=\"-0.1666\" width=\"0.25\" height=\"0.111\""
             "                fill=\"red\" stroke=\"none\" />"
 
             "            <rect id=\"patternRect2\" x=\"1.75\" y=\"-0.12\" width=\"0.25\" height=\"0.07\""
             "                fill=\"red\" stroke=\"none\" />"
             "        </g>"
 
             "    </pattern>"
             "</defs>"
 
             "<g>"
             "    <rect id=\"testRect\" x=\"10\" y=\"20\" width=\"40\" height=\"120\""
             "        transform=\"translate(40 30) scale(2 0.5)\""
             "        fill=\"url(#TestPattern)blue\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("fill_pattern_base", false, QSize(160, 160));
 }
 
 void TestSvgParser::testRenderPattern_r_User_c_View_Rotated()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <pattern id=\"TestPattern\" patternUnits=\"userSpaceOnUse\""
             "        viewBox=\"10 10 60 90\""
             "        x=\"60\" y=\"0\" width=\"30\" height=\"20\""
             "        patternTransform=\"translate(40 10) rotate(90)\">"
 
             "        <g id=\"patternRect\">"
             "            <rect id=\"patternRect1\" x=\"30\" y=\"10\" width=\"20\" height=\"60\""
             "                fill=\"red\" stroke=\"none\" />"
             "            <rect id=\"patternRect2\" x=\"50\" y=\"40\" width=\"20\" height=\"30\""
             "                fill=\"red\" stroke=\"none\" />"
             "        </g>"
 
             "    </pattern>"
             "</defs>"
 
             "<g>"
             "    <rect id=\"testRect\" x=\"20\" y=\"10\" width=\"60\" height=\"90\""
             "        transform=\"translate(50 50) scale(2 1)\""
             "        fill=\"url(#TestPattern)blue\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("fill_pattern_rotated", false, QSize(220, 160));
 }
 
 void TestSvgParser::testRenderPattern_r_Obb_c_View_Rotated()
 {
     /**
      * This test case differs from any application existent in the world :(
      *
      * Chrome and Firefox premultiply the patternTransform instead of doing post-
      * multiplication. Photoshop forgets to multiply the reference rect on it.
      *
      * So...
      */
 
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <pattern id=\"TestPattern\" patternUnits=\"objectBoundingBox\""
             "        viewBox=\"10 10 60 90\""
             "        x=\"0\" y=\"0\" width=\"0.5\" height=\"0.333\""
             "        patternTransform=\"translate(0 0) rotate(90)\">"
 
             "        <g id=\"patternRect\">"
             "            <rect id=\"patternRect1\" x=\"30\" y=\"10\" width=\"20\" height=\"60\""
             "                fill=\"red\" stroke=\"none\" />"
             "            <rect id=\"patternRect2\" x=\"50\" y=\"40\" width=\"20\" height=\"30\""
             "                fill=\"red\" stroke=\"none\" />"
             "        </g>"
 
             "    </pattern>"
             "</defs>"
 
             "<g>"
             "    <rect id=\"testRect\" x=\"20\" y=\"10\" width=\"60\" height=\"90\""
             "        transform=\"translate(50 50) scale(1 1)\""
             "        fill=\"url(#TestPattern)blue\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("fill_pattern_rotated_odd", false, QSize(220, 160));
 }
 
 #include <KoPathShape.h>
 #include <KoColorBackground.h>
 #include <KoClipPath.h>
 #include <commands/KoShapeGroupCommand.h>
 
 void TestSvgParser::testKoClipPathRendering()
 {
     QPainterPath path1;
     path1.addRect(QRect(5,5,15,15));
 
     QPainterPath path2;
     path2.addRect(QRect(10,10,15,15));
 
     QPainterPath clipPath1;
     clipPath1.addRect(QRect(10, 0, 10, 30));
 
     QPainterPath clipPath2;
     clipPath2.moveTo(0,7);
     clipPath2.lineTo(30,7);
     clipPath2.lineTo(15,30);
     clipPath2.lineTo(0,7);
 
     QScopedPointer<KoPathShape> shape1(KoPathShape::createShapeFromPainterPath(path1));
     shape1->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(Qt::blue)));
 
     QScopedPointer<KoPathShape> shape2(KoPathShape::createShapeFromPainterPath(path2));
     shape2->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(Qt::red)));
 
     QScopedPointer<KoPathShape> clipShape1(KoPathShape::createShapeFromPainterPath(clipPath1));
     KoClipPath *koClipPath1 = new KoClipPath({clipShape1.take()}, KoFlake::UserSpaceOnUse);
     koClipPath1->setClipRule(Qt::WindingFill);
     shape1->setClipPath(koClipPath1);
 
     QScopedPointer<KoShapeGroup> group(new KoShapeGroup());
     {
         QList<KoShape*> shapes({shape1.take(), shape2.take()});
 
         KoShapeGroupCommand cmd(group.data(), shapes, false);
         cmd.redo();
     }
 
     QScopedPointer<KoPathShape> clipShape2(KoPathShape::createShapeFromPainterPath(clipPath2));
     KoClipPath *koClipPath2 = new KoClipPath({clipShape2.take()}, KoFlake::UserSpaceOnUse);
     koClipPath2->setClipRule(Qt::WindingFill);
     group->setClipPath(koClipPath2);
 
     SvgRenderTester::testRender(group.take(), "load", "clip_render_test", QSize(30,30));
 }
 
 void TestSvgParser::testKoClipPathRelativeRendering()
 {
     QPainterPath path1;
     path1.addRect(QRect(5,5,15,15));
 
     QPainterPath path2;
     path2.addRect(QRect(10,10,15,15));
 
     QPainterPath clipPath1;
     clipPath1.addRect(QRect(10, 0, 10, 30));
 
     QPainterPath clipPath2;
     clipPath2.moveTo(0,0);
     clipPath2.lineTo(1,0);
     clipPath2.lineTo(0.5,1);
     clipPath2.lineTo(0,0);
 
     QScopedPointer<KoPathShape> shape1(KoPathShape::createShapeFromPainterPath(path1));
     shape1->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(Qt::blue)));
 
     QScopedPointer<KoPathShape> shape2(KoPathShape::createShapeFromPainterPath(path2));
     shape2->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(Qt::red)));
 
     QScopedPointer<KoPathShape> clipShape1(KoPathShape::createShapeFromPainterPath(clipPath1));
     KoClipPath *koClipPath1 = new KoClipPath({clipShape1.take()}, KoFlake::UserSpaceOnUse);
     koClipPath1->setClipRule(Qt::WindingFill);
     shape1->setClipPath(koClipPath1);
 
     QScopedPointer<KoShapeGroup> group(new KoShapeGroup());
     {
         QList<KoShape*> shapes({shape1.take(), shape2.take()});
 
         KoShapeGroupCommand cmd(group.data(), shapes, false);
         cmd.redo();
     }
 
     QScopedPointer<KoPathShape> clipShape2(KoPathShape::createShapeFromPainterPath(clipPath2));
     KoClipPath *koClipPath2 = new KoClipPath({clipShape2.take()}, KoFlake::ObjectBoundingBox);
     koClipPath2->setClipRule(Qt::WindingFill);
     group->setClipPath(koClipPath2);
 
     SvgRenderTester::testRender(group.take(), "load", "relative_clip_render_test", QSize(30,30));
 }
 
 void TestSvgParser::testRenderClipPath_User()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<clipPath id=\"clip1\" clipPathUnits=\"userSpaceOnUse\">"
             "    <rect id=\"clipRect1\" x=\"10\" y=\"0\" width=\"10\" height=\"30\""
             "            fill=\"red\" stroke=\"none\" />"
             "    <rect id=\"clipRect1\" x=\"10\" y=\"0\" width=\"10\" height=\"30\""
             "            fill=\"yellow\" stroke=\"none\" />"
             "</clipPath>"
 
             "<clipPath id=\"clip2\" clipPathUnits=\"userSpaceOnUse\">"
             "    <path id=\"clipRect1\" d=\"M 0 7 L 30 7 15 30 0 7 z\""
             "            fill=\"red\" stroke=\"none\" />"
             "</clipPath>"
 
             "<g id=\"testRect\" clip-path=\"url(#clip2)\">"
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"15\""
             "        fill=\"blue\" stroke=\"none\" clip-path=\"url(#clip1)\"/>"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("clip_render_test", false);
 }
 
 void TestSvgParser::testRenderClipPath_Obb()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<clipPath id=\"clip1\" clipPathUnits=\"userSpaceOnUse\">"
             "    <rect id=\"clipRect1\" x=\"10\" y=\"0\" width=\"10\" height=\"30\""
             "            fill=\"red\" stroke=\"none\" />"
             "    <rect id=\"clipRect1\" x=\"10\" y=\"0\" width=\"10\" height=\"30\""
             "            fill=\"yellow\" stroke=\"none\" />"
             "</clipPath>"
 
             "<clipPath id=\"clip2\" clipPathUnits=\"objectBoundingBox\">"
             "    <path id=\"clipRect1\" d=\"M 0 0 L 1 0 0.5 1 0 0 z\""
             "            fill=\"red\" stroke=\"none\" />"
             "</clipPath>"
 
             "<g id=\"testRect\" clip-path=\"url(#clip2)\">"
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"15\""
             "        fill=\"blue\" stroke=\"none\" clip-path=\"url(#clip1)\"/>"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("relative_clip_render_test", false);
 }
 
 void TestSvgParser::testRenderClipPath_Obb_Transform()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<clipPath id=\"clip1\" clipPathUnits=\"userSpaceOnUse\""
             "    transform=\"rotate(90,15,15)\">"
             "    <rect id=\"clipRect1\" x=\"10\" y=\"0\" width=\"10\" height=\"30\""
             "            fill=\"red\" stroke=\"none\" />"
             "    <rect id=\"clipRect1\" x=\"10\" y=\"0\" width=\"10\" height=\"30\""
             "            fill=\"yellow\" stroke=\"none\" />"
             "</clipPath>"
 
             "<clipPath id=\"clip2\" clipPathUnits=\"objectBoundingBox\""
             "    transform=\"rotate(90 0.5 0.5)\">"
             "    <path id=\"clipRect1\" d=\"M 0 0 L 1 0 0.5 1 0 0 z\""
             "            fill=\"red\" stroke=\"none\" />"
             "</clipPath>"
 
             "<g id=\"testRect\" clip-path=\"url(#clip2)\">"
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"15\""
             "        fill=\"blue\" stroke=\"none\" clip-path=\"url(#clip1)\"/>"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("clip_render_test_rotated", false);
 }
 
 void TestSvgParser::testRenderClipMask_Obb()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             //"<defs>"
 
             "    <linearGradient id=\"Gradient\" gradientUnits=\"objectBoundingBox\""
             "        x1=\"0\" y1=\"0\" x2=\"1\" y2=\"0\">"
 
             "        <stop offset=\"0\" stop-color=\"white\" stop-opacity=\"0\" />"
             "        <stop offset=\"1\" stop-color=\"white\" stop-opacity=\"1\" />"
 
             "    </linearGradient>"
 
             "    <mask id=\"Mask\" maskUnits=\"objectBoundingBox\""
             "        maskContentUnits=\"objectBoundingBox\""
             "        x=\"0.2\" y=\"0.2\" width=\"0.6\" height=\"0.6\">"
 
             "        <rect x=\"0\" y=\"0\" width=\"1\" height=\"1\" fill=\"url(#Gradient)\" />"
 
             "    </mask>"
 
             //"</defs>"
 
 
             "<g id=\"testRect\">"
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"15\""
             "        fill=\"blue\" stroke=\"none\"/>"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\" mask=\"url(#Mask)\" />"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("clip_mask_obb", false);
 }
 
 void TestSvgParser::testRenderClipMask_User_Clip_Obb()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             //"<defs>"
 
             "    <linearGradient id=\"Gradient\" gradientUnits=\"objectBoundingBox\""
             "        x1=\"0\" y1=\"0\" x2=\"1\" y2=\"0\">"
 
             "        <stop offset=\"0\" stop-color=\"white\" stop-opacity=\"0\" />"
             "        <stop offset=\"1\" stop-color=\"white\" stop-opacity=\"1\" />"
 
             "    </linearGradient>"
 
             "    <mask id=\"Mask\" maskUnits=\"objectBoundingBox\""
             "        maskContentUnits=\"userSpaceOnUse\""
             "        x=\"0.2\" y=\"0.2\" width=\"0.6\" height=\"0.6\">"
 
             "        <rect x=\"10\" y=\"10\" width=\"15\" height=\"15\" fill=\"url(#Gradient)\" />"
 
             "    </mask>"
 
             //"</defs>"
 
 
             "<g id=\"testRect\">"
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"15\""
             "        fill=\"blue\" stroke=\"none\"/>"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\" mask=\"url(#Mask)\" />"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("clip_mask_obb", false);
 }
 
 void TestSvgParser::testRenderClipMask_User_Clip_User()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             //"<defs>"
 
             "    <linearGradient id=\"Gradient\" gradientUnits=\"objectBoundingBox\""
             "        x1=\"0\" y1=\"0\" x2=\"1\" y2=\"0\">"
 
             "        <stop offset=\"0\" stop-color=\"white\" stop-opacity=\"0\" />"
             "        <stop offset=\"1\" stop-color=\"white\" stop-opacity=\"1\" />"
 
             "    </linearGradient>"
 
             "    <mask id=\"Mask\" maskUnits=\"userSpaceOnUse\""
             "        maskContentUnits=\"userSpaceOnUse\""
             "        x=\"13\" y=\"13\" width=\"9\" height=\"9\">"
 
             "        <rect x=\"10\" y=\"10\" width=\"15\" height=\"15\" fill=\"url(#Gradient)\" />"
 
             "    </mask>"
 
             //"</defs>"
 
 
             "<g id=\"testRect\">"
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"15\""
             "        fill=\"blue\" stroke=\"none\"/>"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\" mask=\"url(#Mask)\" />"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("clip_mask_obb", false);
 }
 
 QByteArray fileFetcherFunc(const QString &name)
 {
     const QString fileName = TestUtil::fetchDataFileLazy(name);
     QFile file(fileName);
     KIS_ASSERT(file.exists());
     file.open(QIODevice::ReadOnly);
     return file.readAll();
 }
 
 void TestSvgParser::testRenderImage_AspectDefault()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"testRect\">"
             "    <rect id=\"testRect1\" x=\"2\" y=\"2\" width=\"26\" height=\"26\""
             "        fill=\"green\" stroke=\"none\"/>"
 
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"10\""
             "        fill=\"white\" stroke=\"none\"/>"
 
 
             "    <image x=\"5\" y=\"5\" width=\"15\" height=\"10\""
             "        xlink:href=\"svg_render/testing_ref_image.png\">"
 
             "        <title>My image</title>"
 
             "    </image>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.parser.setFileFetcher(fileFetcherFunc);
 
     t.test_standard_30px_72ppi("image_aspect_default", false);
 }
 
 void TestSvgParser::testRenderImage_AspectNone()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"testRect\">"
             "    <rect id=\"testRect1\" x=\"2\" y=\"2\" width=\"26\" height=\"26\""
             "        fill=\"green\" stroke=\"none\"/>"
 
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"10\""
             "        fill=\"white\" stroke=\"none\"/>"
 
 
             "    <image x=\"5\" y=\"5\" width=\"15\" height=\"10\""
             "        preserveAspectRatio=\"none\""
             "        xlink:href=\"svg_render/testing_ref_image.png\">"
 
             "        <title>My image</title>"
 
             "    </image>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
+    t.setFuzzyThreshold(5);
     t.parser.setFileFetcher(fileFetcherFunc);
 
     t.test_standard_30px_72ppi("image_aspect_none", false);
 }
 
 void TestSvgParser::testRenderImage_AspectMeet()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"testRect\">"
             "    <rect id=\"testRect1\" x=\"2\" y=\"2\" width=\"26\" height=\"26\""
             "        fill=\"green\" stroke=\"none\"/>"
 
             "    <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"10\""
             "        fill=\"white\" stroke=\"none\"/>"
 
 
             "    <image x=\"5\" y=\"5\" width=\"15\" height=\"10\""
             "        preserveAspectRatio=\"xMinYMin meet\""
             "        xlink:href=\"svg_render/testing_ref_image.png\">"
 
             "        <title>My image</title>"
 
             "    </image>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.parser.setFileFetcher(fileFetcherFunc);
 
     t.test_standard_30px_72ppi("image_aspect_meet", false);
 }
 
 void TestSvgParser::testRectShapeRoundUniformX()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <rect id=\"testRect\" x=\"5\" y=\"5\" width=\"20\" height=\"20\""
             "        rx=\"5\""
             "        fill=\"blue\" stroke=\"none\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("rect_5_5", false);
 }
 
 void TestSvgParser::testRectShapeRoundUniformY()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <rect id=\"testRect\" x=\"5\" y=\"5\" width=\"20\" height=\"20\""
             "        rx=\"5\""
             "        fill=\"blue\" stroke=\"none\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("rect_5_5", false);
 }
 
 void TestSvgParser::testRectShapeRoundXY()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <rect id=\"testRect\" x=\"5\" y=\"5\" width=\"20\" height=\"20\""
             "        rx=\"5\" ry=\"10\""
             "        fill=\"blue\" stroke=\"none\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("rect_5_10", false);
 }
 
 void TestSvgParser::testRectShapeRoundXYOverflow()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <rect id=\"testRect\" x=\"5\" y=\"5\" width=\"20\" height=\"20\""
             "        rx=\"5\" ry=\"25\""
             "        fill=\"blue\" stroke=\"none\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("rect_5_10", false);
 }
 
 void TestSvgParser::testCircleShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <circle id=\"testRect\" cx=\"15\" cy=\"15\" r=\"10\""
             "        fill=\"blue\" stroke=\"white\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("circle", false);
 }
 
 void TestSvgParser::testEllipseShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <ellipse id=\"testRect\" cx=\"15\" cy=\"15\" rx=\"10\" ry=\"5\""
             "        fill=\"blue\" stroke=\"white\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("ellipse", false);
 }
 
 void TestSvgParser::testLineShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <line id=\"testRect\" x1=\"5\" y1=\"5\" x2=\"25\" y2=\"15\""
             "        fill=\"blue\" stroke=\"white\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("line", false);
 }
 
 void TestSvgParser::testPolylineShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <polyline id=\"testRect\" points=\"5,5 10, 5 10,10 5,10 \n"
             "        5 ,15 15 , 15 15,20 20,20 20,10 25,10 25,25 5,25\""
             "        fill=\"red\" stroke=\"white\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("polyline", false);
 }
 
 void TestSvgParser::testPolygonShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <polygon id=\"testRect\" points=\"5,5 10, 5 10,10 5,10 \n"
             "        5 ,15 15 , 15 15,20 20,20 20,10 25,10 25,25 5,25\""
             "        fill=\"red\" stroke=\"white\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("polygon", false);
 }
 
 void TestSvgParser::testPathShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "    <path id=\"testRect\""
             "        d=\"M 5,5 h 5 l 0,5 L5,10 l 0,5 l10,0 v5 l 5, 0 L20, 10 l 5,0 L 25,25 L 5,25 z\""
             "        fill=\"red\" stroke=\"white\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("polygon", false);
 }
 
 void TestSvgParser::testDefsHidden()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"testRect\">"
             "    <defs>"
             "        <rect id=\"testRect1\" x=\"5\" y=\"5\" width=\"15\" height=\"15\""
             "            fill=\"blue\" stroke=\"none\"/>"
             "    </defs>"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("test_defs_hidden", false);
 }
 
 void TestSvgParser::testDefsUseInheritance()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
 
 
             "<g id=\"unrenderedRect\" fill=\"green\" >"
             "    <defs>"
             "        <rect id=\"testRect1\" x=\"1\" y=\"1\" width=\"15\" height=\"15\""
             "            stroke=\"none\"/>"
             "    </defs>"
             "</g>"
 
 
             /**
              * NOTES:
              * 1) width/height attributes for <use> are not implemented yet
              * 2) x and y are summed up
              * 3) stroke="white" is overridden by the original templated object
              * 4) fill="green" attribute from <defs> is not inherited
              */
 
             "<g id=\"testRect\" fill=\"blue\" >"
             "    <use x=\"4\" y=\"4\" xlink:href=\"#testRect1\""
             "        stroke=\"white\" stroke-width=\"1\" />"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\"/>"
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("defs_use_inheritance", false);
 }
 
 void TestSvgParser::testUseWithoutDefs()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             // technical rect for rendering
             "<g id=\"testRect\">"
 
             "<g id=\"renderedRect1\" fill=\"green\" >"
             "    <rect id=\"testRect1\" x=\"1\" y=\"1\" width=\"15\" height=\"15\""
             "        stroke=\"none\"/>"
             "</g>"
 
 
             /**
              * NOTES:
              * 1) width/height attributes for <use> are not implemented yet
              * 2) x and y are summed up
              * 3) stroke="white" is overridden by the original templated object
              * 4) fill="green" attribute from <defs> is not inherited
              */
 
             "<g id=\"renderedRect2\" fill=\"blue\" >"
             "    <use x=\"4\" y=\"4\" xlink:href=\"#testRect1\""
             "        stroke=\"white\" stroke-width=\"1\" />"
 
             "    <rect id=\"testRect2\" x=\"10\" y=\"10\" width=\"15\" height=\"15\""
             "        fill=\"red\" stroke=\"none\"/>"
             "</g>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("use_without_defs", false);
 }
 
 void TestSvgParser::testMarkersAutoOrientation()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<marker id=\"SimpleRectMarker\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"red\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<path id=\"testRect\""
             "    style=\"fill:none;stroke:#000000;stroke-width:1px;marker-start:url(#SimpleRectMarker);marker-end:url(#SimpleRectMarker);marker-mid:url(#SimpleRectMarker)\""
             "    d=\"M5,15 C5,5 25,5 25,15 L15,25\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("markers", false);
 }
 
 void TestSvgParser::testMarkersAutoOrientationScaled()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<marker id=\"SimpleRectMarker\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"red\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<path id=\"testRect\""
             "    style=\"fill:none;stroke:#000000;stroke-width:2px;marker-start:url(#SimpleRectMarker);marker-end:url(#SimpleRectMarker);marker-mid:url(#SimpleRectMarker)\""
             "    d=\"M5,15 C5,5 25,5 25,15 L15,25\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("markers_scaled", false);
 }
 
 void TestSvgParser::testMarkersAutoOrientationScaledUserCoordinates()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<marker id=\"SimpleRectMarker\""
             "    markerUnits = \"userSpaceOnUse\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"red\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<path id=\"testRect\""
             "    style=\"fill:none;stroke:#000000;stroke-width:2px;marker-start:url(#SimpleRectMarker);marker-end:url(#SimpleRectMarker);marker-mid:url(#SimpleRectMarker)\""
             "    d=\"M5,15 C5,5 25,5 25,15 L15,25\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("markers_user_coordinates", false);
 }
 
 void TestSvgParser::testMarkersCustomOrientation()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<marker id=\"SimpleRectMarker\""
             "    orient=\"45\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"red\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<path id=\"testRect\""
             "    style=\"fill:none;stroke:#000000;stroke-width:1px;marker-start:url(#SimpleRectMarker);marker-end:url(#SimpleRectMarker);marker-mid:url(#SimpleRectMarker)\""
             "    d=\"M5,15 C5,5 25,5 25,15 L15,25\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("markers_custom_orientation", false);
 }
 
 void TestSvgParser::testMarkersDifferent()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<marker id=\"SimpleRectMarker1\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"red\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<marker id=\"SimpleRectMarker2\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"green\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<marker id=\"SimpleRectMarker3\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"blue\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<path id=\"testRect\""
             "    style=\"fill:none;stroke:#000000;stroke-width:1px;marker-start:url(#SimpleRectMarker1);marker-end:url(#SimpleRectMarker2);marker-mid:url(#SimpleRectMarker3)\""
             "    d=\"M5,15 C5,5 25,5 25,15 L15,25\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("markers_different", false);
 }
 
 void TestSvgParser::testMarkersFillAsShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<defs>"
             "    <linearGradient id=\"testGrad\" x1=\"0%\" y1=\"50%\" x2=\"100%\" y2=\"50%\">"
             "        <stop offset=\"5%\" stop-color=\"#F60\" />"
             "        <stop offset=\"80%\" stop-color=\"#FF6\" />"
             "    </linearGradient>"
 
             "    <marker id=\"SimpleRectMarker\""
             "        orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "        <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "            fill=\"red\" stroke=\"none\"/>"
             "        <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "            fill=\"yellow\" stroke=\"none\"/>"
             "        <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "            fill=\"white\" stroke=\"none\"/>"
             "    </marker>"
 
             "</defs>"
 
             "<path id=\"testRect\""
             "    style=\"fill:none;stroke:url(#testGrad) magenta;stroke-width:2px;marker-start:url(#SimpleRectMarker);marker-end:url(#SimpleRectMarker);marker-mid:url(#SimpleRectMarker);krita|marker-fill-method:auto\""
             "    d=\"M5,15 C5,5 25,5 25,15 L15,25\"/>"
             //"    d=\"M5,15 L25,15\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("markers_scaled_fill_as_shape", false);
 }
 
 void TestSvgParser::testMarkersOnClosedPath()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<marker id=\"SimpleRectMarker1\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"9\" y=\"9\" width=\"7\" height=\"7\""
             "        fill=\"red\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<marker id=\"SimpleRectMarker2\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"green\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<marker id=\"SimpleRectMarker3\""
             "    orient=\"auto\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"blue\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<path id=\"testRect\""
             "    style=\"fill:none;stroke:#000000;stroke-width:1px;marker-start:url(#SimpleRectMarker1);marker-end:url(#SimpleRectMarker2);marker-mid:url(#SimpleRectMarker3)\""
             "    d=\"M5,15 C5,5 25,5 25,15 L15,25 z\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("markers_on_closed_path", false);
 }
 
 
 void TestSvgParser::testGradientRecoveringTrasnform()
 {
     // used for experimenting purposes only!
 
     QImage image(100,100,QImage::Format_ARGB32);
     image.fill(0);
     QPainter painter(&image);
 
     painter.setPen(QPen(Qt::black, 0));
 
 
     QLinearGradient gradient(0, 0.5, 1, 0.5);
     gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
 
     //QLinearGradient gradient(0, 50, 100, 50);
     //gradient.setCoordinateMode(QGradient::LogicalMode);
 
     gradient.setColorAt(0.0, Qt::red);
     gradient.setColorAt(1.0, Qt::blue);
 
     QTransform gradientTrasnform;
     gradientTrasnform.shear(0.2, 0);
 
     {
         QBrush brush(gradient);
         brush.setTransform(gradientTrasnform);
         painter.setBrush(brush);
     }
 
     QRect mainShape(3,3,94,94);
     painter.drawRect(mainShape);
 
     QTransform gradientToUser(mainShape.width(), 0, 0, mainShape.height(),
                               mainShape.x(), mainShape.y());
 
     QRect smallShape(0,0,20,20);
     QTransform smallShapeTransform;
 
     {
         smallShapeTransform =
             QTransform::fromTranslate(-smallShape.center().x(), -smallShape.center().y());
 
         QTransform r; r.rotate(90);
         smallShapeTransform *= r;
 
         smallShapeTransform *=
             QTransform::fromTranslate(mainShape.center().x(), mainShape.center().y());
     }
 
 
     {
         gradient.setCoordinateMode(QGradient::LogicalMode);
         QBrush brush(gradient);
         brush.setTransform(gradientTrasnform * gradientToUser * smallShapeTransform.inverted());
         painter.setBrush(brush);
         painter.setPen(Qt::NoPen);
     }
 
     painter.setTransform(smallShapeTransform);
     painter.drawRect(smallShape);
 
     //image.save("gradient_recovering_transform.png");
 }
 
 void TestSvgParser::testMarkersAngularUnits()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             // start
             "<marker id=\"SimpleRectMarker1\""
             "    orient=\"45deg\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"red\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             // end
             "<marker id=\"SimpleRectMarker2\""
             "    orient=\"200grad\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"green\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             // mid
             "<marker id=\"SimpleRectMarker3\""
             "    orient=\"-1.57rad\" refY=\"12.5\" refX=\"12.5\" >"
 
             "    <rect id=\"markerRect\" x=\"10\" y=\"10\" width=\"5\" height=\"5\""
             "        fill=\"blue\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"14\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"yellow\" stroke=\"none\"/>"
             "    <rect id=\"markerRect\" x=\"12\" y=\"12\" width=\"1\" height=\"1\""
             "        fill=\"white\" stroke=\"none\"/>"
             "</marker>"
 
             "<path id=\"testRect\""
             "    style=\"fill:none;stroke:#000000;stroke-width:1px;marker-start:url(#SimpleRectMarker1);marker-end:url(#SimpleRectMarker2);marker-mid:url(#SimpleRectMarker3)\""
             "    d=\"M5,15 C5,5 25,5 25,15 L15,25\"/>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("markers_angular_units", false);
 }
 
 #include "KoParameterShape.h"
 
 void TestSvgParser::testSodipodiArcShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\""
             "    xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\""
             ">"
 
             "<path"
             "    fill=\"red\" stroke=\"black\""
             "    id=\"testRect\""
 
             "    sodipodi:type=\"arc\""
             "    sodipodi:cx=\"15.464287\""
             "    sodipodi:cy=\"14.517863\""
             "    sodipodi:rx=\"6.25\""
             "    sodipodi:ry=\"8.5\""
             "    sodipodi:start=\"5.5346039\""
             "    sodipodi:end=\"4.0381334\""
             //"    d=\"m 20.043381,8.7327624 a 6.25,8.5 0 0 1 1.053863,9.4677386 6.25,8.5 0 0 1 -6.094908,4.794113 6.25,8.5 0 0 1 -5.5086474,-5.963709 6.25,8.5 0 0 1 2.0686234,-9.1530031 l 3.901975,6.6399611 z\" />"
             "    d=\" some weird unparsable text \" />"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("sodipodi_closed_arc", false);
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(dynamic_cast<KoParameterShape*>(shape));
 }
 
 void TestSvgParser::testSodipodiArcShapeOpen()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\""
             "    xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\""
             ">"
 
             "<path"
             "    fill=\"red\" stroke=\"black\""
             "    id=\"testRect\""
 
             "    sodipodi:type=\"arc\""
             "    sodipodi:open=\"true\""
             "    sodipodi:cx=\"15.464287\""
             "    sodipodi:cy=\"14.517863\""
             "    sodipodi:rx=\"6.25\""
             "    sodipodi:ry=\"8.5\""
             "    sodipodi:start=\"5.5346039\""
             "    sodipodi:end=\"4.0381334\""
             //"    d=\"m 20.043381,8.7327624 a 6.25,8.5 0 0 1 1.053863,9.4677386 6.25,8.5 0 0 1 -6.094908,4.794113 6.25,8.5 0 0 1 -5.5086474,-5.963709 6.25,8.5 0 0 1 2.0686234,-9.1530031 l 3.901975,6.6399611 z\" />"
             "    d=\" some weird unparsable text \" />"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("sodipodi_open_arc", false);
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(dynamic_cast<KoParameterShape*>(shape));
 }
 
 void TestSvgParser::testKritaChordShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\""
             "    xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\""
             ">"
 
             "<path"
             "    fill=\"red\" stroke=\"black\""
             "    id=\"testRect\""
 
             "    krita:type=\"arc\""
             "    krita:arcType=\"chord\""
             "    krita:cx=\"15.464287\""
             "    krita:cy=\"14.517863\""
             "    krita:rx=\"6.25\""
             "    krita:ry=\"8.5\""
             "    krita:start=\"5.5346039\""
             "    krita:end=\"4.0381334\""
             //"    d=\"m 20.043381,8.7327624 a 6.25,8.5 0 0 1 1.053863,9.4677386 6.25,8.5 0 0 1 -6.094908,4.794113 6.25,8.5 0 0 1 -5.5086474,-5.963709 6.25,8.5 0 0 1 2.0686234,-9.1530031 l 3.901975,6.6399611 z\" />"
             "    d=\" some weird unparsable text \" />"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("sodipodi_chord_arc", false);
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(dynamic_cast<KoParameterShape*>(shape));
 }
 
 void TestSvgParser::testSodipodiChordShape()
 {
     const QString data =
             "<svg width=\"30px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\""
             "    xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\""
             ">"
 
             "<path"
             "    fill=\"red\" stroke=\"black\""
             "    id=\"testRect\""
 
             "    sodipodi:type=\"arc\""
             "    sodipodi:arc-type=\"chord\""
             "    sodipodi:open=\"true\""
             "    sodipodi:cx=\"15.464287\""
             "    sodipodi:cy=\"14.517863\""
             "    sodipodi:rx=\"6.25\""
             "    sodipodi:ry=\"8.5\""
             "    sodipodi:start=\"5.5346039\""
             "    sodipodi:end=\"4.0381334\""
             //"    d=\"m 20.043381,8.7327624 a 6.25,8.5 0 0 1 1.053863,9.4677386 6.25,8.5 0 0 1 -6.094908,4.794113 6.25,8.5 0 0 1 -5.5086474,-5.963709 6.25,8.5 0 0 1 2.0686234,-9.1530031 l 3.901975,6.6399611 z\" />"
             "    d=\" some weird unparsable text \" />"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard_30px_72ppi("sodipodi_chord_arc", false);
 
     KoShape *shape = t.findShape("testRect");
     QVERIFY(dynamic_cast<KoParameterShape*>(shape));
 }
 
 
 QTEST_MAIN(TestSvgParser)
diff --git a/libs/flake/tests/TestSvgText.cpp b/libs/flake/tests/TestSvgText.cpp
index 1e42bdbc5d..9d11c16d00 100644
--- a/libs/flake/tests/TestSvgText.cpp
+++ b/libs/flake/tests/TestSvgText.cpp
@@ -1,1207 +1,1220 @@
 /*
  *  Copyright (c) 2017 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 "TestSvgText.h"
 
 #include <QTest>
 
 #include "SvgParserTestingUtils.h"
 #include <text/KoSvgText.h>
 #include <text/KoSvgTextProperties.h>
 #include "KoSvgTextShapeMarkupConverter.h"
 
 #include <SvgLoadingContext.h>
 #include <SvgGraphicContext.h>
 #include <QFont>
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              int newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).toInt() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
 }
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              KoSvgText::AutoValue newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).value<KoSvgText::AutoValue>() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
     QCOMPARE(props.property(id), QVariant::fromValue(newValue));
 }
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              qreal newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).toReal() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
 }
 
 
 void TestSvgText::testTextProperties()
 {
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     KoSvgTextProperties props;
 
     addProp(context, props, "writing-mode", "tb-rl", KoSvgTextProperties::WritingModeId, KoSvgText::TopToBottom);
     addProp(context, props, "writing-mode", "rl", KoSvgTextProperties::WritingModeId, KoSvgText::RightToLeft);
 
     addProp(context, props, "glyph-orientation-vertical", "auto", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue());
     addProp(context, props, "glyph-orientation-vertical", "0", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(0));
     addProp(context, props, "glyph-orientation-vertical", "90", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "95", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "175", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI));
     addProp(context, props, "glyph-orientation-vertical", "280", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(3 * M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "350", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(0));
     addProp(context, props, "glyph-orientation-vertical", "105", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
 
     addProp(context, props, "glyph-orientation-horizontal", "0", KoSvgTextProperties::GlyphOrientationHorizontalId, 0.0);
     addProp(context, props, "glyph-orientation-horizontal", "90", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI_2);
     addProp(context, props, "glyph-orientation-horizontal", "95", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI_2);
     addProp(context, props, "glyph-orientation-horizontal", "175", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI);
     addProp(context, props, "glyph-orientation-horizontal", "280", KoSvgTextProperties::GlyphOrientationHorizontalId, 3 * M_PI_2);
 
     addProp(context, props, "direction", "rtl", KoSvgTextProperties::WritingModeId, KoSvgText::DirectionRightToLeft);
     addProp(context, props, "unicode-bidi", "embed", KoSvgTextProperties::UnicodeBidiId, KoSvgText::BidiEmbed);
     addProp(context, props, "unicode-bidi", "bidi-override", KoSvgTextProperties::UnicodeBidiId, KoSvgText::BidiOverride);
 
 
     addProp(context, props, "text-anchor", "middle", KoSvgTextProperties::TextAnchorId, KoSvgText::AnchorMiddle);
     addProp(context, props, "dominant-baseline", "ideographic", KoSvgTextProperties::DominantBaselineId, KoSvgText::DominantBaselineIdeographic);
     addProp(context, props, "alignment-baseline", "alphabetic", KoSvgTextProperties::AlignmentBaselineId, KoSvgText::AlignmentBaselineAlphabetic);
     addProp(context, props, "baseline-shift", "sub", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftSub);
     addProp(context, props, "baseline-shift", "super", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftSuper);
     addProp(context, props, "baseline-shift", "baseline", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftNone);
 
     addProp(context, props, "baseline-shift", "10%", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftPercentage);
     QCOMPARE(props.property(KoSvgTextProperties::BaselineShiftValueId).toDouble(), 0.1);
 
     context.currentGC()->font.setPointSizeF(180);
 
     addProp(context, props, "baseline-shift", "36", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftPercentage);
     QCOMPARE(props.property(KoSvgTextProperties::BaselineShiftValueId).toDouble(), 0.2);
 
     addProp(context, props, "kerning", "auto", KoSvgTextProperties::KerningId, KoSvgText::AutoValue());
     addProp(context, props, "kerning", "20", KoSvgTextProperties::KerningId, KoSvgText::AutoValue(20.0));
 
     addProp(context, props, "letter-spacing", "normal", KoSvgTextProperties::LetterSpacingId, KoSvgText::AutoValue());
     addProp(context, props, "letter-spacing", "20", KoSvgTextProperties::LetterSpacingId, KoSvgText::AutoValue(20.0));
 
     addProp(context, props, "word-spacing", "normal", KoSvgTextProperties::WordSpacingId, KoSvgText::AutoValue());
     addProp(context, props, "word-spacing", "20", KoSvgTextProperties::WordSpacingId, KoSvgText::AutoValue(20.0));
 }
 
 void TestSvgText::testDefaultTextProperties()
 {
     KoSvgTextProperties props;
 
     QVERIFY(props.isEmpty());
     QVERIFY(!props.hasProperty(KoSvgTextProperties::UnicodeBidiId));
 
     QVERIFY(KoSvgTextProperties::defaultProperties().hasProperty(KoSvgTextProperties::UnicodeBidiId));
     QCOMPARE(KoSvgTextProperties::defaultProperties().property(KoSvgTextProperties::UnicodeBidiId).toInt(), int(KoSvgText::BidiNormal));
 
     props = KoSvgTextProperties::defaultProperties();
 
     QVERIFY(props.hasProperty(KoSvgTextProperties::UnicodeBidiId));
     QCOMPARE(props.property(KoSvgTextProperties::UnicodeBidiId).toInt(), int(KoSvgText::BidiNormal));
 }
 
 void TestSvgText::testTextPropertiesDifference()
 {
     using namespace KoSvgText;
 
     KoSvgTextProperties props;
 
     props.setProperty(KoSvgTextProperties::WritingModeId, RightToLeft);
     props.setProperty(KoSvgTextProperties::DirectionId, DirectionRightToLeft);
     props.setProperty(KoSvgTextProperties::UnicodeBidiId, BidiEmbed);
     props.setProperty(KoSvgTextProperties::TextAnchorId, AnchorEnd);
     props.setProperty(KoSvgTextProperties::DominantBaselineId, DominantBaselineNoChange);
     props.setProperty(KoSvgTextProperties::AlignmentBaselineId, AlignmentBaselineIdeographic);
     props.setProperty(KoSvgTextProperties::BaselineShiftModeId, ShiftPercentage);
     props.setProperty(KoSvgTextProperties::BaselineShiftValueId, 0.5);
     props.setProperty(KoSvgTextProperties::KerningId, fromAutoValue(AutoValue(10)));
     props.setProperty(KoSvgTextProperties::GlyphOrientationVerticalId, fromAutoValue(AutoValue(90)));
     props.setProperty(KoSvgTextProperties::GlyphOrientationHorizontalId, fromAutoValue(AutoValue(180)));
     props.setProperty(KoSvgTextProperties::LetterSpacingId, fromAutoValue(AutoValue(20)));
     props.setProperty(KoSvgTextProperties::WordSpacingId, fromAutoValue(AutoValue(30)));
 
     KoSvgTextProperties newProps = props;
 
     newProps.setProperty(KoSvgTextProperties::KerningId, fromAutoValue(AutoValue(11)));
     newProps.setProperty(KoSvgTextProperties::LetterSpacingId, fromAutoValue(AutoValue(21)));
 
     KoSvgTextProperties diff = newProps.ownProperties(props);
 
     QVERIFY(diff.hasProperty(KoSvgTextProperties::KerningId));
     QVERIFY(diff.hasProperty(KoSvgTextProperties::LetterSpacingId));
 
     QVERIFY(!diff.hasProperty(KoSvgTextProperties::WritingModeId));
     QVERIFY(!diff.hasProperty(KoSvgTextProperties::DirectionId));
 
 
 }
 
 void TestSvgText::testParseFontStyles()
 {
     const QString data =
             "<text x=\"7\" y=\"7\""
             "    font-family=\"Verdana , \'Times New Roman\', serif\" font-size=\"15\" font-style=\"oblique\" fill=\"blue\""
             "    font-stretch=\"extra-condensed\""
             "    font-size-adjust=\"0.56\"" //// not implemented! should issue a warning!
             "    font=\"bold italic large Palatino, serif\"" //// not implemented! should issue a warning!
             "    font-variant=\"small-caps\" font-weight=\"600\" >"
             "    Hello, out there"
             "</text>";
 
     KoXmlDocument doc;
     QVERIFY(doc.setContent(data.toLatin1()));
     KoXmlElement root = doc.documentElement();
 
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     SvgStyles styles = context.styleParser().collectStyles(root);
     context.styleParser().parseFont(styles);
 
     //QCOMPARE(styles.size(), 3);
 
     // TODO: multiple fonts!
     QCOMPARE(context.currentGC()->font.family(), QString("Verdana"));
 
     {
         QStringList expectedFonts = {"Verdana", "Times New Roman", "serif"};
         QCOMPARE(context.currentGC()->fontFamiliesList, expectedFonts);
     }
 
     QCOMPARE(context.currentGC()->font.pointSizeF(), 15.0);
     QCOMPARE(context.currentGC()->font.style(), QFont::StyleOblique);
     QCOMPARE(context.currentGC()->font.capitalization(), QFont::SmallCaps);
     QCOMPARE(context.currentGC()->font.weight(), 66);
 
     {
         SvgStyles fontModifier;
         fontModifier["font-weight"] = "bolder";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.weight(), 75);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["font-weight"] = "lighter";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.weight(), 66);
     }
 
     QCOMPARE(context.currentGC()->font.stretch(), int(QFont::ExtraCondensed));
 
     {
         SvgStyles fontModifier;
         fontModifier["font-stretch"] = "narrower";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.stretch(), int(QFont::UltraCondensed));
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["font-stretch"] = "wider";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.stretch(), int(QFont::ExtraCondensed));
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "underline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.underline(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "overline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.overline(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "line-through";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.strikeOut(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = " line-through overline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.underline(), false);
         QCOMPARE(context.currentGC()->font.strikeOut(), true);
         QCOMPARE(context.currentGC()->font.overline(), true);
     }
 
 }
 
 void TestSvgText::testParseTextStyles()
 {
     const QString data =
             "<text x=\"7\" y=\"7\""
             "    font-family=\"Verdana\" font-size=\"15\" font-style=\"oblique\" fill=\"blue\""
             "    writing-mode=\"tb-rl\" "
             "    glyph-orientation-vertical=\"90\" >"
             "    Hello, out there"
             "</text>";
 
     KoXmlDocument doc;
     QVERIFY(doc.setContent(data.toLatin1()));
     KoXmlElement root = doc.documentElement();
 
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     SvgStyles styles = context.styleParser().collectStyles(root);
     context.styleParser().parseFont(styles);
 
     QCOMPARE(context.currentGC()->font.family(), QString("Verdana"));
 
     KoSvgTextProperties &props = context.currentGC()->textProperties;
 
     QCOMPARE(props.property(KoSvgTextProperties::WritingModeId).toInt(), int(KoSvgText::TopToBottom));
     QCOMPARE(props.property(KoSvgTextProperties::GlyphOrientationVerticalId).value<KoSvgText::AutoValue>(), KoSvgText::AutoValue(M_PI_2));
 
 }
 
 #include <text/KoSvgTextShape.h>
 #include <text/KoSvgTextChunkShape.h>
 #include <text/KoSvgTextChunkShapeLayoutInterface.h>
 
 void TestSvgText::testSimpleText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        Hello, out there!"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_simple", QSize(175, 40), 72.0);
 
     KoShape *shape = t.findShape("testRect");
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     QVERIFY(chunkShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(shape));
 
     QCOMPARE(chunkShape->shapeCount(), 0);
     QCOMPARE(chunkShape->layoutInterface()->isTextNode(), true);
 
     QCOMPARE(chunkShape->layoutInterface()->numChars(), 17);
     QCOMPARE(chunkShape->layoutInterface()->nodeText(), QString("Hello, out there!"));
 
     QVector<KoSvgText::CharTransformation> transform = chunkShape->layoutInterface()->localCharTransformations();
     QCOMPARE(transform.size(), 1);
     QVERIFY(bool(transform[0].xPos));
     QVERIFY(bool(transform[0].yPos));
     QVERIFY(!transform[0].dxPos);
     QVERIFY(!transform[0].dyPos);
     QVERIFY(!transform[0].rotate);
 
     QCOMPARE(*transform[0].xPos, 7.0);
     QCOMPARE(*transform[0].yPos, 27.0);
 
     QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
             chunkShape->layoutInterface()->collectSubChunks();
 
     QCOMPARE(subChunks.size(), 1);
     QCOMPARE(subChunks[0].text.size(), 17);
     //qDebug() << ppVar(subChunks[0].text);
     //qDebug() << ppVar(subChunks[0].transformation);
     //qDebug() << ppVar(subChunks[0].format);
 
 }
 
 inline KoSvgTextChunkShape* toChunkShape(KoShape *shape) {
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     KIS_ASSERT(chunkShape);
     return chunkShape;
 }
 
 void TestSvgText::testComplexText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\" dx=\"0,1,2,3,4,5,6,7,8\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        Hello, <tspan fill=\"red\" x=\"20\" y=\"46\" text-anchor=\"start\">ou"
             "t</tspan> there <![CDATA[cool cdata --> nice work]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_complex", QSize(385, 56), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
     QCOMPARE(baseShape->shapeCount(), 4);
     QCOMPARE(baseShape->layoutInterface()->isTextNode(), false);
     QCOMPARE(baseShape->layoutInterface()->numChars(), 41);
 
     {   // chunk 0: "Hello, "
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[0]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 7);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("Hello, "));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 7);
         QVERIFY(bool(transform[0].xPos));
         QVERIFY(!bool(transform[1].xPos));
 
         for (int i = 0; i < 7; i++) {
             QVERIFY(!i || bool(transform[i].dxPos));
 
             if (i) {
                 QCOMPARE(*transform[i].dxPos, qreal(i));
             }
         }
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 7);
         QCOMPARE(subChunks[0].text.size(), 1);
         QCOMPARE(*subChunks[0].transformation.xPos, 7.0);
         QVERIFY(!subChunks[1].transformation.xPos);
     }
 
     {   // chunk 1: "out"
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[1]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 3);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("out"));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 2);
         QVERIFY(bool(transform[0].xPos));
         QVERIFY(!bool(transform[1].xPos));
 
         for (int i = 0; i < 2; i++) {
             QVERIFY(bool(transform[i].dxPos));
             QCOMPARE(*transform[i].dxPos, qreal(i + 7));
         }
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 2);
         QCOMPARE(subChunks[0].text.size(), 1);
         QCOMPARE(subChunks[1].text.size(), 2);
     }
 
     {   // chunk 2: " there "
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[2]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 7);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString(" there "));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 0);
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 1);
         QCOMPARE(subChunks[0].text.size(), 7);
     }
 
     {   // chunk 3: "cool cdata --> nice work"
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[3]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 24);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("cool cdata --> nice work"));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 0);
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 1);
         QCOMPARE(subChunks[0].text.size(), 24);
     }
 }
 
 void TestSvgText::testHindiText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"24\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"FreeSans\" font-size=\"15\" fill=\"blue\" >"
             "मौखिक रूप से हिंदी के काफी सामान"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
+
+    QFont testFont("FreeSans");
+    if (!QFontInfo(testFont).exactMatch()) {
+        QEXPECT_FAIL(0, "FreeSans found is *not* found! Hindi rendering might be broken!", Continue);
+    }
+
     t.test_standard("text_hindi", QSize(260, 30), 72);
 }
 
 void TestSvgText::testTextBaselineShift()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"29\" "
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan>text<tspan baseline-shift=\"super\">super </tspan>normal<tspan baseline-shift=\"sub\">sub</tspan></tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard("text_baseline_shift", QSize(180, 40), 72);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 void TestSvgText::testTextSpacing()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"5\" y=\"24\" "
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan x=\"5\" dy=\"0.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" letter-spacing=\"4.0\">Lorem ipsum (ls=4)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" letter-spacing=\"-2.0\">Lorem ipsum (ls=-2)</tspan>"
 
             "        <tspan x=\"5\" dy=\"2.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" word-spacing=\"4.0\">Lorem ipsum (ws=4)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" word-spacing=\"-2.0\">Lorem ipsum (ws=-2)</tspan>"
 
             "        <tspan x=\"5\" dy=\"2.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"0.0\">Lorem ipsum (k=0)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"2.0\">Lorem ipsum (k=2)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"2.0\" letter-spacing=\"2.0\">Lorem ipsum (k=2,ls=2)</tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
+    t.setFuzzyThreshold(5);
     t.test_standard("text_letter_word_spacing", QSize(340, 250), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 void TestSvgText::testTextDecorations()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"24\" "
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan x=\"20\" dy=\"0.0em\" text-decoration=\"underline\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.5em\" text-decoration=\"overline\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.0em\" text-decoration=\"line-through\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.0em\" text-decoration=\"underline\">Lorem <tspan fill=\"red\">ipsum</tspan> (WRONG!!!)</tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
+    t.setFuzzyThreshold(5);
     t.test_standard("text_decorations", QSize(290, 135), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 void TestSvgText::testRightToLeft()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"20\" y=\"34\" "
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" text-anchor=\"end\">"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" text-anchor=\"end\">"
 
             "        <tspan x=\"250\" dy=\"0.0em\" text-anchor=\"middle\" direction=\"rtl\">aa bb cc dd</tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"rtl\">حادثتا السفينتين «بسين Bassein» و«فايبر Viper»</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"150\" dy=\"2.0em\" text-anchor=\"start\" direction=\"ltr\">aa bb حادثتا السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"350\" dy=\"2.0em\" text-anchor=\"start\" direction=\"rtl\">aa bb حادثتا السفينتين بسين cc dd </tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"150\" dy=\"2.0em\" text-anchor=\"start\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"350\" dy=\"2.0em\" text-anchor=\"end\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">الناطقون: 295 مليون - 422 مليون</tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">Spoken: <tspan direction=\"rtl\" unicode-bidi=\"embed\">295 مليون - 422 مليون </tspan></tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">aa bb <tspan direction=\"rtl\" unicode-bidi=\"bidi-override\">c1 c2 c3 c4</tspan> dd ee</tspan>"
 
 
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_right_to_left", QSize(500,450), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 #include <QTextLayout>
 #include <QPainter>
 
 void TestSvgText::testQtBidi()
 {
     // Arabic text sample from Wikipedia:
     // https://ar.wikipedia.org/wiki/%D8%A5%D9%85%D8%A7%D8%B1%D8%A7%D8%AA_%D8%A7%D9%84%D8%B3%D8%A7%D8%AD%D9%84_%D8%A7%D9%84%D9%85%D8%AA%D8%B5%D8%A7%D9%84%D8%AD
 
     QStringList ltrText;
     ltrText << "aa bb cc dd";
     ltrText << "aa bb حادثتا السفينتين بسين cc dd";
     ltrText << "aa bb \u202ec1c2 d3d4\u202C ee ff";
 
     QStringList rtlText;
     rtlText << "حادثتا السفينتين «بسين Bassein» و«فايبر Viper»";
     rtlText << "حادثتا السفينتين «بسين aa bb cc dd» و«فايبر Viper»";
 
 
     QImage canvas(500,500,QImage::Format_ARGB32);
     QPainter gc(&canvas);
     QPointF pos(15,15);
 
 
     QVector<QStringList> textSamples;
     textSamples << ltrText;
     textSamples << rtlText;
 
     QVector<Qt::LayoutDirection> textDirections;
     textDirections << Qt::LeftToRight;
     textDirections << Qt::RightToLeft;
 
     for (int i = 0; i < textSamples.size(); i++) {
         Q_FOREACH (const QString str, textSamples[i]) {
             QTextOption option;
             option.setTextDirection(textDirections[i]);
             option.setUseDesignMetrics(true);
 
             QTextLayout layout;
 
             layout.setText(str);
             layout.setFont(QFont("serif", 15.0));
             layout.setCacheEnabled(true);
             layout.beginLayout();
 
             QTextLine line = layout.createLine();
             line.setPosition(pos);
             pos.ry() += 25;
             layout.endLayout();
             layout.draw(&gc, QPointF());
         }
     }
 
     canvas.save("test_bidi.png");
 }
 
 void TestSvgText::testQtDxDy()
 {
     QImage canvas(500,500,QImage::Format_ARGB32);
     QPainter gc(&canvas);
     QPointF pos(15,15);
 
     QTextOption option;
     option.setTextDirection(Qt::LeftToRight);
     option.setUseDesignMetrics(true);
     option.setWrapMode(QTextOption::WrapAnywhere);
 
     QTextLayout layout;
 
     layout.setText("aa bb cc dd ee ff");
     layout.setFont(QFont("serif", 15.0));
     layout.setCacheEnabled(true);
     layout.beginLayout();
     layout.setTextOption(option);
 
     {
         QTextLine line = layout.createLine();
         line.setPosition(pos);
         line.setNumColumns(4);
     }
     pos.ry() += 25;
     pos.rx() += 30;
     {
         QTextLine line = layout.createLine();
         line.setPosition(pos);
     }
 
     layout.endLayout();
     layout.draw(&gc, QPointF());
 
 
     canvas.save("test_dxdy.png");
 }
 
 
 void TestSvgText::testTextOutlineSolid()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" stroke=\"red\" stroke-width=\"1\">"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" stroke=\"red\" stroke-width=\"1\">"
             "        SA"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_outline_solid", QSize(30, 30), 72.0);
 }
 
 void TestSvgText::testNbspHandling()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" stroke=\"red\" stroke-width=\"1\">"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" stroke=\"red\" stroke-width=\"1\">"
             "        S\u00A0A"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_nbsp", QSize(30, 30), 72.0);
 }
 
 void TestSvgText::testMulticolorText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
+    t.setFuzzyThreshold(5);
     t.test_standard("text_multicolor", QSize(30, 30), 72.0);
 }
 
 #include <KoSvgTextShapeMarkupConverter.h>
 #include <KoColorBackground.h>
 
 void TestSvgText::testConvertToStrippedSvg()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text transform=\"translate(2)\" id=\"testRect\" x=\"2\" y=\"24\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan><![CDATA[some stuff<><><<<>]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 
     KoSvgTextShape *baseShape = dynamic_cast<KoSvgTextShape*>(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     {
         KoColorBackground *bg = dynamic_cast<KoColorBackground*>(baseShape->background().data());
         QVERIFY(bg);
         QCOMPARE(bg->color(), QColor(Qt::blue));
     }
 
     KoSvgTextShapeMarkupConverter converter(baseShape);
 
     QString svgText;
     QString stylesText;
     QVERIFY(converter.convertToSvg(&svgText, &stylesText));
 
     QCOMPARE(stylesText, QString("<defs/>"));
-    QCOMPARE(svgText, QString("<text fill=\"#0000ff\" font-family=\"Verdana\" font-size=\"15\"><tspan x=\"2\" y=\"24\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>"));
+    QCOMPARE(svgText, QString("<text fill=\"#0000ff\" font-family=\"DejaVu Sans\" font-size=\"15\"><tspan x=\"2\" y=\"24\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>"));
 
     // test loading
 
-    svgText = "<text fill=\"#00ff00\" font-family=\"Verdana\" font-size=\"19\"><tspan x=\"2\" y=\"24\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>";
+    svgText = "<text fill=\"#00ff00\" font-family=\"DejaVu Sans\" font-size=\"19\"><tspan x=\"2\" y=\"24\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>";
 
     QVERIFY(converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
 
     {
         KoColorBackground *bg = dynamic_cast<KoColorBackground*>(baseShape->background().data());
         QVERIFY(bg);
         QCOMPARE(bg->color(), QColor(Qt::green));
     }
 
     {
         KoSvgTextProperties props = baseShape->textProperties();
         QVERIFY(props.hasProperty(KoSvgTextProperties::FontSizeId));
 
         const qreal fontSize = props.property(KoSvgTextProperties::FontSizeId).toReal();
         QCOMPARE(fontSize, 19.0);
     }
 
     QCOMPARE(baseShape->shapeCount(), 3);
 }
 
 void TestSvgText::testConvertToStrippedSvgNullOrigin()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text transform=\"translate(2)\" id=\"testRect\" x=\"0\" y=\"0\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan><![CDATA[some stuff<><><<<>]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 
     KoSvgTextShape *baseShape = dynamic_cast<KoSvgTextShape*>(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     KoSvgTextShapeMarkupConverter converter(baseShape);
 
     QString svgText;
     QString stylesText;
     QVERIFY(converter.convertToSvg(&svgText, &stylesText));
 
     QCOMPARE(stylesText, QString("<defs/>"));
-    QCOMPARE(svgText, QString("<text fill=\"#0000ff\" font-family=\"Verdana\" font-size=\"15\"><tspan x=\"0\" y=\"0\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>"));
+    QCOMPARE(svgText, QString("<text fill=\"#0000ff\" font-family=\"DejaVu Sans\" font-size=\"15\"><tspan x=\"0\" y=\"0\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>"));
 }
 
 void TestSvgText::testConvertFromIncorrectStrippedSvg()
 {
     QScopedPointer<KoSvgTextShape> baseShape(new KoSvgTextShape());
 
     KoSvgTextShapeMarkupConverter converter(baseShape.data());
 
     QString svgText;
     QString stylesText;
 
     svgText = "<text>blah text</text>";
     QVERIFY(converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     QCOMPARE(converter.errors().size(), 0);
 
     svgText = "<text>>><<><blah text</text>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 
     svgText = "<notext>blah text</notext>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 
     svgText = "<defs/>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 }
 
 void TestSvgText::testEmptyTextChunk()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        " // no actual text! should not crash!
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     // it just shouldn't assert or fail when seeing an empty text block
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 }
 
 void TestSvgText::testConvertHtmlToSvg()
 {
     const QString html =
             "<?xml version=\"1.0\"?>"
             "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">"
             "<html>"
               "<head>"
                 "<meta name=\"qrichtext\" content=\"1\"/>"
                 "<style type=\"text/css\">p, li { white-space: pre-wrap; }</style>"
               "</head>"
               "<body style=\" font-family:'Droid Sans'; font-size:9pt; font-weight:400; font-style:normal;\">"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">"
                 "  <span style=\" font-family:'Times'; font-size:20pt;\">Lorem ipsum dolor</span>"
                 "</p>"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">sit am"
                 "<span style=\" font-weight:600;\">et, consectetur adipis</span>cing </p>"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">"
                 "  <span style=\" font-style:italic;\">elit. </span>"
                 "</p>"
               "</body>"
             "</html>";
 
     KoSvgTextShape shape;
     KoSvgTextShapeMarkupConverter converter(&shape);
 
     QString svg;
     QString defs;
 
     converter.convertFromHtml(html, &svg, &defs);
 
 
     bool r = converter.convertToSvg(&svg, &defs);
 
     qDebug() << r << svg << defs;
 
 }
 
 void TestSvgText::testTextWithMultipleRelativeOffsets()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
-            "        font-family=\"Verdana\" font-size=\"15\" "
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        dy=\"0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0\">"
             "        Lorem ipsum dolor sit amet"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
+    t.setFuzzyThreshold(5);
     t.test_standard("text_multiple_relative_offsets", QSize(300, 80), 72.0);
 }
 
 void TestSvgText::testTextWithMultipleAbsoluteOffsetsArabic()
 {
     /**
      * According to the standard, each **absolute** offset defines a
      * new text chunk, therefore, the arabic text must become
      * ltr reordered
      */
 
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
-            "        font-family=\"Verdana\" font-size=\"15\" "
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        y=\"40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 \">"
             "        Lo rem اللغة العربية المعيارية الحديثة ip sum"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_multiple_absolute_offsets_arabic", QSize(530, 70), 72.0);
 }
 
 void TestSvgText::testTextWithMultipleRelativeOffsetsArabic()
 {
     /**
      * According to the standard, **relative** offsets must not define a new
      * text chunk, therefore, the arabic text must be written in native rtl order,
      * even though the individual letters are split.
      */
 
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
-            "        font-family=\"Verdana\" font-size=\"15\" "
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        dy=\"0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0\">"
             "        Lo rem اللغة العربية المعيارية الحديثة ip sum"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
-
+    // we cannot expect more than one failure
+#ifndef USE_ROUND_TRIP
     QEXPECT_FAIL("", "WARNING: in Krita relative offsets also define a new text chunk, that doesn't comply with SVG standard and must be fixed", Continue);
     t.test_standard("text_multiple_relative_offsets_arabic", QSize(530, 70), 72.0);
+#endif
 }
 
 void TestSvgText::testTextOutline()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\""
             " "
-            "        font-family=\"Verdana\" font-size=\"15\" fill=\"blue\" >"
+            "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        normal "
             "        <tspan text-decoration=\"line-through\">strikethrough</tspan>"
             "        <tspan text-decoration=\"overline\">overline</tspan>"
             "        <tspan text-decoration=\"underline\">underline</tspan>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     QRect renderRect(0, 0, 450, 40);
 
     SvgRenderTester t (data);
+    t.setFuzzyThreshold(5);
     t.test_standard("text_outline", renderRect.size(), 72.0);
 
     KoShape *shape = t.findShape("testRect");
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     QVERIFY(chunkShape);
 
     KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
 
     QImage canvas(renderRect.size(), QImage::Format_ARGB32);
     canvas.fill(0);
     QPainter gc(&canvas);
     gc.setPen(Qt::NoPen);
     gc.setBrush(Qt::black);
     gc.setRenderHint(QPainter::Antialiasing, true);
     gc.drawPath(textShape->textOutline());
 
     QVERIFY(TestUtil::checkQImage(canvas, "svg_render", "load_text_outline", "converted_to_path", 3, 5));
 }
 
 
 
 
 QTEST_MAIN(TestSvgText)
diff --git a/libs/flake/tests/data/svg_render/load_image_aspect_default.png b/libs/flake/tests/data/svg_render/load_image_aspect_default.png
index c5749a5098..34666ca23f 100644
Binary files a/libs/flake/tests/data/svg_render/load_image_aspect_default.png and b/libs/flake/tests/data/svg_render/load_image_aspect_default.png differ
diff --git a/libs/flake/tests/data/svg_render/load_text_baseline_shift.png b/libs/flake/tests/data/svg_render/load_text_baseline_shift.png
index 59ac7bf9d0..244995591d 100644
Binary files a/libs/flake/tests/data/svg_render/load_text_baseline_shift.png and b/libs/flake/tests/data/svg_render/load_text_baseline_shift.png differ
diff --git a/libs/flake/tests/data/svg_render/load_text_decorations.png b/libs/flake/tests/data/svg_render/load_text_decorations.png
index 1377f5f03f..437280ca1e 100644
Binary files a/libs/flake/tests/data/svg_render/load_text_decorations.png and b/libs/flake/tests/data/svg_render/load_text_decorations.png differ
diff --git a/libs/flake/tests/data/svg_render/load_text_hindi.png b/libs/flake/tests/data/svg_render/load_text_hindi.png
index e6fd1f9366..397950833d 100644
Binary files a/libs/flake/tests/data/svg_render/load_text_hindi.png and b/libs/flake/tests/data/svg_render/load_text_hindi.png differ
diff --git a/libs/flake/tests/data/svg_render/load_text_multiple_absolute_offsets_arabic.png b/libs/flake/tests/data/svg_render/load_text_multiple_absolute_offsets_arabic.png
index 0120741001..9afb6f8583 100644
Binary files a/libs/flake/tests/data/svg_render/load_text_multiple_absolute_offsets_arabic.png and b/libs/flake/tests/data/svg_render/load_text_multiple_absolute_offsets_arabic.png differ
diff --git a/libs/flake/tests/data/svg_render/load_text_right_to_left.png b/libs/flake/tests/data/svg_render/load_text_right_to_left.png
index fedd01354f..b9f8e081e3 100644
Binary files a/libs/flake/tests/data/svg_render/load_text_right_to_left.png and b/libs/flake/tests/data/svg_render/load_text_right_to_left.png differ