Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/LibreOffice/emfio/qa/cppunit/emf/   (Office von Apache Version 25.8.3.2©)  Datei vom 5.10.2025 mit Größe 97 kB image not shown  

Quelle  EmfImportTest.cxx   Sprache: C

 
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#include <sal/config.h>
#include <config_fonts.h>

#include <test/unoapixml_test.hxx>

#include <com/sun/star/frame/Desktop.hpp>
#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/graphic/XGraphic.hpp>

#include <comphelper/seqstream.hxx>

#include <com/sun/star/graphic/EmfTools.hpp>

#include <drawinglayer/primitive2d/Primitive2DContainer.hxx>
#include <drawinglayer/tools/primitive2dxmldump.hxx>
#include <vcl/filter/PDFiumLibrary.hxx>

#include <memory>
#include <string_view>

using namespace css;
using namespace css::uno;
using namespace css::io;
using namespace css::graphic;
using drawinglayer::primitive2d::Primitive2DSequence;
using drawinglayer::primitive2d::Primitive2DContainer;

class Test : public UnoApiXmlTest
{
public:
    Test()
        : UnoApiXmlTest(u"/emfio/qa/cppunit/emf/data/"_ustr)
    {
    }

    const OString aXPathPrefix = "/primitive2D/metafile/transform/"_ostr;

    Primitive2DSequence parseEmf(std::u16string_view aSource);
};

Primitive2DSequence Test::parseEmf(std::u16string_view aSource)
{
    const Reference<XEmfParser> xEmfParser = EmfTools::create(m_xContext);

    OUString aUrl = m_directories.getURLFromSrc(aSource);
    OUString aPath = m_directories.getPathFromSrc(aSource);

    SvFileStream aFileStream(aUrl, StreamMode::READ);
    std::size_t nSize = aFileStream.remainingSize();
    CPPUNIT_ASSERT_MESSAGE("Unable to open file", nSize);
    std::unique_ptr<sal_Int8[]> pBuffer(new sal_Int8[nSize + 1]);
    aFileStream.ReadBytes(pBuffer.get(), nSize);
    pBuffer[nSize] = 0;

    Sequence<sal_Int8> aData(pBuffer.get(), nSize + 1);
    Reference<XInputStream> aInputStream(new comphelper::SequenceInputStream(aData));
    css::uno::Sequence<css::beans::PropertyValue> aEmptyValues;

    return xEmfParser->getDecomposition(aInputStream, aPath, aEmptyValues);
}

CPPUNIT_TEST_FIXTURE(Test, testPolyPolygon)
{
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/fdo79679-2.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));

    CPPUNIT_ASSERT(pDocument);

    // Chart axis
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", "path", u"m0 0h19746v14817h-19746z");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor", 2);
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[1]", "color", u"#ffffff");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[1]/polypolygon", "path",
                u"m0 0h19781v14852h-19781z");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[2]/polypolygon", "path",
                u"m2574 13194v-12065h15303v12065z");

    assertXPath(pDocument, aXPathPrefix + "mask/polygonstroke", 116);
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonstroke[1]/polygon",
                       u"2574,13194 2574,1129 17877,1129 17877,13194");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstroke[1]/line", "color", u"#ffffff");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstroke[1]/line", "width", u"35");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonstroke[2]/polygon",
                       u"2574,13194 2574,1129");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstroke[2]/line", "color", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstroke[2]/line", "width", u"35");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonstroke[10]/polygon",
                       u"8674,13194 8674,1129");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstroke[10]/line", "color", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstroke[10]/line", "width", u"35");

    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion", 28);
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[6]", "width", u"459");
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[6]", "x", u"9908");
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[6]", "text", u"0.5");
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[6]", "fontcolor", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "mask/pointarray", 98);
    assertXPath(pDocument, aXPathPrefix + "mask/pointarray[1]", "color", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "mask/pointarray[1]/point", "x", u"2574");
    assertXPath(pDocument, aXPathPrefix + "mask/pointarray[1]/point", "y", u"1129");
}

CPPUNIT_TEST_FIXTURE(Test, testDrawImagePointsTypeBitmap)
{
    // tdf#142941 EMF+ file with ObjectTypeImage, FillRects, DrawImagePoints ,records
    // The test is checking the position of displaying bitmap with too large SrcRect

    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestDrawImagePointsTypeBitmap.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor", "color", u"#0080ff");
    assertXPath(pDocument, aXPathPrefix + "bitmap", "xy11", u"5347");
    assertXPath(pDocument, aXPathPrefix + "bitmap", "xy12", u"0");
    assertXPath(pDocument, aXPathPrefix + "bitmap", "xy13", u"5558");
    assertXPath(pDocument, aXPathPrefix + "bitmap", "xy21", u"0");
    assertXPath(pDocument, aXPathPrefix + "bitmap", "xy22", u"4717");
    assertXPath(pDocument, aXPathPrefix + "bitmap", "xy23", u"5565");
    assertXPath(
        pDocument, aXPathPrefix + "bitmap/data[2]", "row",
        u"020202,ffffff,ffffff,ffffff,fefefe,ffffff,ffffff,fefefe,ffffff,ffffff,f8f8f8,ffffff,"
        "fdfdfd,ffffff,ffffff,fdfdfd,ffffff,ffffff,ffffff,fbfbfb,010101,ffffff,fefefe,ffffff,"
        "ffffff,fbfbfb,ffffff,fdfdfd,fcfcfc,fdfdfd,ffffff,ffffff,ffffff,ffffff,ffffff,ffffff,"
        "ffffff,ffffff,ffffff,ffffff,020202,fdfdfd,ffffff,ffffff,fefefe,ffffff,ffffff,ffffff,"
        "ffffff,fbfbfb,fefefe,ffffff,fcfcfc,ffffff,fdfdfd,ffffff,ffffff,ffffff,ffffff,fbfbfb,"
        "010101,ffffff,fefefe,ffffff,ffffff,ffffff,fcfcfc,ffffff,fafafa,ffffff,ffffff,fefefe,"
        "ffffff,fdfdfd,fefefe,fefefe,ffffff,ffffff,fdfdfd,fffbfb,1e0000,8f4347,b13a3e,b82d32,"
        "bb3438,b73237,b63338,b33035,b63338,b83338,b9313b,b9313b,b83239,b83338,b63338,b53438,"
        "b63539,b53335,ba3236,a2393e,1c0000");
}

CPPUNIT_TEST_FIXTURE(Test, testDrawString)
{
#if HAVE_MORE_FONTS
    // EMF+ file with only one DrawString Record
    // Since the text is undecorated the optimal choice is a simpletextportion primitive

    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TestDrawString.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    // check correct import of the DrawString: height, position, text, color and font
    assertXPath(pDocument, aXPathPrefix + "transform/textsimpleportion", "height", u"120");
    assertXPath(pDocument, aXPathPrefix + "transform/textsimpleportion", "x", u"817");
    assertXPath(pDocument, aXPathPrefix + "transform/textsimpleportion", "y", u"1138");
    assertXPath(pDocument, aXPathPrefix + "transform/textsimpleportion", "text", u"TEST");
    assertXPath(pDocument, aXPathPrefix + "transform/textsimpleportion", "fontcolor", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "transform/textsimpleportion", "familyname", u"CALIBRI");
#endif
}

CPPUNIT_TEST_FIXTURE(Test, testDrawStringAlign)
{
#if HAVE_MORE_FONTS
    // EMF+ DrawString with alignment (StringAlignmentNear, StringAlignmentFar, StringAlignmentCenter)
    // It seems Arial font is replaced with Liberation Sans. These numbers are valid for Liberation Sans.
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TestDrawStringAlign.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/transform", 9);
    assertXPath(pDocument, aXPathPrefix + "mask/transform[1]/textsimpleportion", "width", u"12");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[1]/textsimpleportion", "height", u"12");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[1]/textsimpleportion", "x", u"12");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[1]/textsimpleportion", "y", u"22");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[1]/textsimpleportion", "text", u"HLVT");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[1]/textsimpleportion", "fontcolor",
                u"#000000");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[1]/textsimpleportion", "familyname",
                u"ARIAL");

    assertXPath(pDocument, aXPathPrefix + "mask/transform[2]/textsimpleportion", "width", u"12");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[2]/textsimpleportion", "height", u"12");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[2]/textsimpleportion", "x", u"144");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[2]/textsimpleportion", "y", u"22");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[2]/textsimpleportion", "text", u"HCVT");

    // TODO Make the position of the text the same across the platforms (Arial vs Liberation Sans).
    // This is usually 276, but can be 275 as well; depends on what fonts are installed?
    sal_Int32 nX
        = getXPath(pDocument, aXPathPrefix + "mask/transform[3]/textsimpleportion", "x").toInt32();
    CPPUNIT_ASSERT(nX >= 275);
    CPPUNIT_ASSERT(nX <= 276);
    assertXPath(pDocument, aXPathPrefix + "mask/transform[3]/textsimpleportion", "y", u"22");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[3]/textsimpleportion", "text", u"HRVT");

    assertXPath(pDocument, aXPathPrefix + "mask/transform[4]/textsimpleportion", "x", u"12");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[4]/textsimpleportion", "y", u"66");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[4]/textsimpleportion", "text", u"HLVC");

    assertXPath(pDocument, aXPathPrefix + "mask/transform[5]/textsimpleportion", "x", u"143");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[5]/textsimpleportion", "y", u"66");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[5]/textsimpleportion", "text", u"HCVC");

    // This is usually 274, but can be 273 as well; depends on what fonts are installed?
    nX = getXPath(pDocument, aXPathPrefix + "mask/transform[6]/textsimpleportion", "x").toInt32();
    CPPUNIT_ASSERT(nX >= 273);
    CPPUNIT_ASSERT(nX <= 274);
    assertXPath(pDocument, aXPathPrefix + "mask/transform[6]/textsimpleportion", "y", u"66");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[6]/textsimpleportion", "text", u"HRVC");

    assertXPath(pDocument, aXPathPrefix + "mask/transform[7]/textsimpleportion", "x", u"12");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[7]/textsimpleportion", "y", u"110");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[7]/textsimpleportion", "text", u"HLVB");

    assertXPath(pDocument, aXPathPrefix + "mask/transform[8]/textsimpleportion", "x", u"143");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[8]/textsimpleportion", "y", u"110");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[8]/textsimpleportion", "text", u"HCVB");

    // This is usually 275, but can be 274 as well; depends on what fonts are installed?
    nX = getXPath(pDocument, aXPathPrefix + "mask/transform[9]/textsimpleportion", "x").toInt32();
    CPPUNIT_ASSERT(nX >= 274);
    CPPUNIT_ASSERT(nX <= 275);
    assertXPath(pDocument, aXPathPrefix + "mask/transform[9]/textsimpleportion", "y", u"110");
    assertXPath(pDocument, aXPathPrefix + "mask/transform[9]/textsimpleportion", "text", u"HRVB");
#endif
}

CPPUNIT_TEST_FIXTURE(Test, testDrawStringTransparent)
{
#if HAVE_MORE_FONTS
    // EMF+ file with one DrawString Record with transparency

    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestDrawStringTransparent.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/transform/unifiedtransparence", "transparence",
                u"50");
    assertXPath(pDocument, aXPathPrefix + "mask/transform/unifiedtransparence/textsimpleportion",
                "height", u"24");
    assertXPath(pDocument, aXPathPrefix + "mask/transform/unifiedtransparence/textsimpleportion",
                "x", u"66");
    assertXPath(pDocument, aXPathPrefix + "mask/transform/unifiedtransparence/textsimpleportion",
                "y", u"74");
    assertXPath(pDocument, aXPathPrefix + "mask/transform/unifiedtransparence/textsimpleportion",
                "text", u"Transparent Text");
    assertXPath(pDocument, aXPathPrefix + "mask/transform/unifiedtransparence/textsimpleportion",
                "fontcolor", u"#0000ff");
    assertXPath(pDocument, aXPathPrefix + "mask/transform/unifiedtransparence/textsimpleportion",
                "familyname", u"ARIAL");
#endif
}

CPPUNIT_TEST_FIXTURE(Test, testDrawStringWithBrush)
{
    // tdf#142975 EMF+ with records: DrawString, Brush and Font
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestDrawStringWithBrush.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);
    assertXPath(pDocument, aXPathPrefix + "transform/textdecoratedportion", "xy11", u"20");
    assertXPath(pDocument, aXPathPrefix + "transform/textdecoratedportion", "xy13", u"16");
    assertXPath(pDocument, aXPathPrefix + "transform/textdecoratedportion", "xy22", u"20");
    assertXPath(pDocument, aXPathPrefix + "transform/textdecoratedportion", "xy33", u"1");
    assertXPath(pDocument, aXPathPrefix + "transform/textdecoratedportion", "text",
                u"0123456789ABCDEF");
    assertXPath(pDocument, aXPathPrefix + "transform/textdecoratedportion", "fontcolor",
                u"#a50021");
    assertXPath(pDocument, aXPathPrefix + "transform/textdecoratedportion", "familyname",
                u"TIMES NEW ROMAN");
}

CPPUNIT_TEST_FIXTURE(Test, testEmfPlusDrawBeziers)
{
    // tdf#107019 tdf#154789 EMF+ records: DrawBeziers
    // Check if DrawBeziers is displayed correctly and text is rotated
    Primitive2DSequence aSequence
        = parseEmf(u"emfio/qa/cppunit/emf/data/TestEmfPlusDrawBeziers.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor", 4);
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[1]", "color", u"#000000");

    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow", 9);
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[9]/line", "color", u"#00ff00");

    assertXPath(pDocument, aXPathPrefix + "transform", 5);
    assertXPath(pDocument, aXPathPrefix + "transform[1]/textsimpleportion", "fontcolor",
                u"#000000");
    assertXPath(pDocument, aXPathPrefix + "transform[1]/textsimpleportion", "text",
                u"% Efficiency");
    assertXPath(pDocument, aXPathPrefix + "transform[1]", "xy11", u"0");
    assertXPath(pDocument, aXPathPrefix + "transform[1]", "xy12", u"4");
    assertXPath(pDocument, aXPathPrefix + "transform[1]", "xy13", u"800");
    assertXPath(pDocument, aXPathPrefix + "transform[1]", "xy21", u"-4");
    assertXPath(pDocument, aXPathPrefix + "transform[1]", "xy22", u"0");
    assertXPath(pDocument, aXPathPrefix + "transform[1]", "xy23", u"3196");
}

CPPUNIT_TEST_FIXTURE(Test, testDrawLine)
{
    // EMF+ with records: DrawLine
    // The line is colored and has a specified width, therefore a polypolygonstroke primitive is the optimal choice
    Primitive2DSequence aSequence = parseEmf(u"emfio/qa/cppunit/emf/data/TestDrawLine.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    // check correct import of the DrawLine: color and width of the line
    assertXPath(pDocument, aXPathPrefix + "mask/unifiedtransparence", "transparence", u"14");
    assertXPath(pDocument, aXPathPrefix + "mask/unifiedtransparence/polypolygonstroke/line",
                "color", u"#c01002");
    assertXPath(pDocument, aXPathPrefix + "mask/unifiedtransparence/polypolygonstroke/line",
                "width", u"115");
    assertXPath(pDocument, aXPathPrefix + "mask/unifiedtransparence/polypolygonstroke/line",
                "linecap", u"BUTT");
    assertXPath(pDocument, aXPathPrefix + "mask/unifiedtransparence/polypolygonstroke/polypolygon",
                "path", u"m89.1506452315894 403.573503917507 895.170581035125-345.821325648415");
}

CPPUNIT_TEST_FIXTURE(Test, testDrawLineWithCaps)
{
    // EMF+ with records: DrawLine
    // Test lines with different caps styles and arrows
    Primitive2DSequence aSequence
        = parseEmf(u"emfio/qa/cppunit/emf/data/TestEmfPlusDrawLineWithCaps.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow", 3);

    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[1]/line", "width", u"212");
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[1]/stroke", 0);
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[1]/linestartattribute/polypolygon",
                "path", u"m0-1 1 2h-2z");
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[1]/lineendattribute", 0);

    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[2]/line", "width", u"212");
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[2]/stroke", 0);
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[2]/linestartattribute/polypolygon",
                "path", u"m0-1 1 2h-2z");
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[2]/lineendattribute", 0);

    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[3]/line", "width", u"423");
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[3]/stroke", 0);
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[3]/linestartattribute", 0);
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow[3]/lineendattribute/polypolygon",
                "path", u"m-1-1h2v2h-2z");

    assertXPath(pDocument, aXPathPrefix + "unifiedtransparence", 3);
    assertXPath(pDocument, aXPathPrefix + "unifiedtransparence[1]", "transparence", u"39");
    assertXPath(pDocument,
                aXPathPrefix
                    + "unifiedtransparence[1]/polygonstrokearrow/linestartattribute/polypolygon",
                "path",
                u"m-1 1h2v-1l-0.0764-0.3827-0.2165-0.3244-0.3244-0.2165-0.3827-0.0764-0.3827 "
                "0.0764-0.3244 0.2165-0.2165 0.3244-0.0764 0.3827z");
    assertXPath(pDocument,
                aXPathPrefix
                    + "unifiedtransparence[1]/polygonstrokearrow/lineendattribute/polypolygon",
                "path", u"m-1 1h2v-1l-1-1-1 1z");
    assertXPath(pDocument,
                aXPathPrefix + "unifiedtransparence[2]/polygonstrokearrow/linestartattribute", 0);
    assertXPath(pDocument,
                aXPathPrefix
                    + "unifiedtransparence[2]/polygonstrokearrow/lineendattribute/polypolygon",
                "path", u"m-1-1h2v2h-2z");
    assertXPath(pDocument,
                aXPathPrefix
                    + "unifiedtransparence[3]/polygonstrokearrow/lineendattribute/polypolygon",
                "path", u"m0-1 1 1-0.5 0.5v0.5h-1v-0.5l-0.5-0.5z");
}

CPPUNIT_TEST_FIXTURE(Test, testDrawLineWithDash)
{
    // EMF+ with records: DrawLine, ScaleWorldTransform, RotateWorldTransform
    // Test lines with different dash styles, different line arrows and different World Rotation
    Primitive2DSequence aSequence
        = parseEmf(u"emfio/qa/cppunit/emf/data/TestEmfPlusDrawLineWithDash.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    // check correct import of the DrawLine: color and width of the line
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke", 10);
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[1]/line", "color", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[1]/line", "width", u"185");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[1]/stroke", 0);

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[2]/line", "width", u"185");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[2]/stroke", "dotDashArray",
                u"185 185 ");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[3]/line", "width", u"185");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[3]/stroke", "dotDashArray",
                u"556 185 ");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[4]/line", "width", u"185");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[4]/stroke", "dotDashArray",
                u"556 185 185 185 ");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[5]/line", "width", u"370");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[5]/stroke", "dotDashArray",
                u"556 185 185 185 185 185 ");

    assertXPath(pDocument, aXPathPrefix + "mask/polygonstrokearrow", 2);
    //TODO polypolygonstroke[6-9]/stroke add support for PenDataDashedLineOffset
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstrokearrow[1]/line", "width", u"370");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstrokearrow[1]/stroke", "dotDashArray",
                u"1851 741 5554 1481 ");
    // Arrows on both ends
    assertXPath(pDocument,
                aXPathPrefix + "mask/polygonstrokearrow[1]/linestartattribute/polypolygon", "path",
                u"m0-1 1 2h-2z");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstrokearrow[1]/lineendattribute/polypolygon",
                "path", u"m0-1 1 2h-2z");

    assertXPath(pDocument, aXPathPrefix + "mask/polygonstrokearrow[2]/line", "width", u"370");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstrokearrow[2]/stroke", "dotDashArray",
                u"1852 741 5555 1481 ");
    assertXPath(pDocument,
                aXPathPrefix + "mask/polygonstrokearrow[2]/linestartattribute/polypolygon", "path",
                u"m-1 1h2v-1l-0.0764-0.3827-0.2165-0.3244-0.3244-0.2165-0.3827-0.0764-0.3827 "
                "0.0764-0.3244 0.2165-0.2165 0.3244-0.0764 0.3827z");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonstrokearrow[2]/lineendattribute/polypolygon",
                "path",
                u"m-1 1h2v-1l-0.0764-0.3827-0.2165-0.3244-0.3244-0.2165-0.3827-0.0764-0.3827 "
                "0.0764-0.3244 0.2165-0.2165 0.3244-0.0764 0.3827z");
}

CPPUNIT_TEST_FIXTURE(Test, testLinearGradient)
{
    // EMF+ file with LinearGradient brush
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TestLinearGradient.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, "/primitive2D/metafile/transform", "xy11", u"1");
    assertXPath(pDocument, "/primitive2D/metafile/transform", "xy12", u"0");
    assertXPath(pDocument, "/primitive2D/metafile/transform", "xy13", u"0");
    assertXPath(pDocument, "/primitive2D/metafile/transform", "xy21", u"0");
    assertXPath(pDocument, "/primitive2D/metafile/transform", "xy22", u"1");
    assertXPath(pDocument, "/primitive2D/metafile/transform", "xy23", u"0");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", "height", u"7610");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", "width", u"15232");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", "path", u"m0 0h15232v7610h-15232z");

    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[1]", "spreadmethod", u"repeat");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[1]", "startx", u"0");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[1]", "starty", u"-1");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[1]", "endx", u"0");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[1]", "endy", u"-1");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[1]", "opacity",
                u"0.392156862745098");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[1]/polypolygon", "path",
                u"m0 0.216110019646294h7615.75822989746v7610.21611001965h-7615.75822989746z");

    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[2]", "spreadmethod", u"repeat");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[2]", "startx", u"-1");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[2]", "starty", u"-1");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[2]", "endx", u"-1");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[2]", "endy", u"-1");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[2]", "opacity", u"1");
    assertXPath(pDocument, aXPathPrefix + "mask/svglineargradient[2]/polypolygon", "path",
                u"m7615.75822989746 "
                u"0.216110019646294h7615.75822989746v7610.21611001965h-7615.75822989746z");
}

CPPUNIT_TEST_FIXTURE(Test, testTextMapMode)
{
    // EMF with records: SETMAPMODE with MM_TEXT MapMode, POLYLINE16, EXTCREATEPEN, EXTTEXTOUTW
    // MM_TEXT is mapped to one device pixel. Positive x is to the right; positive y is down.
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TextMapMode.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor", 2);
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[1]", "color", u"#ffffff");
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[1]/polypolygon", "path",
                u"m0 0h3542v4647h-3542z");

    assertXPath(pDocument, aXPathPrefix + "textsimpleportion", 20);
    assertXPath(pDocument, aXPathPrefix + "textsimpleportion[1]", "text", u"N");
    assertXPath(pDocument, aXPathPrefix + "textsimpleportion[1]", "fontcolor", u"#4a70e3");
    assertXPath(pDocument, aXPathPrefix + "textsimpleportion[1]", "x", u"2099");
    assertXPath(pDocument, aXPathPrefix + "textsimpleportion[1]", "y", u"1859");

    assertXPath(pDocument, aXPathPrefix + "polygonstroke", 138);
    assertXPathContent(pDocument, aXPathPrefix + "polygonstroke[1]/polygon",
                       u"2142,1638 2142,1489");
    assertXPath(pDocument, aXPathPrefix + "polygonstroke[1]/line", "color", u"#4a70e3");
    assertXPath(pDocument, aXPathPrefix + "polygonstroke[1]/line", "width", u"11");

    assertXPathContent(pDocument, aXPathPrefix + "polygonstroke[10]/polygon",
                       u"1967,1029 1869,952");
    assertXPath(pDocument, aXPathPrefix + "polygonstroke[10]/line", "color", u"#4a70e3");
    assertXPath(pDocument, aXPathPrefix + "polygonstroke[10]/line", "width", u"11");

    assertXPathContent(pDocument, aXPathPrefix + "polygonstroke[20]/polygon",
                       u"2710,1113 2873,1330");
    assertXPath(pDocument, aXPathPrefix + "polygonstroke[20]/line", "color", u"#666666");
    assertXPath(pDocument, aXPathPrefix + "polygonstroke[20]/line", "width", u"11");
}

CPPUNIT_TEST_FIXTURE(Test, testEnglishMapMode)
{
    // EMF image with records: SETMAPMODE with MM_ENGLISH MapMode, STROKEANDFILLPATH, EXTTEXTOUTW, SETTEXTALIGN, STRETCHDIBITS
    // MM_LOENGLISH is mapped to 0.01 inch. Positive x is to the right; positive y is up.M
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/test_mm_hienglish_ref.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", 1);
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon[1]", "path",
                u"m0 0h29699v20999h-29699z");

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor", 3);
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[1]", "color", u"#ffffad");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[1]/polypolygon", "path",
                u"m-1-1h29700v21001h-29700z");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[2]/polypolygon", "path",
                u"m1058 7937v5293h3175v-1059h-2118v-4234z");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[3]/polypolygon", "path",
                u"m12699 1058h4234v1060h-1587v4231h-1059v-4231h-1588z");

    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion", 4);
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[1]", "text", u"UL");
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[1]", "fontcolor", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[1]", "x", u"106");
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[1]", "y", u"459");
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[1]", "width", u"424");
    assertXPath(pDocument, aXPathPrefix + "mask/textsimpleportion[1]", "height", u"424");

    assertXPath(pDocument, aXPathPrefix + "mask/polygonhairline", 5);
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[1]/polygon",
                       u"-1,-1 29699,-1 29699,21000 -1,21000");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[2]/polygon",
                       u"1058,7937 1058,13230 4233,13230 4233,12171 2115,12171 2115,7937");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[3]/polygon",
                       u"1058,7937 1058,13230 4233,13230 4233,12171 2115,12171 2115,7937");
}

CPPUNIT_TEST_FIXTURE(Test, testRectangleWithModifyWorldTransform)
{
    // EMF image with records: EXTCREATEPEN, SELECTOBJECT, MODIFYWORLDTRANSFORM, RECTANGLE

    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestRectangleWithModifyWorldTransform.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor", 1);
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[1]", "color", u"#ffffff");
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[1]/polypolygon", "path",
                u"m1042 417 918 529 353 610-918-528z");

    assertXPath(pDocument, aXPathPrefix + "polygonstroke", 1);
    assertXPathContent(pDocument, aXPathPrefix + "polygonstroke[1]/polygon",
                       u"1042,417 1960,946 2313,1556 1395,1028");
}

CPPUNIT_TEST_FIXTURE(Test, testChordWithModifyWorldTransform)
{
    // EMF import test with records: CHORD, MODIFYWORLDTRANSFORM, EXTCREATEPEN, SELECTOBJECT
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestChordWithModifyWorldTransform.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor", "color", u"#ffffff");
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor/polypolygon", "path",
                u"m590 448-21 45-66 24-34 12-33 12-21 45-33 12 12 33-33 12 12 33 12 34 33-12 12 33 "
                "34-12 33-12 45 21 33-12 33-12 46 21 66-25 33-12 66-24 34-12 66-24z");
    assertXPathContent(pDocument, aXPathPrefix + "polygonstroke/polygon",
                       u"590,448 569,493 503,517 469,529 436,541 415,586 382,598 394,631 361,643 "
                       "361,643 373,676 373,676 385,710 418,698 430,731 464,719 497,707 542,728 "
                       "575,716 608,704 654,725 720,700 753,688 819,664 853,652 919,628");
}

CPPUNIT_TEST_FIXTURE(Test, testAngleArc)
{
    // tdf167616 EMF import test of displaying AngleArc which draw a line segment and an arc in a single operation
    // Records: EMR_ANGLEARC, EMR_SETARCDIRECTION
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TestAngleArc.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);
    assertXPath(pDocument, aXPathPrefix + "mask/polygonhairline", 20);
    assertXPath(pDocument, aXPathPrefix + "mask/polygonhairline[1]", "color", u"#000000");

    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[5]/polygon",
                       u"2350,990 4000,640");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[7]/polygon",
                       u"4000,640 1140,2000");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[9]/polygon",
                       u"640,2500 2350,2350");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[11]/polygon",
                       u"2350,1650 4000,2000");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[13]/polygon",
                       u"4000,2000 640,3000");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[15]/polygon",
                       u"1140,3500 2350,3850");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[17]/polygon",
                       u"1650,3850 3500,3000");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[19]/polygon",
                       u"3500,4000 1280,4250");
}

CPPUNIT_TEST_FIXTURE(Test, testArcStartPointEqualEndPoint)
{
    // i73608 EMF import test where StartPoint == EndPoint. It should draw full circle
    // Records: SETMAPMODE, SETWINDOWEXTEX, SETWINDOWORGEX, EXTSELECTCLIPRGN, INTERSECTCLIPRECT, MOVETOEX, ARC
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestArcStartPointEqualEndPoint.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/group/mask/polygonhairline", "color", u"#000000");
    assertXPathContent(
        pDocument, aXPathPrefix + "mask/group/mask/polygonhairline/polygon",
        u"11886,23133 11970,23223 12051,23316 12131,23410 12208,23506 12282,23604 12354,23704 "
        "12424,23805 12491,23909 12556,24014 12618,24120 12677,24228 12734,24337 12788,24448 "
        "12839,24560 12888,24673 12933,24788 12976,24903 13016,25020 13053,25137 13087,25256 "
        "13119,25375 13147,25495 13172,25615 13195,25736 13214,25858 13230,25980 13244,26103 "
        "13254,26225 13261,26348 13266,26472 13267,26595 13265,26718 13260,26841 13253,26964 "
        "13242,27087 13228,27209 13211,27331 13191,27453 13168,27574 13142,27694 13113,27814 "
        "13082,27933 13047,28051 13009,28169 12969,28285 12926,28400 12879,28514 12830,28628 "
        "12779,28739 12724,28850 12667,28959 12607,29067 12545,29173 12480,29277 12412,29380 "
        "12342,29482 12269,29581 12194,29679 12117,29775 12037,29869 11955,29960 11871,30050 "
        "11784,30138 11696,30224 11605,30307 11512,30388 11418,30467 11321,30543 11223,30617 "
        "11122,30689 11020,30758 10917,30825 10811,30888 10705,30950 10596,31009 10487,31065 "
        "10376,31118 10263,31168 10150,31216 10035,31261 9919,31303 9803,31343 9685,31379 "
        "9566,31412 9447,31443 9327,31471 9206,31495 9085,31517 8963,31535 8841,31551 8719,31564 "
        "8596,31573 8473,31580 8350,31583 8226,31584 8103,31581 7980,31576 7857,31567 7735,31555 "
        "7612,31541 7491,31523 7369,31503 7248,31479 7128,31452 7008,31423 6890,31390 6772,31355 "
        "6655,31316 6538,31275 6423,31231 6310,31184 6197,31135 6085,31082 5975,31027 5866,30969 "
        "5759,30909 5653,30846 5549,30780 5447,30712 5346,30641 5247,30568 5150,30492 5054,30414 "
        "4961,30334 4870,30251 4780,30166 4693,30079 4608,29990 4525,29899 4445,29805 4367,29710 "
        "4291,29613 4217,29514 4146,29414 4078,29311 4012,29207 3949,29101 3888,28994 3830,28885 "
        "3775,28775 3722,28664 3672,28551 3625,28438 3581,28323 3540,28207 3501,28090 3465,27972 "
        "3433,27853 3403,27733 3376,27613 3352,27492 3331,27371 3313,27249 3299,27127 3287,27004 "
        "3278,26881 3272,26758 3269,26635 3270,26512 3273,26388 3279,26265 3289,26143 3301,26020 "
        "3316,25898 3335,25776 3356,25655 3380,25534 3408,25414 3438,25294 3471,25176 3508,25058 "
        "3547,24941 3588,24825 3633,24711 3681,24597 3731,24484 3784,24373 3840,24263 3899,24155 "
        "3960,24048 4023,23943 4090,23839 4159,23737 4230,23636 4304,23538 4380,23441 4459,23346 "
        "4540,23253 4623,23162 4708,23074 4796,22987 4885,22902 4977,22820 5071,22740 5166,22663 "
        "5264,22587 5363,22515 5465,22444 5567,22376 5672,22311 5778,22249 5885,22188 5994,22131 "
        "6105,22076 6216,22024 6329,21975 6443,21929 6559,21885 6675,21845 6792,21807 6910,21772 "
        "7029,21740 7149,21711 7269,21685 7390,21662 7512,21642 7634,21624 7756,21610 7879,21599 "
        "8002,21591 8125,21586 8248,21584 8371,21585 8494,21589 8617,21596 8740,21606 8862,21619 "
        "8985,21636 9106,21655 9227,21677 9348,21702 9468,21730 9587,21761 9705,21795 9823,21832 "
        "9940,21872 10055,21914 10170,21960 10283,22008 10395,22059 10506,22113 10615,22169 "
        "10723,22229 10830,22291 10935,22355 11038,22422 11140,22491 11240,22563 11338,22638 "
        "11434,22715 11529,22794 11621,22875 11711,22959 11800,23045");
}

CPPUNIT_TEST_FIXTURE(Test, testArcInsideWronglyDefinedRectangle)
{
    // tdf#142268 EMF import test with records: ARC
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestArcInsideWronglyDefinedRectangle.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polygonhairline", "color", u"#000000");
    assertXPathContent(
        pDocument, aXPathPrefix + "polygonhairline/polygon",
        u"1630,1460 1650,1470 1670,1480 1700,1490 1720,1500 1750,1510 1770,1520 1800,1530 "
        u"1820,1530 "
        "1850,1540 1870,1540 1900,1540 1930,1540 1950,1540 1980,1540 2000,1530 2030,1530 2050,1520 "
        "2080,1510 2100,1500 2130,1490 2150,1480 2170,1470 2200,1450 2220,1440 2240,1420 2260,1400 "
        "2280,1390 2290,1370 2310,1350 2330,1330 2340,1300 2360,1280 2370,1260 2380,1240 2390,1210 "
        "2400,1190 2410,1160 2420,1140 2420,1110 2420,1080 2430,1060 2430,1030 2430,1000 2430,980 "
        "2430,950 2420,930 2420,900 2410,870 2410,850 2400,820 2390,800 2380,770 2360,750 2350,730 "
        "2340,710 2320,680 2300,660 2290,640 2270,630 2250,610 2230,590 2210,580 2190,560 2160,550 "
        "2140,540 2120,520 2090,510 2070,510 2040,500 2020,490 1990,490 1970,480 1940,480 1920,480 "
        "1890,480 1860,480 1840,490 1810,490 1790,500 1760,500 1740,510 1710,520 1690,530 1670,540 "
        "1640,560 1620,570 1600,580 1580,600 1560,620 1540,640 1520,660 1510,680 1490,700 1480,720 "
        "1460,740 1450,760");
}

CPPUNIT_TEST_FIXTURE(Test, testEllipseWithSelectClipPath)
{
    // EMF import test with records: RECTANGLE, BEGINPATH, ENDPATH, ELLIPSE
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestEllipseWithSelectClipPath.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "group/mask/polypolygon", 1);
    assertXPath(pDocument, aXPathPrefix + "group/mask/polypolygon[1]", "path",
                u"m177 776c0 211 565 423 1306 423 706 0 1307-212 1307-423 "
                u"0-247-601-423-1307-423-741 0-1306 176-1306 423z");

    assertXPath(pDocument, aXPathPrefix + "group/mask/polypolygoncolor", 1);
    assertXPath(pDocument, aXPathPrefix + "group/mask/polypolygoncolor[1]", "color", u"#ff1100");
    assertXPath(pDocument, aXPathPrefix + "group/mask/polypolygoncolor[1]/polypolygon[1]", "path",
                u"m353 353h2472v1057h-2472z");

    assertXPath(pDocument, aXPathPrefix + "group/mask/polygonstroke", 1);
    assertXPathContent(pDocument, aXPathPrefix + "group/mask/polygonstroke[1]/polygon",
                       u"353,353 2825,353 2825,1410 353,1410");
}

CPPUNIT_TEST_FIXTURE(Test, testEllipseXformIntersectClipRect)
{
    // EMF import test with records: EXTCREATEPEN, CREATEBRUSHINDIRECT, MODIFYWORLDTRANSFORM, INTERSECTCLIPRECT, ELLIPSE
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestEllipseXformIntersectClipRect.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", "path", u"m0 0h3000v2000h-3000z");
    assertXPath(pDocument, aXPathPrefix + "mask/group/mask/polypolygon", "path",
                u"m370 152 1128-409 592 1623-1128 410z");
    assertXPath(pDocument, aXPathPrefix + "mask/group/mask/polypolygoncolor", "color", u"#bbaa00");
    assertXPath(pDocument, aXPathPrefix + "mask/group/mask/polypolygoncolor/polypolygon", "path",
                u"m627 1372c157 431 965 587 1795 286 796-290 1348-940 "
                u"1191-1371-169-464-999-575-1795-286-830 302-1360 907-1191 1371z");
    assertXPathContent(pDocument, aXPathPrefix + "mask/group/mask/polygonstroke/polygon",
                       u"627,1372 2422,1658 3613,287 1818,1");
}

CPPUNIT_TEST_FIXTURE(Test, testSetArcDirection)
{
    // EMF import test with records: SETARCDIRECTION, ARC, PIE
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TestSetArcDirection.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor", "color", u"#ffffff");
    assertXPath(
        pDocument, aXPathPrefix + "polypolygoncolor/polypolygon", "path",
        u"m1640 1570-1000-950 50-50 50-50 50-50 50-40 60-40 50-40 60-30 60-40 60-20 60-30 70-20 "
        "60-20 70-10 60-20h70l70-10h60 70l70 10 60 10 70 10 70 20 60 20 60 20 70 30 60 30 60 30 50 "
        "40 60 40 50 40 50 40 50 50 50 50 50 50 40 60 40 60 40 60 30 60 30 60 30 60 20 70 30 70 10 "
        "60 20 70 10 70 10 70 10 70v80 70l-10 70v70l-10 70-20 70-20 70z");
    assertXPath(pDocument, aXPathPrefix + "polygonhairline", 2);
    assertXPath(pDocument, aXPathPrefix + "polygonhairline[1]", "color", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "polygonhairline[2]", "color", u"#000000");
    assertXPath(pDocument, aXPathPrefix + "polygonhairline", 2);
    assertXPathContent(
        pDocument, aXPathPrefix + "polygonhairline[1]/polygon",
        u"1070,1570 1110,1560 1160,1540 1200,1530 1250,1520 1300,1510 1350,1510 1400,1500 "
        u"1440,1500 "
        "1490,1500 1540,1500 1590,1500 1640,1510 1690,1510 1740,1520 1780,1530 1830,1540 1880,1560 "
        "1920,1570 1960,1590 2010,1610 2050,1630 2090,1650 2130,1670 2160,1700 2200,1720 2230,1750 "
        "2260,1780 2290,1810 2320,1840 2350,1870 2370,1900 2390,1930 2410,1970 2430,2000 2440,2030 "
        "2450,2070 2460,2110 2470,2140 2480,2180 2480,2220 2480,2250 2480,2290 2470,2320 2470,2360 "
        "2460,2400 2450,2430 2430,2470 2420,2500 2400,2540 2380,2570 2350,2600 2330,2630 2300,2660 "
        "2270,2690 2240,2720 2210,2750 2170,2770 2140,2800 2100,2820 2060,2840 2020,2860 1980,2880 "
        "1940,2900 1890,2920 1850,2930 1800,2940 1750,2950 1700,2960 1660,2970 1610,2970 1560,2980 "
        "1510,2980 1460,2980 1410,2980 1360,2970 1320,2970 1270,2960 1220,2950 1170,2940 1130,2930 "
        "1080,2910 1040,2900 1000,2880 950,2860 910,2840 870,2820 840,2800 800,2770 770,2740 "
        "730,2720 700,2690 670,2660 650,2630 620,2600 600,2560 580,2530 560,2500 550,2460 530,2430 "
        "520,2390 510,2360 510,2320 500,2280 500,2250 500,2210 500,2170 510,2140 520,2100 530,2070 "
        "540,2030 560,1990 570,1960 590,1930 610,1890 640,1860 660,1830 690,1800 720,1770 750,1740 "
        "790,1720 820,1690 860,1670 900,1650 940,1630 980,1610 1020,1590");
    assertXPathContent(
        pDocument, aXPathPrefix + "polygonhairline[2]/polygon",
        u"1640,1570 640,620 690,570 740,520 790,470 840,430 900,390 950,350 1010,320 1070,280 "
        "1130,260 1190,230 1260,210 1320,190 1390,180 1450,160 1520,160 1590,150 1650,150 1720,150 "
        "1790,160 1850,170 1920,180 1990,200 2050,220 2110,240 2180,270 2240,300 2300,330 2350,370 "
        "2410,410 2460,450 2510,490 2560,540 2610,590 2660,640 2700,700 2740,760 2780,820 2810,880 "
        "2840,940 2870,1000 2890,1070 2920,1140 2930,1200 2950,1270 2960,1340 2970,1410 2980,1480 "
        "2980,1560 2980,1630 2970,1700 2970,1770 2960,1840 2940,1910 2920,1980");
}

CPPUNIT_TEST_FIXTURE(Test, testDrawPolyLine16WithClip)
{
    // EMF image with records:
    // CREATEBRUSHINDIRECT, FILLRGN, BEGINPATH, POLYGON16, SELECTCLIPPATH, MODIFYWORLDTRANSFORM, SELECTOBJECT
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestDrawPolyLine16WithClip.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", "path", u"m0 0h3943v3939h-3943z");

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor", 1);
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[1]/polypolygon", "path",
                u"m1323 0h1323v1322h1323v1322h-1323v1322h-1323v-1322h-1323v-1322h1323z");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[1]", "color", u"#b4ffff");

    assertXPath(pDocument, aXPathPrefix + "mask/polygonhairline", 1);
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[1]/polygon",
                       u"1323,0 2646,0 2646,1322 3969,1322 3969,2644 2646,2644 2646,3966 1323,3966 "
                       "1323,2644 0,2644 0,1322 1323,1322");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonhairline[1]", "color", u"#000000");

    assertXPath(pDocument, aXPathPrefix + "mask/group[1]/mask/polypolygon", "path",
                u"m2646 0v1322h1323v1322h-1323v1322h-1323v-1322h-1323v-1322h1323v-1322");
    assertXPathContent(pDocument, aXPathPrefix + "mask/group[1]/mask/polygonstroke/polygon",
                       u"0,793 3969,4230");
}

CPPUNIT_TEST_FIXTURE(Test, testFillRegion)
{
    // EMF import with records: CREATEBRUSHINDIRECT, FILLRGN. The SETICMMODE is also used.
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TestFillRegion.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", "path", u"m0 0h3943v3939h-3943z");

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor", 1);
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[1]/polypolygon", "path",
                u"m1323 0h1323v1322h1323v1322h-1323v1322h-1323v-1322h-1323v-1322h1323z");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor[1]", "color", u"#ff0000");

    assertXPath(pDocument, aXPathPrefix + "mask/polygonhairline", 1);
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonhairline[1]/polygon",
                       u"1323,0 2646,0 2646,1322 3969,1322 3969,2644 2646,2644 2646,3966 1323,3966 "
                       "1323,2644 0,2644 0,1322 1323,1322");
    assertXPath(pDocument, aXPathPrefix + "mask/polygonhairline[1]", "color", u"#000000");
}

CPPUNIT_TEST_FIXTURE(Test, testPolylinetoCloseStroke)
{
    // EMF import with records: BEGINPATH, ARC, ENDPATH, STROKEPATH, EXTCREATEPEN.
    Primitive2DSequence aSequence
        = parseEmf(u"/emfio/qa/cppunit/emf/data/TestPolylinetoCloseStroke.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polygonhairline", 2);
    assertXPathContent(
        pDocument, aXPathPrefix + "polygonhairline[1]/polygon",
        u"1080,150 1010,170 940,190 870,210 810,230 750,260 690,280 630,310 570,340 520,380 "
        u"470,410 "
        "420,450 370,490 330,530 290,570 260,610 230,660 200,700 170,750 150,790 130,840 120,890 "
        "110,930 100,980 100,1030 100,1080 110,1130 120,1180 130,1220 140,1270 160,1320 190,1360 "
        "210,1410 250,1450 280,1490 320,1540 360,1580 400,1620 450,1650 500,1690");
    assertXPath(pDocument, aXPathPrefix + "polygonhairline[1]", "color", u"#000000");
    assertXPathContent(
        pDocument, aXPathPrefix + "polygonhairline[2]/polygon",
        u"1760,1120 1710,1130 1670,1140 1620,1150 1580,1160 1540,1170 1500,1180 1460,1200 "
        u"1420,1210 "
        "1380,1230 1350,1240 1320,1260 1290,1280 1260,1300 1230,1310 1210,1330 1190,1360 1170,1380 "
        "1150,1400 1140,1420 1120,1440 1110,1460 1110,1490 1100,1510 1100,1530 1100,1550 1100,1580 "
        "1110,1600 1120,1620 1130,1650 1140,1670 1160,1690 1170,1710 1190,1730");
    assertXPath(pDocument, aXPathPrefix + "polygonhairline[2]", "color", u"#000000");
}

CPPUNIT_TEST_FIXTURE(Test, testEmfPolydraw)
{
    // tdf#142249 EMF import with records: POLYDRAW, CREATEPEN.
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TestEmfPolydraw.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "polygonhairline", 2);
    assertXPath(pDocument, aXPathPrefix + "polygonhairline[1]", "color", u"#000000");
    assertXPathContent(pDocument, aXPathPrefix + "polygonhairline[1]/polygon",
                       u"2000,200 3000,200 3000,1000");
    assertXPath(pDocument, aXPathPrefix + "polygonhairline[2]", "color", u"#000000");
    assertXPathContent(pDocument, aXPathPrefix + "polygonhairline[2]/polygon",
                       u"3000,2000 3000,2000 4000,2000 3000,3000");

    assertXPath(pDocument, aXPathPrefix + "polygonstroke", 1);
    assertXPathContent(pDocument, aXPathPrefix + "polygonstroke[1]/polygon",
                       u"50,50 50,50 1000,1000 1000,1000 2000,2500 2000,1000");
    assertXPath(pDocument, aXPathPrefix + "polygonstroke[1]/line", "color", u"#ff0000");
    assertXPath(pDocument, aXPathPrefix + "polygonstroke[1]/stroke", "dotDashArray", u"90 30 ");
}

CPPUNIT_TEST_FIXTURE(Test, testEmfPlusBrushPathGradientWithBlendColors)
{
    // tdf#131506 EMF+ records: FillRects, Brush with PathGradient and BlendColor, FillRects
    Primitive2DSequence aSequence
        = parseEmf(u"emfio/qa/cppunit/emf/data/TestEmfPlusBrushPathGradientWithBlendColors.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "svgradialgradient", "radius", u"0.7");
    assertXPath(pDocument, aXPathPrefix + "svgradialgradient/focalx", 0);
    assertXPath(pDocument, aXPathPrefix + "svgradialgradient/focaly", 0);
    assertXPath(pDocument, aXPathPrefix + "svgradialgradient", "startx", u"1");
    assertXPath(pDocument, aXPathPrefix + "svgradialgradient", "starty", u"1");
    assertXPath(pDocument, aXPathPrefix + "svgradialgradient", "spreadmethod", u"pad");
}

CPPUNIT_TEST_FIXTURE(Test, testEmfPlusDrawCurve)
{
    // tdf#143877 EMF+ records: DrawCurve, DrawClosedCurve
    Primitive2DSequence aSequence = parseEmf(u"emfio/qa/cppunit/emf/data/TestEmfPlusDrawCurve.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke", 26);

    // Verify DrawCurve with tension=0.5, offset=0, segments=2
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[3]/line", "color", u"#ff0000");
    assertXPath(
        pDocument, aXPathPrefix + "mask/polypolygonstroke[3]/polypolygon", "path",
        u"m4121.5678588927 597.698391624308 124.350808427242 119.857180790532 168.799608035277 "
        "163.249184432137 191.024007839294 186.003527805174 191.024007839294 188.120210909643 "
        "168.799608035277 169.599233745543 124.350808427242 130.440596312875 57.677609015188 "
        "70.6442986116379 14.8162665360123 69.7182497534329 10.5830475257226 128.191620514377 "
        "6.34982851543373 166.821087170928 2.11660950514397 185.606649723086-2.11660950514397 "
        "184.548308170852-6.34982851543373 163.646062514225-10.5830475257226 "
        "122.899912753206-14.8162665360123 62.3098588877929");

    // Verify DrawCurve with tension=1.125, offset=0, segments=3
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[9]/line", "color", u"#ff0000");
    assertXPath(
        pDocument, aXPathPrefix + "mask/polypolygonstroke[9]/polypolygon", "path",
        u"m6593.23860852523 4960.44685532205 129.113179813817 111.125862984599 154.512493875552 "
        "132.292694029285 167.212150906418 147.109475760564 167.212150906418 155.576208178439 "
        "154.512493875552 157.692891282907 129.113179813817 153.45952507397 91.0142087212153 "
        "142.876109551627 59.2650661440466 139.171914118808 42.3321901028912 144.463621879979 "
        "25.399314061734 146.580304984447 8.46643802057861 145.521963432213-8.46643802057861 "
        "141.288597223276-25.399314061734 133.880206357636-42.3321901028912 "
        "123.296790835293-59.2650661440466 109.538350656248-83.6060754532091 "
        "99.2195205219632-111.121999020089 93.3986419846751-132.288094071533 "
        "85.9902511190348-147.104360607545 76.9943479250442-155.570798628123 "
        "66.4109324027004-157.687408133268 54.2400045520071-153.454189122979 "
        "40.4815643729608-142.871141597256 25.135611865564");

    // Verify DrawCurve with tension=0.125, offset=0, segments=4
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[13]/line", "color", u"#ff0000");
    assertXPath(
        pDocument, aXPathPrefix + "mask/polypolygonstroke[13]/polypolygon", "path",
        u"m4121.5678588927 9267.6323875275 124.350808427242 119.857180790532 168.799608035277 "
        "163.249184432138 191.024007839294 186.003527805173 191.024007839294 188.120210909643 "
        "168.799608035277 169.599233745543 124.350808427242 130.440596312876 57.677609015188 "
        "70.6442986116381 14.8162665360123 69.7182497534323 10.5830475257226 128.191620514377 "
        "6.34982851543373 166.821087170927 2.11660950514397 185.606649723086-2.11660950514397 "
        "184.548308170854-6.34982851543373 163.646062514224-10.5830475257226 "
        "122.899912753204-14.8162665360123 62.3098588877929-55.8255756981871 "
        "42.2675157423582-119.853013228809 69.3875180183586-163.243508084272 "
        "86.5855682421661-185.997060264576 93.861666413779-188.113669769721 "
        "91.2158125331916-169.593336599706 78.6480066004096-130.436060754531 "
        "56.1582486154312-70.6418422341994 "
        "23.7465385782562-70.6418422341985-7.93756164175647-130.436060754532-28.046051134208-169."
        "593336599706-41.8044913132544-188.113669769721-49.2128821788938-185.997060264576-50."
        "271223731128-163.243508084272-44.979515969957-119.853013228809-33.3377588953808-55."
        "8255756981871-15.3459525073959");

    // Verify DrawCurve with tension=0.125, offset=1, segments=3
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[18]/line", "color", u"#ff0000");
    assertXPath(
        pDocument, aXPathPrefix + "mask/polypolygonstroke[18]/polypolygon", "path",
        u"m5162.41058304753 14700.2318678401 10.5830475257226 128.191620514377 6.34982851543373 "
        "166.821087170927 2.11660950514397 185.606649723086-2.11660950514397 "
        "184.548308170854-6.34982851543373 163.646062514224-10.5830475257226 "
        "122.899912753204-14.8162665360123 62.3098588877929-55.8255756981871 "
        "42.2675157423582-119.853013228809 69.3875180183586-163.243508084272 "
        "86.5855682421661-185.997060264576 93.861666413779-188.113669769721 "
        "91.2158125331916-169.593336599706 78.6480066004096-130.436060754531 "
        "56.1582486154312-70.6418422341994 23.7465385782562");

    // Verify DrawClosedCurve with tension=0.5
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygonstroke[22]/line", "color", u"#ff0000");
    assertXPath(
        pDocument, aXPathPrefix + "mask/polypolygonstroke[22]/polypolygon", "path",
        u"m2709.26016658501 19012.0476443365v122.767620059174 173.568014566423 198.968211820044 "
        "198.968211820044 173.568014566423 122.767620059174 46.5670282983083l-46.5654091131796 "
        "23.283514149156-122.763351298383 61.383810029587-173.561979421852 "
        "86.7840072832114-198.961293483586 99.4841059100218-198.961293483586 "
        "99.4841059100218-173.561979421852 86.7840072832114-122.763351298383 "
        "61.383810029587-46.5654091131796 "
        "23.283514149156-46.5654091131798-11.6417570745798-122.763351298383-30.6919050147917-173."
        "561979421852-43.3920036416057-198.961293483586-49.7420529550109-198.961293483586-49."
        "7420529550109-173.561979421852-43.3920036416057-122.763351298383-30.6919050147953-46."
        "5654091131798-11.6417570745762 46.5654091131798-104.775813671193 "
        "122.763351298383-276.227145133147 173.561979421852-390.528032774448 "
        "198.961293483586-447.678476595098 198.961293483586-447.678476595102 "
        "173.561979421852-390.528032774448 122.763351298383-276.227145133147 "
        "46.5654091131798-104.775813671193 46.5654091131796 46.5670282983083 122.763351298383 "
        "122.767620059178 173.561979421852 173.568014566419 198.961293483586 198.968211820044 "
        "198.961293483586 198.968211820047 173.561979421852 173.568014566419 122.763351298383 "
        "122.767620059178 46.5654091131796 46.5670282983083z");
}

CPPUNIT_TEST_FIXTURE(Test, testEmfPlusGetDC)
{
    // tdf#147818 EMF+ records: GetDC, DrawPath, FillRects
    Primitive2DSequence aSequence = parseEmf(u"emfio/qa/cppunit/emf/data/TestEmfPlusGetDC.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "textsimpleportion", "text", u"sd CCCCCCCCCCCCCCC");
    assertXPath(pDocument, aXPathPrefix + "textsimpleportion", "fontcolor", u"#000000");

    assertXPath(pDocument, aXPathPrefix + "group", 5);
    assertXPath(
        pDocument, aXPathPrefix + "group[4]/textsimpleportion", "text",
        u"Getttttttttttttttttttttttttttttt, uuuu: \"eeeeeeeeeeeeeeeeeeeeeee-7acd04a3953b\")");
    assertXPath(pDocument, aXPathPrefix + "group[5]/textsimpleportion", "text",
                u"TTTTTTTTTTTTTTTTTTTTTTTTTTTTT, trackId: 55)");
    assertXPath(pDocument, aXPathPrefix + "group[5]/textsimpleportion", "fontcolor", u"#000000");

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor", 6);
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[1]/polypolygon", "path",
                u"m105.78125 "
                "776.111111111111h3878.64583333333l458.385416666667-493.888888888889v-176."
                "388888888889h-4337.03125v670.277777777778");
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[1]", "color", u"#ffffff");

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[3]/polypolygon", "path",
                u"m2291.92708333333 4550.83333333333h317.34375v-317.5h-317.34375z");
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[3]", "color", u"#fcf2e3");

    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[6]/polypolygon", "path",
                u"m19428.4895833333 6632.22222222222h317.34375v-2398.88888888889h-317.34375z");
    assertXPath(pDocument, aXPathPrefix + "polypolygoncolor[6]", "color", u"#fcf2e3");

    assertXPath(pDocument, aXPathPrefix + "polypolygonstroke", 4);
    assertXPath(pDocument, aXPathPrefix + "polygonstrokearrow", 13);
}

CPPUNIT_TEST_FIXTURE(Test, testEmfPlusSave)
{
    // tdf#147818 EMF+ records: Save, Restore, SetWorldTransform, FillRects, SetClipRegion
    Primitive2DSequence aSequence = parseEmf(u"/emfio/qa/cppunit/emf/data/TestEmfPlusSave.emf");
    CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(aSequence.getLength()));
    drawinglayer::Primitive2dXmlDump dumper;
    xmlDocUniquePtr pDocument = dumper.dumpAndParse(Primitive2DContainer(aSequence));
    CPPUNIT_ASSERT(pDocument);

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygon", "path", u"m0 0h33544v21311h-33544z");

    assertXPath(pDocument, aXPathPrefix + "mask/group/mask/polypolygoncolor/polypolygon", "path",
                u"m327.458333333333 638.222222222222h437007.1875v295555.555555556h-437007.1875z");
    assertXPath(pDocument, aXPathPrefix + "mask/group/mask/polypolygoncolor", "color", u"#ff0cad");

    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor/polypolygon", "path",
                u"m10853.4145539602 7321.41354709201h41952690v29630720h-41952690z");
    assertXPath(pDocument, aXPathPrefix + "mask/polypolygoncolor", "color", u"#00ffad");

    assertXPath(pDocument, aXPathPrefix + "mask/polygonstrokearrow/line", "color", u"#000000");
    assertXPathContent(pDocument, aXPathPrefix + "mask/polygonstrokearrow/polygon",
                       u"10853.4145539602,7321.41354709201 10853.4145539602,4907.54325697157 "
                       "12832.6557236512,4907.54325697157");
}

CPPUNIT_TEST_FIXTURE(Test, testEmfPlusDrawPathWithCustomCap)
{
    // tdf#142261 EMF+ records: DrawPath, SetWorldTransform, Object (Brush, Pen, Path)
--> --------------------

--> maximum size reached

--> --------------------

Messung V0.5
C=95 H=100 G=97

¤ Dauer der Verarbeitung: 0.17 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland




Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.