Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2265 insertions, 0 deletions

diff --git a/sd/qa/unit/export-tests-ooxml3.cxx b/sd/qa/unit/export-tests-ooxml3.cxx
new file mode 100644
index 000000000..5f4928b66
--- /dev/null
+++ b/sd/qa/unit/export-tests-ooxml3.cxx
@@ -0,0 +1,2265 @@
+
+/* -*- 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 <officecfg/Office/Common.hxx>
+#include "sdmodeltestbase.hxx"
+#include <comphelper/sequence.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <editeng/eeitem.hxx>
+#include <editeng/editobj.hxx>
+#include <editeng/numitem.hxx>
+#include <editeng/unoprnms.hxx>
+
+#include <svx/xlineit0.hxx>
+#include <svx/xlndsit.hxx>
+#include <svx/svdoole2.hxx>
+#include <svx/svdotable.hxx>
+
+#include <com/sun/star/awt/FontUnderline.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
+#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/frame/XLoadable.hpp>
+#include <com/sun/star/lang/Locale.hpp>
+#include <com/sun/star/text/GraphicCrop.hpp>
+
+#include <sdpage.hxx>
+
+class SdOOXMLExportTest3 : public SdModelTestBaseXML
+{
+public:
+    void testTdf92222();
+    void testTdf129430();
+    void testTdf114848();
+    void testTdf147586();
+    void testTdf68759();
+    void testTdf127901();
+    void testTdf48735();
+    void testTdf90626();
+    void testTdf107608();
+    void testTdf111786();
+    void testFontScale();
+    void testShapeAutofitPPTX();
+    void testLegacyShapeAutofitPPTX();
+    void testTdf115394();
+    void testTdf115394Zero();
+    void testTdf115005();
+    int testTdf115005_FallBack_Images(bool bAddReplacementImages);
+    void testTdf115005_FallBack_Images_On();
+    void testTdf115005_FallBack_Images_Off();
+    void testTdf118806();
+    void testTdf130058();
+    void testTdf111789();
+    void testTdf145162();
+    void testZeroIndentExport();
+    void testTdf100348_convert_Fontwork2TextWarp();
+    void testTdf1225573_FontWorkScaleX();
+    void testTdf99497_keepAppearanceOfCircleKind();
+    /// SmartArt animated elements
+    void testTdf104792();
+    void testTdf90627();
+    void testTdf104786();
+    void testTdf118783();
+    void testTdf104789();
+    void testOpenDocumentAsReadOnly();
+    void testTdf118835();
+    void testTdf118768();
+    void testTdf118836();
+    void testTdf116350TextEffects();
+    void testTdf128096();
+    void testTdf120573();
+    void testTdf119118();
+    void testTdf99213();
+    void testPotxExport();
+    void testTdf44223();
+    void testTdf135843();
+    void testSmartArtPreserve();
+    void testTdf125346();
+    void testTdf125346_2();
+    void testTdf125360();
+    void testTdf125360_1();
+    void testTdf125360_2();
+    void testTdf125551();
+    void testTdf136830();
+    void testTdf126234();
+    void testTdf126741();
+    void testTdf127372();
+    void testTdf127379();
+    void testTdf98603();
+    void testTdf79082();
+    void testTdf128213();
+    void testTdf129372();
+    void testShapeGlowEffect();
+    void testUnderline();
+    void testTdf119087();
+    void testTdf131554();
+    void testTdf132282();
+    void testTdf132201EffectOrder();
+    void testShapeSoftEdgeEffect();
+    void testShapeShadowBlurEffect();
+    void testTdf119223();
+    void testTdf128213ShapeRot();
+    void testTdf125560_textDeflate();
+    void testTdf125560_textInflateTop();
+    void testTdf96061_textHighlight();
+    void testTdf143222_embeddedWorksheet();
+    void testTdf142235_TestPlaceholderTextAlignment();
+    void testTdf143315();
+    void testTdf147121();
+    void testTdf140912_PicturePlaceholder();
+    void testEnhancedPathViewBox();
+    void testTdf74670();
+    void testTdf109169_OctagonBevel();
+    void testTdf109169_DiamondBevel();
+    void testTdf144092_emptyShapeTextProps();
+    void testTdf94122_autoColor();
+    void testTdf124333();
+    void testAutofittedTextboxIndent();
+    void testTdf152436();
+
+    CPPUNIT_TEST_SUITE(SdOOXMLExportTest3);
+
+    CPPUNIT_TEST(testTdf92222);
+    CPPUNIT_TEST(testTdf129430);
+    CPPUNIT_TEST(testTdf114848);
+    CPPUNIT_TEST(testTdf147586);
+    CPPUNIT_TEST(testTdf68759);
+    CPPUNIT_TEST(testTdf127901);
+    CPPUNIT_TEST(testTdf48735);
+    CPPUNIT_TEST(testTdf90626);
+    CPPUNIT_TEST(testTdf107608);
+    CPPUNIT_TEST(testTdf111786);
+    CPPUNIT_TEST(testFontScale);
+    CPPUNIT_TEST(testShapeAutofitPPTX);
+    CPPUNIT_TEST(testLegacyShapeAutofitPPTX);
+    CPPUNIT_TEST(testTdf115394);
+    CPPUNIT_TEST(testTdf115394Zero);
+    CPPUNIT_TEST(testTdf115005);
+    CPPUNIT_TEST(testTdf115005_FallBack_Images_On);
+    CPPUNIT_TEST(testTdf115005_FallBack_Images_Off);
+    CPPUNIT_TEST(testTdf118806);
+    CPPUNIT_TEST(testTdf130058);
+    CPPUNIT_TEST(testTdf111789);
+    CPPUNIT_TEST(testTdf145162);
+    CPPUNIT_TEST(testZeroIndentExport);
+    CPPUNIT_TEST(testTdf100348_convert_Fontwork2TextWarp);
+    CPPUNIT_TEST(testTdf1225573_FontWorkScaleX);
+    CPPUNIT_TEST(testTdf99497_keepAppearanceOfCircleKind);
+    CPPUNIT_TEST(testTdf104792);
+    CPPUNIT_TEST(testTdf90627);
+    CPPUNIT_TEST(testTdf104786);
+    CPPUNIT_TEST(testTdf118783);
+    CPPUNIT_TEST(testTdf104789);
+    CPPUNIT_TEST(testOpenDocumentAsReadOnly);
+    CPPUNIT_TEST(testTdf118835);
+    CPPUNIT_TEST(testTdf118768);
+    CPPUNIT_TEST(testTdf118836);
+    CPPUNIT_TEST(testTdf116350TextEffects);
+    CPPUNIT_TEST(testTdf128096);
+    CPPUNIT_TEST(testTdf120573);
+    CPPUNIT_TEST(testTdf119118);
+    CPPUNIT_TEST(testTdf99213);
+    CPPUNIT_TEST(testPotxExport);
+    CPPUNIT_TEST(testTdf44223);
+    CPPUNIT_TEST(testTdf135843);
+    CPPUNIT_TEST(testSmartArtPreserve);
+    CPPUNIT_TEST(testTdf125346);
+    CPPUNIT_TEST(testTdf125346_2);
+    CPPUNIT_TEST(testTdf125360);
+    CPPUNIT_TEST(testTdf125360_1);
+    CPPUNIT_TEST(testTdf125360_2);
+    CPPUNIT_TEST(testTdf125551);
+    CPPUNIT_TEST(testTdf136830);
+    CPPUNIT_TEST(testTdf126234);
+    CPPUNIT_TEST(testTdf126741);
+    CPPUNIT_TEST(testTdf127372);
+    CPPUNIT_TEST(testTdf127379);
+    CPPUNIT_TEST(testTdf98603);
+    CPPUNIT_TEST(testTdf79082);
+    CPPUNIT_TEST(testTdf128213);
+    CPPUNIT_TEST(testTdf129372);
+    CPPUNIT_TEST(testShapeGlowEffect);
+    CPPUNIT_TEST(testUnderline);
+    CPPUNIT_TEST(testTdf119087);
+    CPPUNIT_TEST(testTdf131554);
+    CPPUNIT_TEST(testTdf132282);
+    CPPUNIT_TEST(testTdf132201EffectOrder);
+    CPPUNIT_TEST(testShapeSoftEdgeEffect);
+    CPPUNIT_TEST(testShapeShadowBlurEffect);
+    CPPUNIT_TEST(testTdf119223);
+    CPPUNIT_TEST(testTdf128213ShapeRot);
+    CPPUNIT_TEST(testTdf125560_textDeflate);
+    CPPUNIT_TEST(testTdf125560_textInflateTop);
+    CPPUNIT_TEST(testTdf96061_textHighlight);
+    CPPUNIT_TEST(testTdf143222_embeddedWorksheet);
+    CPPUNIT_TEST(testTdf142235_TestPlaceholderTextAlignment);
+    CPPUNIT_TEST(testTdf143315);
+    CPPUNIT_TEST(testTdf147121);
+    CPPUNIT_TEST(testTdf140912_PicturePlaceholder);
+    CPPUNIT_TEST(testEnhancedPathViewBox);
+    CPPUNIT_TEST(testTdf74670);
+    CPPUNIT_TEST(testTdf109169_OctagonBevel);
+    CPPUNIT_TEST(testTdf109169_DiamondBevel);
+    CPPUNIT_TEST(testTdf144092_emptyShapeTextProps);
+    CPPUNIT_TEST(testTdf94122_autoColor);
+    CPPUNIT_TEST(testTdf124333);
+    CPPUNIT_TEST(testAutofittedTextboxIndent);
+    CPPUNIT_TEST(testTdf152436);
+    CPPUNIT_TEST_SUITE_END();
+
+    virtual void registerNamespaces(xmlXPathContextPtr& pXmlXPathCtx) override
+    {
+        XmlTestTools::registerODFNamespaces(pXmlXPathCtx);
+        XmlTestTools::registerOOXMLNamespaces(pXmlXPathCtx);
+    }
+};
+
+void SdOOXMLExportTest3::testTdf92222()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf92222.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocTheme = parseExport(tempFile, "ppt/theme/theme1.xml");
+    assertXPath(pXmlDocTheme, "/a:theme/a:themeElements/a:fmtScheme/a:lnStyleLst/a:ln[1]", "w",
+                "6350");
+    assertXPath(pXmlDocTheme, "/a:theme/a:themeElements/a:fmtScheme/a:lnStyleLst/a:ln[2]", "w",
+                "12700");
+    assertXPath(pXmlDocTheme, "/a:theme/a:themeElements/a:fmtScheme/a:lnStyleLst/a:ln[3]", "w",
+                "19050");
+}
+
+void SdOOXMLExportTest3::testTdf129430()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/odp/tdf129430.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDoc1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDoc1, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p[2]/a:pPr/a:lnSpc/a:spcPct",
+                "val", "100000");
+}
+
+void SdOOXMLExportTest3::testTdf114848()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf114848.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocTheme1 = parseExport(tempFile, "ppt/theme/theme1.xml");
+    assertXPath(pXmlDocTheme1, "/a:theme/a:themeElements/a:clrScheme/a:dk2/a:srgbClr", "val",
+                "1f497d");
+    xmlDocUniquePtr pXmlDocTheme2 = parseExport(tempFile, "ppt/theme/theme2.xml");
+    assertXPath(pXmlDocTheme2, "/a:theme/a:themeElements/a:clrScheme/a:dk2/a:srgbClr", "val",
+                "1f497d");
+}
+
+void SdOOXMLExportTest3::testTdf147586()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf147586.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    // Without the fix in place, this test would have failed with
+    // - Expected: 227fc7
+    // - Actual  : 4f4f4f
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[1]/p:txBody/a:p[1]/a:pPr/a:buClr/a:srgbClr", "val",
+                "227fc7");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[1]/p:txBody/a:p[2]/a:pPr/a:buClr/a:srgbClr", "val",
+                "227fc7");
+}
+
+void SdOOXMLExportTest3::testTdf68759()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf68759.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[1]/p:spPr/a:xfrm/a:off", "x",
+                "1687320");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[1]/p:spPr/a:xfrm/a:off", "y",
+                "1615320");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[2]/p:spPr/a:xfrm", "flipH", "1");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[2]/p:spPr/a:xfrm", "rot", "9600000");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[2]/p:spPr/a:xfrm/a:off", "x",
+                "3847320");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[2]/p:spPr/a:xfrm/a:off", "y",
+                "1614600");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[3]/p:spPr/a:xfrm", "flipH", "1");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[3]/p:spPr/a:xfrm/a:off", "x",
+                "5934960");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:pic[3]/p:spPr/a:xfrm/a:off", "y",
+                "1615320");
+}
+
+void SdOOXMLExportTest3::testTdf127901()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf127901.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocContent1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent1, "/p:sld/p:cSld/p:spTree/p:pic/p:blipFill/a:blip/a:lum", "bright",
+                "70000");
+    assertXPath(pXmlDocContent1, "/p:sld/p:cSld/p:spTree/p:pic/p:blipFill/a:blip/a:lum", "contrast",
+                "-70000");
+
+    xmlDocUniquePtr pXmlDocContent2 = parseExport(tempFile, "ppt/slides/slide2.xml");
+    assertXPath(pXmlDocContent2, "/p:sld/p:cSld/p:spTree/p:pic/p:blipFill/a:blip/a:grayscl", 1);
+
+    xmlDocUniquePtr pXmlDocContent3 = parseExport(tempFile, "ppt/slides/slide3.xml");
+    assertXPath(pXmlDocContent3, "/p:sld/p:cSld/p:spTree/p:pic/p:blipFill/a:blip/a:biLevel",
+                "thresh", "50000");
+}
+
+void SdOOXMLExportTest3::testTdf48735()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf48735.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocContent1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent1, "/p:sld/p:cSld/p:spTree/p:pic/p:blipFill/a:srcRect", "b", "23627");
+    assertXPath(pXmlDocContent1, "/p:sld/p:cSld/p:spTree/p:pic/p:blipFill/a:srcRect", "l", "23627");
+    assertXPath(pXmlDocContent1, "/p:sld/p:cSld/p:spTree/p:pic/p:blipFill/a:srcRect", "r", "23627");
+    assertXPath(pXmlDocContent1, "/p:sld/p:cSld/p:spTree/p:pic/p:blipFill/a:srcRect", "t", "18842");
+}
+
+void SdOOXMLExportTest3::testTdf90626()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf90626.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[1]/a:pPr/a:buSzPct",
+                "val", "100000");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[2]/a:pPr/a:buSzPct",
+                "val", "150142");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[3]/a:pPr/a:buSzPct",
+                "val", "100000");
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[4]/a:pPr/a:buSzPct",
+                "val", "150142");
+}
+
+void SdOOXMLExportTest3::testTdf107608()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf107608.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    uno::Reference<beans::XPropertySet> xPropSet(xShape, uno::UNO_SET_THROW);
+
+    drawing::FillStyle aFillStyle(drawing::FillStyle_NONE);
+    xPropSet->getPropertyValue("FillStyle") >>= aFillStyle;
+    CPPUNIT_ASSERT_EQUAL(drawing::FillStyle_HATCH, aFillStyle);
+
+    bool bBackgroundFill = false;
+    xPropSet->getPropertyValue("FillBackground") >>= bBackgroundFill;
+    CPPUNIT_ASSERT(bBackgroundFill);
+
+    Color nBackgroundColor;
+    xPropSet->getPropertyValue("FillColor") >>= nBackgroundColor;
+    CPPUNIT_ASSERT_EQUAL(Color(0x92D050), nBackgroundColor);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf111786()
+{
+    // Export line transparency with the color
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf111786.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    uno::Reference<beans::XPropertySet> xPropSet(xShape, uno::UNO_SET_THROW);
+
+    Color nLineColor;
+    xPropSet->getPropertyValue("LineColor") >>= nLineColor;
+    CPPUNIT_ASSERT_EQUAL(Color(0x3465A4), nLineColor);
+
+    sal_Int16 nTransparency;
+    xPropSet->getPropertyValue("LineTransparence") >>= nTransparency;
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int16>(33), nTransparency);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testFontScale()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/font-scale.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+
+    // Rounding errors possible, approximate value (+/- 1%)
+    OUString sScale = getXPath(
+        pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:bodyPr/a:normAutofit", "fontScale");
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(sal_Int32(76000), sScale.toInt32(), 1000);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testShapeAutofitPPTX()
+{
+    sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/testShapeAutofit.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    CPPUNIT_ASSERT(pXmlDocContent);
+
+    // TextAutoGrowHeight --> "Resize shape to fit text" --> true
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[1]/p:txBody/a:bodyPr/a:spAutoFit", 1);
+    // TextAutoGrowHeight --> "Resize shape to fit text" --> false
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:bodyPr/a:noAutofit", 1);
+}
+
+void SdOOXMLExportTest3::testLegacyShapeAutofitPPTX()
+{
+    sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"/sd/qa/unit/data/odp/testLegacyShapeAutofit.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    CPPUNIT_ASSERT(pXmlDocContent);
+
+    // Text in a legacy rectangle
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[1]/p:txBody/a:bodyPr/a:noAutofit", 1);
+    // Text in (closed) Polygon
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:bodyPr/a:noAutofit", 1);
+    // Text in a legacy ellipse
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[3]/p:txBody/a:bodyPr/a:noAutofit", 1);
+}
+
+void SdOOXMLExportTest3::testTdf115394()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf115394.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    double fTransitionDuration;
+
+    // Slow in MS formats
+    SdPage* pPage1 = xDocShRef->GetDoc()->GetSdPage(0, PageKind::Standard);
+    fTransitionDuration = pPage1->getTransitionDuration();
+    CPPUNIT_ASSERT_EQUAL(1.0, fTransitionDuration);
+
+    // Medium in MS formats
+    SdPage* pPage2 = xDocShRef->GetDoc()->GetSdPage(1, PageKind::Standard);
+    fTransitionDuration = pPage2->getTransitionDuration();
+    CPPUNIT_ASSERT_EQUAL(0.75, fTransitionDuration);
+
+    // Fast in MS formats
+    SdPage* pPage3 = xDocShRef->GetDoc()->GetSdPage(2, PageKind::Standard);
+    fTransitionDuration = pPage3->getTransitionDuration();
+    CPPUNIT_ASSERT_EQUAL(0.5, fTransitionDuration);
+
+    // Custom values
+    SdPage* pPage4 = xDocShRef->GetDoc()->GetSdPage(3, PageKind::Standard);
+    fTransitionDuration = pPage4->getTransitionDuration();
+    CPPUNIT_ASSERT_EQUAL(0.25, fTransitionDuration);
+
+    SdPage* pPage5 = xDocShRef->GetDoc()->GetSdPage(4, PageKind::Standard);
+    fTransitionDuration = pPage5->getTransitionDuration();
+    CPPUNIT_ASSERT_EQUAL(4.25, fTransitionDuration);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf115394Zero()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf115394-zero.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    double fTransitionDuration;
+
+    SdPage* pPage = xDocShRef->GetDoc()->GetSdPage(0, PageKind::Standard);
+    fTransitionDuration = pPage->getTransitionDuration();
+    CPPUNIT_ASSERT_EQUAL(0.01, fTransitionDuration);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf115005()
+{
+    sd::DrawDocShellRef xDocShRefOriginal
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf115005.odp"), ODP);
+    utl::TempFile tempFile;
+    sd::DrawDocShellRef xDocShRefResaved = saveAndReload(xDocShRefOriginal.get(), ODP, &tempFile);
+
+    // additional checks of the output file
+    uno::Reference<packages::zip::XZipFileAccess2> xNameAccess
+        = packages::zip::ZipFileAccess::createWithURL(comphelper::getComponentContext(m_xSFactory),
+                                                      tempFile.GetURL());
+
+    // check that the document contains original vector images
+    const uno::Sequence<OUString> names = xNameAccess->getElementNames();
+    int nSVMFiles = 0;
+    for (OUString const& s : names)
+    {
+        if (s.endsWith(".svm"))
+            nSVMFiles++;
+    }
+    CPPUNIT_ASSERT_EQUAL(3, nSVMFiles);
+}
+
+int SdOOXMLExportTest3::testTdf115005_FallBack_Images(bool bAddReplacementImages)
+{
+    sd::DrawDocShellRef xDocShRefOriginal = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf115005_no_fallback_images.odp"), ODP);
+
+    // check if fallback images were not created if AddReplacementImages=true/false
+    // set AddReplacementImages
+    {
+        std::shared_ptr<comphelper::ConfigurationChanges> batch(
+            comphelper::ConfigurationChanges::create());
+        if (!officecfg::Office::Common::Save::Graphic::AddReplacementImages::isReadOnly())
+            officecfg::Office::Common::Save::Graphic::AddReplacementImages::set(
+                bAddReplacementImages, batch);
+        batch->commit();
+    }
+
+    // save the file with already set options
+    utl::TempFile tempFile;
+    sd::DrawDocShellRef xDocShRefResaved = saveAndReload(xDocShRefOriginal.get(), ODP, &tempFile);
+
+    // additional checks of the output file
+    uno::Reference<packages::zip::XZipFileAccess2> xNameAccess
+        = packages::zip::ZipFileAccess::createWithURL(comphelper::getComponentContext(m_xSFactory),
+                                                      tempFile.GetURL());
+
+    // check that the document contains original vector images
+    const uno::Sequence<OUString> names = xNameAccess->getElementNames();
+    int nSVMFiles = 0;
+    int nPNGFiles = 0;
+    for (OUString const& n : names)
+    {
+        if (n.endsWith(".svm"))
+            nSVMFiles++;
+        if (n.endsWith(".png"))
+            nPNGFiles++;
+    }
+
+    // check results
+    CPPUNIT_ASSERT_EQUAL(1, nSVMFiles);
+    return nPNGFiles;
+}
+
+void SdOOXMLExportTest3::testTdf115005_FallBack_Images_On()
+{
+    const int nPNGFiles = testTdf115005_FallBack_Images(true);
+    CPPUNIT_ASSERT_EQUAL(1, nPNGFiles);
+}
+
+void SdOOXMLExportTest3::testTdf115005_FallBack_Images_Off()
+{
+    const int nPNGFiles = testTdf115005_FallBack_Images(false);
+    CPPUNIT_ASSERT_EQUAL(0, nPNGFiles);
+}
+
+void SdOOXMLExportTest3::testTdf118806()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf118806.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent, "//p:animMotion", "origin", "layout");
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf130058()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf130058.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    bool bHasShadow = false;
+    xShape->getPropertyValue("Shadow") >>= bHasShadow;
+    CPPUNIT_ASSERT(bHasShadow);
+    double fShadowDist = 0.0;
+    xShape->getPropertyValue("ShadowXDistance") >>= fShadowDist;
+    CPPUNIT_ASSERT_EQUAL(static_cast<double>(0), fShadowDist);
+    xShape->getPropertyValue("ShadowYDistance") >>= fShadowDist;
+    CPPUNIT_ASSERT_EQUAL(static_cast<double>(141), fShadowDist);
+    Color nColor;
+    xShape->getPropertyValue("ShadowColor") >>= nColor;
+    CPPUNIT_ASSERT_EQUAL(COL_BLACK, nColor);
+    sal_Int32 nTransparency = 0;
+    xShape->getPropertyValue("ShadowTransparence") >>= nTransparency;
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(57), nTransparency);
+    double fShadowSizeX = 0.0;
+    xShape->getPropertyValue("ShadowSizeX") >>= fShadowSizeX;
+    CPPUNIT_ASSERT_EQUAL(static_cast<double>(1000), fShadowSizeX);
+    double fShadowSizeY = 0.0;
+    xShape->getPropertyValue("ShadowSizeY") >>= fShadowSizeY;
+    CPPUNIT_ASSERT_EQUAL(static_cast<double>(1000), fShadowSizeY);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf111789()
+{
+    // Shadow properties were not exported for text shapes.
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf111789.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    // First text shape has some shadow
+    {
+        uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+        bool bHasShadow = false;
+        xShape->getPropertyValue("Shadow") >>= bHasShadow;
+        CPPUNIT_ASSERT(bHasShadow);
+        double fShadowDist = 0.0;
+        xShape->getPropertyValue("ShadowXDistance") >>= fShadowDist;
+        CPPUNIT_ASSERT_EQUAL(static_cast<double>(273), fShadowDist);
+        xShape->getPropertyValue("ShadowYDistance") >>= fShadowDist;
+        CPPUNIT_ASSERT_EQUAL(static_cast<double>(273), fShadowDist);
+        Color nColor;
+        xShape->getPropertyValue("ShadowColor") >>= nColor;
+        CPPUNIT_ASSERT_EQUAL(Color(0xFF0000), nColor);
+        sal_Int32 nTransparency = 0;
+        xShape->getPropertyValue("ShadowTransparence") >>= nTransparency;
+        CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(7), nTransparency);
+        double fShadowSizeX = 0.0;
+        xShape->getPropertyValue("ShadowSizeX") >>= fShadowSizeX;
+        CPPUNIT_ASSERT_EQUAL(static_cast<double>(100000), fShadowSizeX);
+        double fShadowSizeY = 0.0;
+        xShape->getPropertyValue("ShadowSizeY") >>= fShadowSizeY;
+        CPPUNIT_ASSERT_EQUAL(static_cast<double>(100000), fShadowSizeY);
+    }
+
+    // Second text shape has no shadow
+    {
+        uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(1, 0, xDocShRef));
+        bool bHasShadow = false;
+        xShape->getPropertyValue("Shadow") >>= bHasShadow;
+        CPPUNIT_ASSERT(!bHasShadow);
+    }
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf145162()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf145162.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+
+    assertXPath(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[2]/a:pPr/a:buNone");
+    // Before the fix, that tag was missing so PP put bullet to each para.
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testZeroIndentExport()
+{
+    // Load the bugdoc and save to pptx then.
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/testZeroIndent.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    // There are 3 slides, get them
+    xmlDocUniquePtr pSlide1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+    xmlDocUniquePtr pSlide2 = parseExport(tempFile, "ppt/slides/slide2.xml");
+    xmlDocUniquePtr pSlide3 = parseExport(tempFile, "ppt/slides/slide3.xml");
+
+    CPPUNIT_ASSERT(pSlide1);
+    CPPUNIT_ASSERT(pSlide2);
+    CPPUNIT_ASSERT(pSlide3);
+
+    // Each slide has 3 paragraphs, one full line, an empty and a normal para.
+    // Check the indent and bullet. These have to match with PP. Before the fix,
+    // they were different.
+    assertXPath(pSlide1, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[2]/a:pPr/a:buNone");
+
+    assertXPath(pSlide2, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[1]/a:pPr/a:buNone");
+    assertXPath(pSlide2, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[1]/a:pPr", "indent", "0");
+    assertXPath(pSlide2, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[2]/a:pPr/a:buNone");
+    assertXPath(pSlide2, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[2]/a:pPr", "indent", "0");
+    assertXPath(pSlide2, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[3]/a:pPr/a:buNone");
+    assertXPath(pSlide2, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[3]/a:pPr", "indent", "0");
+
+    assertXPath(pSlide3, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[1]/a:pPr", "indent", "0");
+    assertXPath(pSlide3, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[2]/a:pPr/a:buNone");
+    assertXPath(pSlide3, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[2]/a:pPr", "indent", "0");
+    assertXPath(pSlide3, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p[3]/a:pPr", "indent", "0");
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf100348_convert_Fontwork2TextWarp()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"/sd/qa/unit/data/odp/tdf100348_Fontwork2TextWarp.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    // Resulting pptx has to contain the TextWarp shape
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    const OString sPathStart("/p:sld/p:cSld/p:spTree/p:sp[1]/p:txBody/a:bodyPr/a:prstTxWarp");
+    assertXPath(pXmlDocContent, sPathStart + "[@prst='textWave1']");
+    const OString sPathAdj(sPathStart + "/a:avLst/a:gd");
+    assertXPath(pXmlDocContent, sPathAdj + "[@name='adj1' and  @fmla='val 18750']");
+    assertXPath(pXmlDocContent, sPathAdj + "[@name='adj2' and  @fmla='val -7500']");
+
+    // Reloading has to get the Fontwork shape back
+    // TextPath makes a custom shape to a Fontwork shape, so must exist
+    uno::Reference<beans::XPropertySet> xShapeWavePropSet(getShapeFromPage(0, 0, xDocShRef));
+    auto aGeomPropSeq = xShapeWavePropSet->getPropertyValue("CustomShapeGeometry")
+                            .get<uno::Sequence<beans::PropertyValue>>();
+    auto aGeomPropVec
+        = comphelper::sequenceToContainer<std::vector<beans::PropertyValue>>(aGeomPropSeq);
+    OUString sName = "TextPath";
+    auto aIterator = std::find_if(
+        aGeomPropVec.begin(), aGeomPropVec.end(),
+        [sName](const beans::PropertyValue& rValue) { return rValue.Name == sName; });
+    CPPUNIT_ASSERT_MESSAGE("No TextPath", aIterator != aGeomPropVec.end());
+
+    // Type has to be same as in original document on roundtrip.
+    sName = "Type";
+    auto aIterator2 = std::find_if(
+        aGeomPropVec.begin(), aGeomPropVec.end(),
+        [sName](const beans::PropertyValue& rValue) { return rValue.Name == sName; });
+    CPPUNIT_ASSERT_MESSAGE("No Type", aIterator2 != aGeomPropVec.end());
+    OUString sOwnName;
+    aIterator2->Value >>= sOwnName;
+    CPPUNIT_ASSERT_EQUAL(OUString("fontwork-wave"), sOwnName);
+
+    // Adjustmentvalues need to be the same.
+    sName = "AdjustmentValues";
+    auto aIterator3 = std::find_if(
+        aGeomPropVec.begin(), aGeomPropVec.end(),
+        [sName](const beans::PropertyValue& rValue) { return rValue.Name == sName; });
+    CPPUNIT_ASSERT_MESSAGE("No AdjustmentValues", aIterator3 != aGeomPropVec.end());
+    uno::Sequence<drawing::EnhancedCustomShapeAdjustmentValue> aAdjValueSeq;
+    aIterator3->Value >>= aAdjValueSeq;
+    double fAdj1;
+    aAdjValueSeq[0].Value >>= fAdj1;
+    double fAdj2;
+    aAdjValueSeq[1].Value >>= fAdj2;
+    CPPUNIT_ASSERT_EQUAL(4050.0, fAdj1); // odp values, not pptx values
+    CPPUNIT_ASSERT_EQUAL(9180.0, fAdj2);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf1225573_FontWorkScaleX()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf125573_FontWorkScaleX.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    // Error was, that attribute 'fromWordArt' was ignored
+    // ensure, resulting pptx has fromWordArt="1" on textArchDown shape
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[1]/p:txBody/a:bodyPr[@fromWordArt='1']");
+
+    // Error was, that text in legacy shapes of category "Follow Path" was not scaled to the path.
+    uno::Reference<beans::XPropertySet> xShapeArchProps(getShapeFromPage(0, 0, xDocShRef));
+    awt::Rectangle aBoundRectArch;
+    xShapeArchProps->getPropertyValue(UNO_NAME_MISC_OBJ_BOUNDRECT) >>= aBoundRectArch;
+    // difference should be zero, but allow some range for stroke thickness
+    CPPUNIT_ASSERT_LESS(sal_Int32(50), std::abs(aBoundRectArch.Width - 13081));
+
+    // Error was, that text in shapes of category "Warp" was not scaled to the path.
+    uno::Reference<beans::XPropertySet> xShapeWaveProps(getShapeFromPage(0, 1, xDocShRef));
+    awt::Rectangle aBoundRectWave;
+    xShapeWaveProps->getPropertyValue(UNO_NAME_MISC_OBJ_BOUNDRECT) >>= aBoundRectWave;
+    // difference should be zero, but allow some range for stroke thickness
+    CPPUNIT_ASSERT_LESS(sal_Int32(50), std::abs(aBoundRectWave.Width - 11514));
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf99497_keepAppearanceOfCircleKind()
+{
+    // Error was, that all CircleKind were exported to 'ellipse'.
+    // Resulting pptx has to contain the customshapes of the corresponding kind
+    // slide 1 ARC -> arc, slide 2 CUT -> chord, slide 3 SECTION -> pie
+    // Adjustment values need to exist and their values need to correspond to the
+    // original angles. Shape 'arc' needs to be unfilled.
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"/sd/qa/unit/data/odp/tdf99497_CircleKind.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    // slide 1 45° -> adj1 = 20493903, 270° -> adj2 = 5400000, <a:noFill/> exists
+    xmlDocUniquePtr pXmlDocContent1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+    const OString sPathStart1("/p:sld/p:cSld/p:spTree/p:sp/p:spPr/a:prstGeom");
+    assertXPath(pXmlDocContent1, sPathStart1 + "[@prst='arc']");
+    const OString sPathAdj1(sPathStart1 + "/a:avLst/a:gd");
+    assertXPath(pXmlDocContent1, sPathAdj1 + "[@name='adj1' and  @fmla='val 20493903']");
+    assertXPath(pXmlDocContent1, sPathAdj1 + "[@name='adj2' and  @fmla='val 5400000']");
+    assertXPath(pXmlDocContent1, "/p:sld/p:cSld/p:spTree/p:sp/p:spPr/a:noFill");
+
+    // slide 2 270° -> adj1 = 5400000, 180° -> adj2 = 10800000
+    xmlDocUniquePtr pXmlDocContent2 = parseExport(tempFile, "ppt/slides/slide2.xml");
+    const OString sPathStart2("/p:sld/p:cSld/p:spTree/p:sp/p:spPr/a:prstGeom");
+    assertXPath(pXmlDocContent2, sPathStart2 + "[@prst='chord']");
+    const OString sPathAdj2(sPathStart2 + "/a:avLst/a:gd");
+    assertXPath(pXmlDocContent2, sPathAdj2 + "[@name='adj1' and  @fmla='val 5400000']");
+    assertXPath(pXmlDocContent2, sPathAdj2 + "[@name='adj2' and  @fmla='val 10800000']");
+
+    // slide 3 120° -> adj1 = 12600000, 30° -> adj2 = 20946396
+    xmlDocUniquePtr pXmlDocContent3 = parseExport(tempFile, "ppt/slides/slide3.xml");
+    const OString sPathStart3("/p:sld/p:cSld/p:spTree/p:sp/p:spPr/a:prstGeom");
+    assertXPath(pXmlDocContent3, sPathStart3 + "[@prst='pie']");
+    const OString sPathAdj3(sPathStart3 + "/a:avLst/a:gd");
+    assertXPath(pXmlDocContent3, sPathAdj3 + "[@name='adj1' and  @fmla='val 12600000']");
+    assertXPath(pXmlDocContent3, sPathAdj3 + "[@name='adj2' and  @fmla='val 20946396']");
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf104792()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf104792-smart-art-animation.pptx"),
+        PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:timing/p:tnLst/p:par/p:cTn/p:childTnLst[1]/p:seq/p:cTn/p:childTnLst[1]/"
+                "p:par[1]/p:cTn/p:childTnLst[1]/p:par/p:cTn/p:childTnLst[1]/p:par/p:cTn/"
+                "p:childTnLst[1]/p:set/p:cBhvr/p:tgtEl/p:spTgt",
+                1);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf90627()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf90627.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    // Don't export empty endCondLst without cond.
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:timing/p:tnLst/p:par/p:cTn/p:childTnLst[1]/p:seq/p:cTn/p:childTnLst[1]/"
+                "p:par[2]/p:cTn/p:childTnLst[1]/p:par/p:cTn/p:childTnLst[1]/p:par/p:cTn/"
+                "p:endCondLst[not(*)]",
+                0);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf104786()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf104786.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide2.xml");
+    // Don't export empty 'to'
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:timing/p:tnLst/p:par/p:cTn/p:childTnLst[1]/p:seq/p:cTn/p:childTnLst[1]/"
+                "p:par[2]/p:cTn/p:childTnLst[1]/p:par/p:cTn/p:childTnLst[1]/p:par/p:cTn/"
+                "p:childTnLst/p:set[2]/p:to",
+                0);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf118783()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf118783.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    OUString sAttributeName
+        = getXPathContent(pXmlDocContent, "//p:animRot/p:cBhvr/p:attrNameLst/p:attrName");
+    CPPUNIT_ASSERT_EQUAL(OUString("r"), sAttributeName);
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf104789()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf104789.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    OUString sAttributeName = getXPathContent(
+        pXmlDocContent, "/p:sld/p:timing/p:tnLst/p:par/p:cTn/p:childTnLst/p:seq/p:cTn/p:childTnLst/"
+                        "p:par/p:cTn/p:childTnLst/p:par/p:cTn/p:childTnLst/p:par/p:cTn/"
+                        "p:childTnLst/p:set/p:cBhvr/p:attrNameLst/p:attrName");
+    CPPUNIT_ASSERT_EQUAL(OUString("style.opacity"), sAttributeName);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testOpenDocumentAsReadOnly()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/open-as-read-only.pptx"), PPTX);
+    CPPUNIT_ASSERT(xDocShRef->IsSecurityOptOpenReadOnly());
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    CPPUNIT_ASSERT(xDocShRef->IsSecurityOptOpenReadOnly());
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf118835()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf118835.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent, "(//p:animClr)[1]", "clrSpc", "rgb");
+    assertXPathContent(pXmlDocContent, "(//p:animClr)[1]//p:attrName", "style.color");
+    assertXPath(pXmlDocContent, "(//p:animClr)[1]//p:to/a:srgbClr", "val", "ed1c24");
+
+    assertXPath(pXmlDocContent, "(//p:animClr)[2]", "clrSpc", "rgb");
+    assertXPathContent(pXmlDocContent, "(//p:animClr)[2]//p:attrName", "stroke.color");
+    assertXPath(pXmlDocContent, "(//p:animClr)[2]//p:to/a:srgbClr", "val", "333399");
+
+    assertXPath(pXmlDocContent, "(//p:animClr)[3]", "clrSpc", "rgb");
+    assertXPathContent(pXmlDocContent, "(//p:animClr)[3]//p:attrName", "fillcolor");
+    assertXPath(pXmlDocContent, "(//p:animClr)[3]//p:to/a:srgbClr", "val", "fcd3c1");
+
+    assertXPath(pXmlDocContent, "(//p:animClr)[5]", "clrSpc", "hsl");
+    assertXPathContent(pXmlDocContent, "(//p:animClr)[5]//p:attrName", "fillcolor");
+    assertXPath(pXmlDocContent, "(//p:animClr)[5]//p:by/p:hsl", "h", "10800000");
+    assertXPath(pXmlDocContent, "(//p:animClr)[5]//p:by/p:hsl", "s", "0");
+    assertXPath(pXmlDocContent, "(//p:animClr)[5]//p:by/p:hsl", "l", "0");
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf118768()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf118768-brake.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent, "//p:anim[1]", "from", "(-#ppt_w/2)");
+    assertXPath(pXmlDocContent, "//p:anim[1]", "to", "(#ppt_x)");
+    assertXPath(pXmlDocContent, "//p:anim[2]", "from", "0");
+
+    assertXPath(pXmlDocContent, "//p:anim[2]", "to", "-1");
+    assertXPath(pXmlDocContent, "//p:anim[2]/p:cBhvr/p:cTn", "autoRev", "1");
+
+    assertXPath(pXmlDocContent, "//p:anim[3]", "by", "(#ppt_h/3+#ppt_w*0.1)");
+    assertXPath(pXmlDocContent, "//p:anim[3]/p:cBhvr/p:cTn", "autoRev", "1");
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf118836()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf118836.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent, "//p:animScale/p:by", "x", "250000");
+    assertXPath(pXmlDocContent, "//p:animScale/p:by", "y", "250000");
+    xDocShRef->DoClose();
+}
+
+static double getAdjustmentValue(const uno::Reference<beans::XPropertySet>& xSet)
+{
+    auto aGeomPropSeq
+        = xSet->getPropertyValue("CustomShapeGeometry").get<uno::Sequence<beans::PropertyValue>>();
+    auto aGeomPropVec
+        = comphelper::sequenceToContainer<std::vector<beans::PropertyValue>>(aGeomPropSeq);
+
+    auto aIterator = std::find_if(
+        aGeomPropVec.begin(), aGeomPropVec.end(),
+        [](const beans::PropertyValue& rValue) { return rValue.Name == "AdjustmentValues"; });
+
+    if (aIterator != aGeomPropVec.end())
+    {
+        uno::Sequence<drawing::EnhancedCustomShapeAdjustmentValue> aAdjustment;
+        double fResult = 0.0;
+        aIterator->Value >>= aAdjustment;
+        aAdjustment[0].Value >>= fResult;
+        return fResult;
+    }
+
+    return -1.0;
+}
+
+static bool getScaleXValue(const uno::Reference<beans::XPropertySet>& xSet)
+{
+    bool bScaleX = false;
+
+    auto aGeomPropSeq
+        = xSet->getPropertyValue("CustomShapeGeometry").get<uno::Sequence<beans::PropertyValue>>();
+    auto aGeomPropVec
+        = comphelper::sequenceToContainer<std::vector<beans::PropertyValue>>(aGeomPropSeq);
+
+    auto aIterator = std::find_if(
+        aGeomPropVec.begin(), aGeomPropVec.end(),
+        [](const beans::PropertyValue& rValue) { return rValue.Name == "TextPath"; });
+
+    if (aIterator != aGeomPropVec.end())
+    {
+        uno::Sequence<beans::PropertyValue> aTextPathProperties;
+        aIterator->Value >>= aTextPathProperties;
+        auto aIterator2 = std::find_if(
+            std::cbegin(aTextPathProperties), std::cend(aTextPathProperties),
+            [](const beans::PropertyValue& rValue) { return rValue.Name == "ScaleX"; });
+
+        if (aIterator2 != std::cend(aTextPathProperties))
+        {
+            aIterator2->Value >>= bScaleX;
+        }
+    }
+
+    return bScaleX;
+}
+
+void SdOOXMLExportTest3::testTdf116350TextEffects()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf116350-texteffects.pptx"), PPTX);
+
+    // Default angle for ArchUp
+    uno::Reference<beans::XPropertySet> xShape0(getShapeFromPage(0, 0, xDocShRef));
+    double fAdjust = getAdjustmentValue(xShape0);
+    CPPUNIT_ASSERT_EQUAL(180.0, fAdjust);
+
+    bool bScaleX = getScaleXValue(xShape0);
+    CPPUNIT_ASSERT_EQUAL(true, bScaleX);
+
+    // Default angle for ArchDown
+    uno::Reference<beans::XPropertySet> xShape14(getShapeFromPage(14, 0, xDocShRef));
+    fAdjust = getAdjustmentValue(xShape14);
+    CPPUNIT_ASSERT_EQUAL(0.0, fAdjust);
+
+    bScaleX = getScaleXValue(xShape14);
+    CPPUNIT_ASSERT_EQUAL(true, bScaleX);
+
+    // Angle directly set
+    uno::Reference<beans::XPropertySet> xShape1(getShapeFromPage(1, 0, xDocShRef));
+    fAdjust = getAdjustmentValue(xShape1);
+    CPPUNIT_ASSERT_EQUAL(213.25, fAdjust);
+
+    bScaleX = getScaleXValue(xShape1);
+    CPPUNIT_ASSERT_EQUAL(true, bScaleX);
+
+    // Export
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent, "//p:sp[1]/p:txBody/a:bodyPr/a:prstTxWarp", "prst", "textArchUp");
+    assertXPath(pXmlDocContent, "//p:sp[14]/p:txBody/a:bodyPr/a:prstTxWarp", "prst", "textCircle");
+    assertXPath(pXmlDocContent, "//p:sp[14]/p:spPr/a:solidFill/a:srgbClr", 0);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf128096()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf128096.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocContent1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent1,
+                "//p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:r/a:rPr/a:highlight/a:srgbClr", "val",
+                "ffff00");
+
+    // Check that underlined content is also highlighted
+    xmlDocUniquePtr pXmlDocContent2 = parseExport(tempFile, "ppt/slides/slide2.xml");
+    assertXPath(pXmlDocContent2,
+                "//p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:r/a:rPr/a:highlight/a:srgbClr", "val",
+                "ffff00");
+}
+void SdOOXMLExportTest3::testTdf120573()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf120573.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDoc = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDoc, "//p:sld/p:cSld/p:spTree/p:pic/p:nvPicPr/p:nvPr/a:audioFile", 1);
+    assertXPath(pXmlDoc, "//p:sld/p:cSld/p:spTree/p:pic/p:nvPicPr/p:nvPr/a:videoFile", 0);
+
+    xmlDocUniquePtr pXmlDocRels = parseExport(tempFile, "ppt/slides/_rels/slide1.xml.rels");
+    assertXPath(pXmlDocRels,
+                "(/rels:Relationships/rels:Relationship[@Target='../media/media1.wav'])[1]", "Type",
+                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio");
+
+    xmlDocUniquePtr pXmlContentType = parseExport(tempFile, "[Content_Types].xml");
+    assertXPath(pXmlContentType,
+                "/ContentType:Types/ContentType:Override[@PartName='/ppt/media/media1.wav']",
+                "ContentType", "audio/x-wav");
+}
+
+void SdOOXMLExportTest3::testTdf119118()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf119118.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent, "//p:iterate", "type", "lt");
+    assertXPath(pXmlDocContent, "//p:tmAbs", "val", "200");
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf99213()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf99213-target-missing.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    // Number of nodes with p:attrNameLst was 3, including one that missed tgtEl
+    assertXPath(pXmlDocContent, "//p:attrNameLst", 2);
+    // Timenode that miss its target element should be filtered.
+    assertXPath(pXmlDocContent, "//p:attrNameLst/preceding-sibling::p:tgtEl", 2);
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testPotxExport()
+{
+    // Create new document
+    sd::DrawDocShellRef xDocShRef
+        = new sd::DrawDocShell(SfxObjectCreateMode::EMBEDDED, false, DocumentType::Draw);
+    uno::Reference<frame::XLoadable> xLoadable(xDocShRef->GetModel(), uno::UNO_QUERY);
+    CPPUNIT_ASSERT(xLoadable.is());
+    xLoadable->initNew();
+
+    // Export as a POTM template
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), POTX, &tempFile);
+    xDocShRef->DoClose();
+
+    // Load and check content type
+    xmlDocUniquePtr pContentTypes = parseExport(tempFile, "[Content_Types].xml");
+    CPPUNIT_ASSERT(pContentTypes);
+    assertXPath(pContentTypes,
+                "/ContentType:Types/ContentType:Override[@PartName='/ppt/presentation.xml']",
+                "ContentType",
+                "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml");
+}
+
+void SdOOXMLExportTest3::testTdf44223()
+{
+    utl::TempFile tempFile;
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf44223.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    std::unique_ptr<SvStream> const pStream1(parseExportStream(tempFile, "ppt/media/audio1.wav"));
+    CPPUNIT_ASSERT_EQUAL(sal_uInt64(11140), pStream1->remainingSize());
+
+    std::unique_ptr<SvStream> const pStream2(parseExportStream(tempFile, "ppt/media/audio2.wav"));
+    CPPUNIT_ASSERT_EQUAL(sal_uInt64(28074), pStream2->remainingSize());
+
+    xmlDocUniquePtr pXmlContentType = parseExport(tempFile, "[Content_Types].xml");
+    assertXPath(pXmlContentType,
+                "/ContentType:Types/ContentType:Override[@PartName='/ppt/media/audio1.wav']",
+                "ContentType", "audio/x-wav");
+
+    assertXPath(pXmlContentType,
+                "/ContentType:Types/ContentType:Override[@PartName='/ppt/media/audio2.wav']",
+                "ContentType", "audio/x-wav");
+
+    xmlDocUniquePtr pDoc1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+
+    // Start condition: 0s after timenode id 5 begins.
+    assertXPath(pDoc1, "//p:audio/p:cMediaNode/p:cTn/p:stCondLst/p:cond", "evt", "begin");
+    assertXPath(pDoc1, "//p:audio/p:cMediaNode/p:cTn/p:stCondLst/p:cond", "delay", "0");
+    assertXPath(pDoc1, "//p:audio/p:cMediaNode/p:cTn/p:stCondLst/p:cond/p:tn", "val", "5");
+
+    xmlDocUniquePtr pDoc2 = parseExport(tempFile, "ppt/slides/slide2.xml");
+    assertXPath(pDoc2, "//p:transition/p:sndAc/p:stSnd/p:snd[@r:embed]", 2);
+
+    xmlDocUniquePtr pRels1 = parseExport(tempFile, "ppt/slides/_rels/slide1.xml.rels");
+    assertXPath(pRels1, "//rels:Relationship[@Id='rId1']", "Type",
+                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio");
+    assertXPath(pRels1, "//rels:Relationship[@Id='rId1']", "Target", "../media/audio1.wav");
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf135843()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf135843_export.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDoc = parseExport(tempFile, "ppt/slides/slide1.xml");
+    const OString sPathStart("/p:sld/p:cSld/p:spTree/p:graphicFrame/a:graphic/a:graphicData/a:tbl");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[1]/a:tc[1]/a:tcPr/a:lnL/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[1]/a:tc[1]/a:tcPr/a:lnR/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[1]/a:tc[1]/a:tcPr/a:lnT/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[1]/a:tc[1]/a:tcPr/a:lnB/a:noFill");
+
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[2]/a:tc[1]/a:tcPr/a:lnL/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[2]/a:tc[1]/a:tcPr/a:lnR/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[2]/a:tc[1]/a:tcPr/a:lnT/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[2]/a:tc[1]/a:tcPr/a:lnB/a:noFill");
+
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[3]/a:tc[1]/a:tcPr/a:lnL/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[3]/a:tc[1]/a:tcPr/a:lnR/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[3]/a:tc[1]/a:tcPr/a:lnT/a:noFill");
+    assertXPath(pXmlDoc, sPathStart + "/a:tr[3]/a:tc[1]/a:tcPr/a:lnB/a:noFill");
+}
+
+void SdOOXMLExportTest3::testSmartArtPreserve()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/smartart-preserve.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDoc = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDoc, "//p:sld/p:cSld/p:spTree/p:graphicFrame/p:nvGraphicFramePr/p:cNvPr");
+    assertXPath(pXmlDoc,
+                "//p:sld/p:cSld/p:spTree/p:graphicFrame/a:graphic/a:graphicData/dgm:relIds");
+    assertXPath(pXmlDoc,
+                "//p:sld/p:cSld/p:spTree/p:graphicFrame/p:nvGraphicFramePr/p:nvPr/p:extLst/p:ext",
+                "uri", "{D42A27DB-BD31-4B8C-83A1-F6EECF244321}");
+    assertXPath(pXmlDoc, "//p:sld/p:cSld/p:spTree/p:graphicFrame/p:nvGraphicFramePr/p:nvPr/"
+                         "p:extLst/p:ext/p14:modId");
+
+    xmlDocUniquePtr pXmlDocRels = parseExport(tempFile, "ppt/slides/_rels/slide1.xml.rels");
+    assertXPath(
+        pXmlDocRels,
+        "(/rels:Relationships/rels:Relationship[@Target='../diagrams/layout1.xml'])[1]", "Type",
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramLayout");
+    assertXPath(
+        pXmlDocRels, "(/rels:Relationships/rels:Relationship[@Target='../diagrams/data1.xml'])[1]",
+        "Type", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData");
+    assertXPath(
+        pXmlDocRels,
+        "(/rels:Relationships/rels:Relationship[@Target='../diagrams/colors1.xml'])[1]", "Type",
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramColors");
+    assertXPath(
+        pXmlDocRels,
+        "(/rels:Relationships/rels:Relationship[@Target='../diagrams/quickStyle1.xml'])[1]", "Type",
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramQuickStyle");
+
+    xmlDocUniquePtr pXmlContentType = parseExport(tempFile, "[Content_Types].xml");
+    assertXPath(pXmlContentType,
+                "/ContentType:Types/ContentType:Override[@PartName='/ppt/diagrams/layout1.xml']",
+                "ContentType",
+                "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml");
+    assertXPath(pXmlContentType,
+                "/ContentType:Types/ContentType:Override[@PartName='/ppt/diagrams/data1.xml']",
+                "ContentType",
+                "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml");
+    assertXPath(pXmlContentType,
+                "/ContentType:Types/ContentType:Override[@PartName='/ppt/diagrams/colors1.xml']",
+                "ContentType",
+                "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml");
+    assertXPath(
+        pXmlContentType,
+        "/ContentType:Types/ContentType:Override[@PartName='/ppt/diagrams/quickStyle1.xml']",
+        "ContentType", "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml");
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf125346()
+{
+    // There are two themes in the test document, make sure we use the right theme
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf125346.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    uno::Reference<beans::XPropertySet> xPropSet(xShape, uno::UNO_SET_THROW);
+
+    drawing::FillStyle aFillStyle(drawing::FillStyle_NONE);
+    xPropSet->getPropertyValue("FillStyle") >>= aFillStyle;
+    CPPUNIT_ASSERT_EQUAL(drawing::FillStyle_SOLID, aFillStyle);
+
+    Color nFillColor;
+    xPropSet->getPropertyValue("FillColor") >>= nFillColor;
+    CPPUNIT_ASSERT_EQUAL(Color(0x90C226), nFillColor);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf125346_2()
+{
+    // There are two themes in the test document, make sure we use the right theme
+    // Test more slides with different themes
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf125346_2.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    {
+        uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+        uno::Reference<beans::XPropertySet> xPropSet(xShape, uno::UNO_SET_THROW);
+
+        drawing::FillStyle aFillStyle(drawing::FillStyle_NONE);
+        xPropSet->getPropertyValue("FillStyle") >>= aFillStyle;
+        CPPUNIT_ASSERT_EQUAL(drawing::FillStyle_SOLID, aFillStyle);
+
+        Color nFillColor;
+        xPropSet->getPropertyValue("FillColor") >>= nFillColor;
+        CPPUNIT_ASSERT_EQUAL(Color(0x90C226), nFillColor);
+    }
+
+    {
+        uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 1, xDocShRef));
+        uno::Reference<beans::XPropertySet> xPropSet(xShape, uno::UNO_SET_THROW);
+
+        drawing::FillStyle aFillStyle(drawing::FillStyle_NONE);
+        xPropSet->getPropertyValue("FillStyle") >>= aFillStyle;
+        CPPUNIT_ASSERT_EQUAL(drawing::FillStyle_SOLID, aFillStyle);
+
+        Color nFillColor;
+        xPropSet->getPropertyValue("FillColor") >>= nFillColor;
+        CPPUNIT_ASSERT_EQUAL(Color(0x052F61), nFillColor);
+    }
+
+    {
+        uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 2, xDocShRef));
+        uno::Reference<beans::XPropertySet> xPropSet(xShape, uno::UNO_SET_THROW);
+
+        drawing::FillStyle aFillStyle(drawing::FillStyle_NONE);
+        xPropSet->getPropertyValue("FillStyle") >>= aFillStyle;
+        CPPUNIT_ASSERT_EQUAL(drawing::FillStyle_SOLID, aFillStyle);
+
+        Color nFillColor;
+        xPropSet->getPropertyValue("FillColor") >>= nFillColor;
+        CPPUNIT_ASSERT_EQUAL(Color(0x90C226), nFillColor);
+    }
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf125360()
+{
+    // Check whether the changed fill transparency is exported correctly.
+    // Color is defined by shape style
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf125360.pptx"), PPTX);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+
+    xShape->setPropertyValue("FillTransparence", uno::Any(static_cast<sal_Int32>(23)));
+
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xShape.set(getShapeFromPage(0, 0, xDocShRef));
+
+    sal_Int32 nTransparence = 0;
+    xShape->getPropertyValue("FillTransparence") >>= nTransparence;
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(23), nTransparence);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf125360_1()
+{
+    // Check whether the changed fill transparency is exported correctly.
+    // Color is defined by color scheme
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf125360_1.pptx"), PPTX);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+
+    xShape->setPropertyValue("FillTransparence", uno::Any(static_cast<sal_Int32>(23)));
+
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xShape.set(getShapeFromPage(0, 0, xDocShRef));
+
+    sal_Int32 nTransparence = 0;
+    xShape->getPropertyValue("FillTransparence") >>= nTransparence;
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(23), nTransparence);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf125360_2()
+{
+    // Check whether the changed fill transparency is exported correctly.
+    // Color is defined by color scheme with a transparency
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf125360_2.pptx"), PPTX);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+
+    sal_Int32 nTransparence = 0;
+    xShape->getPropertyValue("FillTransparence") >>= nTransparence;
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(82), nTransparence);
+
+    xShape->setPropertyValue("FillTransparence", uno::Any(static_cast<sal_Int32>(23)));
+
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xShape.set(getShapeFromPage(0, 0, xDocShRef));
+
+    nTransparence = 0;
+    xShape->getPropertyValue("FillTransparence") >>= nTransparence;
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(23), nTransparence);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf125551()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf125551.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    uno::Reference<drawing::XShapes> xGroupShape(getShapeFromPage(0, 0, xDocShRef), uno::UNO_QUERY);
+    uno::Reference<drawing::XShape> xShapeBg(xGroupShape->getByIndex(0), uno::UNO_QUERY);
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1024), xShapeBg->getPosition().X);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(576), xShapeBg->getPosition().Y);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(10815), xShapeBg->getSize().Width);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(8587), xShapeBg->getSize().Height);
+}
+
+void SdOOXMLExportTest3::testTdf136830()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf136830.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    // Without the fix in place, the X position of the shapes would have been 0
+    uno::Reference<drawing::XShapes> xGroupShape(getShapeFromPage(0, 0, xDocShRef), uno::UNO_QUERY);
+
+    uno::Reference<drawing::XShape> xShape1(xGroupShape->getByIndex(0), uno::UNO_QUERY);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(14134), xShape1->getPosition().X);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-5321), xShape1->getPosition().Y);
+
+    uno::Reference<drawing::XShape> xShape2(xGroupShape->getByIndex(1), uno::UNO_QUERY);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(8085), xShape2->getPosition().X);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(8085), xShape2->getPosition().Y);
+
+    uno::Reference<drawing::XShape> xShape3(xGroupShape->getByIndex(2), uno::UNO_QUERY);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(8283), xShape3->getPosition().X);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(4620), xShape3->getPosition().Y);
+}
+
+void SdOOXMLExportTest3::testTdf126234()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf126234.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    // check relative size of the bullet, 400% is a legitimate value for MS Office document
+    // Without a fix, it will fail to set the size correctly
+    const SdrPage* pPage = GetPage(1, xDocShRef);
+    SdrTextObj* pTxtObj = dynamic_cast<SdrTextObj*>(pPage->GetObj(0));
+    CPPUNIT_ASSERT_MESSAGE("no text object", pTxtObj != nullptr);
+    const EditTextObject& aEdit = pTxtObj->GetOutlinerParaObject()->GetTextObject();
+    const SvxNumBulletItem* pNumFmt = aEdit.GetParaAttribs(0).GetItem(EE_PARA_NUMBULLET);
+    CPPUNIT_ASSERT(pNumFmt);
+    CPPUNIT_ASSERT_EQUAL(sal_uInt16(400), pNumFmt->GetNumRule().GetLevel(0).GetBulletRelSize());
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf126741()
+{
+    sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf126741.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    // dash dot dot line style import fix
+    // The original fixed values are replaced with the percent values, because
+    // with fix for tdf#127166 the MS Office preset styles are correctly detected.
+    const SdrPage* pPage = GetPage(1, xDocShRef);
+    SdrObject* const pObj = pPage->GetObj(0);
+    CPPUNIT_ASSERT(pObj);
+
+    const XLineStyleItem& rStyleItem
+        = dynamic_cast<const XLineStyleItem&>(pObj->GetMergedItem(XATTR_LINESTYLE));
+    const XLineDashItem& rDashItem
+        = dynamic_cast<const XLineDashItem&>(pObj->GetMergedItem(XATTR_LINEDASH));
+
+    CPPUNIT_ASSERT_EQUAL(drawing::LineStyle_DASH, rStyleItem.GetValue());
+    CPPUNIT_ASSERT_EQUAL(sal_uInt16(1), rDashItem.GetDashValue().GetDots());
+    CPPUNIT_ASSERT_EQUAL(800.0, rDashItem.GetDashValue().GetDotLen());
+    CPPUNIT_ASSERT_EQUAL(sal_uInt16(2), rDashItem.GetDashValue().GetDashes());
+    CPPUNIT_ASSERT_EQUAL(100.0, rDashItem.GetDashValue().GetDashLen());
+    CPPUNIT_ASSERT_EQUAL(300.0, rDashItem.GetDashValue().GetDistance());
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf127372()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/odp/tdf127372.odp"), ODP);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    awt::Gradient aTransparenceGradient;
+    xShape->getPropertyValue("FillTransparenceGradient") >>= aTransparenceGradient;
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(0x000000), aTransparenceGradient.StartColor);
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(0x000000), aTransparenceGradient.EndColor);
+}
+
+void SdOOXMLExportTest3::testTdf127379()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/odp/tdf127379.odp"), ODP);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    uno::Reference<drawing::XDrawPagesSupplier> xDoc(xDocShRef->GetDoc()->getUnoModel(),
+                                                     uno::UNO_QUERY_THROW);
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xDoc->getDrawPages()->getCount());
+
+    uno::Reference<drawing::XDrawPage> xPage(getPage(0, xDocShRef));
+    uno::Reference<beans::XPropertySet> xPropSet(xPage, uno::UNO_QUERY);
+
+    uno::Any aAny = xPropSet->getPropertyValue("Background");
+    CPPUNIT_ASSERT_MESSAGE("Slide background is missing", aAny.hasValue());
+    uno::Reference<beans::XPropertySet> aXBackgroundPropSet;
+    aAny >>= aXBackgroundPropSet;
+
+    drawing::FillStyle aFillStyle(drawing::FillStyle_NONE);
+    aXBackgroundPropSet->getPropertyValue("FillStyle") >>= aFillStyle;
+    CPPUNIT_ASSERT_EQUAL(drawing::FillStyle_GRADIENT, aFillStyle);
+
+    awt::Gradient aGradient;
+    CPPUNIT_ASSERT(aXBackgroundPropSet->getPropertyValue("FillGradient") >>= aGradient);
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(0xFF0000), aGradient.StartColor);
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(0x2A6099), aGradient.EndColor);
+}
+
+void SdOOXMLExportTest3::testTdf98603()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf98603.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    uno::Reference<text::XTextRange> const xParagraph(getParagraphFromShape(0, xShape));
+    uno::Reference<text::XTextRange> xRun(getRunFromParagraph(0, xParagraph));
+    uno::Reference<beans::XPropertySet> xPropSet(xRun, uno::UNO_QUERY_THROW);
+    css::lang::Locale aLocale;
+    xPropSet->getPropertyValue("CharLocaleComplex") >>= aLocale;
+    CPPUNIT_ASSERT_EQUAL(OUString("he"), aLocale.Language);
+    CPPUNIT_ASSERT_EQUAL(OUString("IL"), aLocale.Country);
+}
+
+void SdOOXMLExportTest3::testTdf128213()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf128213.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPathNoAttribute(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp/p:spPr/a:xfrm", "rot");
+}
+
+void SdOOXMLExportTest3::testTdf79082()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf79082.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[1]", "pos",
+                "360000");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[1]", "algn", "l");
+
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[2]", "pos",
+                "756000");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[2]", "algn", "l");
+
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[3]", "pos",
+                "1440000");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[3]", "algn",
+                "ctr");
+
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[4]", "pos",
+                "1800000");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[4]", "algn", "r");
+
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[5]", "pos",
+                "3240000");
+    assertXPath(pXmlDocContent,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:pPr/a:tabLst/a:tab[5]", "algn",
+                "dec");
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf129372()
+{
+    //Without the fix in place, it would crash at import time
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf129372.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    const SdrPage* pPage = GetPage(1, xDocShRef.get());
+
+    const SdrObject* pObj = pPage->GetObj(0);
+    CPPUNIT_ASSERT_MESSAGE("no object", pObj != nullptr);
+    CPPUNIT_ASSERT_EQUAL(SdrObjKind::OLE2, pObj->GetObjIdentifier());
+}
+
+void SdOOXMLExportTest3::testShapeGlowEffect()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/shape-glow-effect.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    sal_Int32 nRadius = -1;
+    xShape->getPropertyValue("GlowEffectRadius") >>= nRadius;
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(388), nRadius); // 139700 EMU = 388.0556 mm/100
+    Color nColor;
+    xShape->getPropertyValue("GlowEffectColor") >>= nColor;
+    CPPUNIT_ASSERT_EQUAL(Color(0xFFC000), nColor);
+    sal_Int16 nTransparency;
+    xShape->getPropertyValue("GlowEffectTransparency") >>= nTransparency;
+    CPPUNIT_ASSERT_EQUAL(sal_Int16(60), nTransparency);
+}
+
+void SdOOXMLExportTest3::testUnderline()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/underline.fodp"), FODP);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    uno::Reference<text::XTextRange> xParagraph(getParagraphFromShape(0, xShape));
+    uno::Reference<text::XTextRange> xRun(getRunFromParagraph(0, xParagraph));
+    uno::Reference<beans::XPropertySet> xPropSet(xRun, uno::UNO_QUERY_THROW);
+
+    Color nColor;
+    xPropSet->getPropertyValue("CharColor") >>= nColor;
+    CPPUNIT_ASSERT_EQUAL(COL_LIGHTRED, nColor);
+
+    xPropSet->getPropertyValue("CharUnderlineColor") >>= nColor;
+    CPPUNIT_ASSERT_EQUAL(COL_AUTO, nColor);
+
+    sal_Int16 nUnderline;
+    xPropSet->getPropertyValue("CharUnderline") >>= nUnderline;
+    CPPUNIT_ASSERT_EQUAL(awt::FontUnderline::DOUBLE, nUnderline);
+
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+
+    xShape.set(getShapeFromPage(0, 0, xDocShRef));
+    xParagraph.set(getParagraphFromShape(0, xShape));
+    xRun.set(getRunFromParagraph(0, xParagraph));
+    xPropSet.set(xRun, uno::UNO_QUERY_THROW);
+
+    xPropSet->getPropertyValue("CharColor") >>= nColor;
+    CPPUNIT_ASSERT_EQUAL(COL_LIGHTRED, nColor);
+
+    xPropSet->getPropertyValue("CharUnderlineColor") >>= nColor;
+    CPPUNIT_ASSERT_EQUAL(COL_AUTO, nColor);
+
+    xPropSet->getPropertyValue("CharUnderline") >>= nUnderline;
+    CPPUNIT_ASSERT_EQUAL(awt::FontUnderline::DOUBLE, nUnderline);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf119087()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf119087.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    // This would fail both on export validation, and reloading the saved pptx file.
+
+    // Get first paragraph of the text
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    uno::Reference<text::XTextRange> const xParagraph(getParagraphFromShape(0, xShape));
+    // Get first run of the paragraph
+    uno::Reference<text::XTextRange> xRun(getRunFromParagraph(0, xParagraph));
+    uno::Reference<beans::XPropertySet> xPropSet(xRun, uno::UNO_QUERY_THROW);
+
+    Color nColor = COL_AUTO;
+    xPropSet->getPropertyValue("CharColor") >>= nColor;
+    CPPUNIT_ASSERT_EQUAL(Color(0x00B050), nColor);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf131554()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf131554.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    uno::Reference<drawing::XShape> xShape(getShapeFromPage(1, 0, xDocShRef), uno::UNO_QUERY);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(5622), xShape->getPosition().X);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(13251), xShape->getPosition().Y);
+}
+
+void SdOOXMLExportTest3::testTdf132282()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf132282.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    uno::Reference<drawing::XShape> xShape(getShapeFromPage(0, 0, xDocShRef), uno::UNO_QUERY);
+    // Without the fix in place, the position would be 0,0, height = 1 and width = 1
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1736), xShape->getPosition().X);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(763), xShape->getPosition().Y);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(30523), xShape->getSize().Width);
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(2604), xShape->getSize().Height);
+}
+
+void SdOOXMLExportTest3::testTdf132201EffectOrder()
+{
+    auto xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/effectOrder.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xmlDocUniquePtr pXmlDocContent = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPathChildren(pXmlDocContent, "/p:sld/p:cSld/p:spTree/p:sp[3]/p:spPr/a:effectLst", 2);
+    // The relative order of effects is important: glow must be before shadow
+    CPPUNIT_ASSERT_EQUAL(0, getXPathPosition(pXmlDocContent,
+                                             "/p:sld/p:cSld/p:spTree/p:sp[3]/p:spPr/a:effectLst",
+                                             "glow"));
+    CPPUNIT_ASSERT_EQUAL(1, getXPathPosition(pXmlDocContent,
+                                             "/p:sld/p:cSld/p:spTree/p:sp[3]/p:spPr/a:effectLst",
+                                             "outerShdw"));
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testShapeSoftEdgeEffect()
+{
+    auto xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/shape-soft-edges.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    auto xShapeProps(getShapeFromPage(0, 0, xDocShRef));
+    sal_Int32 nRadius = -1;
+    xShapeProps->getPropertyValue("SoftEdgeRadius") >>= nRadius;
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(635), nRadius); // 18 pt
+}
+
+void SdOOXMLExportTest3::testShapeShadowBlurEffect()
+{
+    auto xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/shape-blur-effect.pptx"), PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    bool bHasShadow = false;
+    xShape->getPropertyValue("Shadow") >>= bHasShadow;
+    CPPUNIT_ASSERT(bHasShadow);
+    sal_Int32 nRadius = -1;
+    xShape->getPropertyValue("ShadowBlur") >>= nRadius;
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(388), nRadius); // 11 pt
+}
+
+void SdOOXMLExportTest3::testTdf119223()
+{
+    auto xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf119223.odp"), ODP);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocRels = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocRels, "//p:cNvPr[@name='SomeCustomShape']");
+
+    assertXPath(pXmlDocRels, "//p:cNvPr[@name='SomePicture']");
+
+    assertXPath(pXmlDocRels, "//p:cNvPr[@name='SomeFormula']");
+
+    assertXPath(pXmlDocRels, "//p:cNvPr[@name='SomeLine']");
+
+    assertXPath(pXmlDocRels, "//p:cNvPr[@name='SomeTextbox']");
+
+    assertXPath(pXmlDocRels, "//p:cNvPr[@name='SomeTable']");
+
+    assertXPath(pXmlDocRels, "//p:cNvPr[@name='SomeGroup']");
+}
+
+void SdOOXMLExportTest3::testTdf128213ShapeRot()
+{
+    auto xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf128213-shaperot.pptx"), PPTX);
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocRels = parseExport(tempFile, "ppt/slides/slide1.xml");
+
+    assertXPath(pXmlDocRels, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:bodyPr/a:scene3d");
+    assertXPath(pXmlDocRels,
+                "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:bodyPr/a:scene3d/a:camera/a:rot", "rev",
+                "5400000");
+}
+
+void SdOOXMLExportTest3::testTdf125560_textDeflate()
+{
+    auto xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/ShapePlusImage.pptx"), PPTX);
+    utl::TempFile tempFile;
+
+    // This problem did not affect the pptx export, only the ODP so assert that
+    xDocShRef = saveAndReload(xDocShRef.get(), ODP, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocRels = parseExport(tempFile, "content.xml");
+    assertXPath(pXmlDocRels,
+                "/office:document-content/office:body/office:presentation/draw:page/"
+                "draw:custom-shape/draw:enhanced-geometry",
+                "type", "mso-spt161");
+}
+
+void SdOOXMLExportTest3::testTdf125560_textInflateTop()
+{
+    auto xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/ShapeTextInflateTop.pptx"), PPTX);
+    utl::TempFile tempFile;
+
+    // This problem did not affect the pptx export, only the ODP so assert that
+    xDocShRef = saveAndReload(xDocShRef.get(), ODP, &tempFile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXmlDocRels = parseExport(tempFile, "content.xml");
+    assertXPath(pXmlDocRels,
+                "/office:document-content/office:body/office:presentation/draw:page/"
+                "draw:custom-shape/draw:enhanced-geometry",
+                "type", "mso-spt164");
+}
+
+void SdOOXMLExportTest3::testTdf142235_TestPlaceholderTextAlignment()
+{
+    auto xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/placeholder-box-textalignment.odp"), ODP);
+
+    utl::TempFile tmpfile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tmpfile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXml1 = parseExport(tmpfile, "ppt/slides/slide2.xml");
+    xmlDocUniquePtr pXml2 = parseExport(tmpfile, "ppt/slides/slide3.xml");
+
+    // Without the fix in place many of these asserts failed, because alignment was bad.
+
+    assertXPath(pXml1, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:bodyPr", "anchor", "t");
+    assertXPath(pXml2, "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:bodyPr", "anchor", "t");
+}
+
+void SdOOXMLExportTest3::testTdf96061_textHighlight()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf96061.pptx"), PPTX);
+
+    uno::Reference<beans::XPropertySet> xShape(getShapeFromPage(0, 0, xDocShRef));
+    uno::Reference<text::XTextRange> const xParagraph1(getParagraphFromShape(0, xShape));
+    uno::Reference<text::XTextRange> xRun1(getRunFromParagraph(0, xParagraph1));
+    uno::Reference<beans::XPropertySet> xPropSet1(xRun1, uno::UNO_QUERY_THROW);
+
+    Color aColor;
+    xPropSet1->getPropertyValue("CharBackColor") >>= aColor;
+    CPPUNIT_ASSERT_EQUAL(COL_YELLOW, aColor);
+
+    uno::Reference<text::XTextRange> const xParagraph2(getParagraphFromShape(1, xShape));
+    uno::Reference<text::XTextRange> xRun2(getRunFromParagraph(0, xParagraph2));
+    uno::Reference<beans::XPropertySet> xPropSet2(xRun2, uno::UNO_QUERY_THROW);
+    xPropSet2->getPropertyValue("CharBackColor") >>= aColor;
+    CPPUNIT_ASSERT_EQUAL(COL_AUTO, aColor);
+
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+
+    uno::Reference<beans::XPropertySet> xShape2(getShapeFromPage(0, 0, xDocShRef));
+    uno::Reference<text::XTextRange> const xParagraph3(getParagraphFromShape(0, xShape2));
+    uno::Reference<text::XTextRange> xRun3(getRunFromParagraph(0, xParagraph3));
+    uno::Reference<beans::XPropertySet> xPropSet3(xRun3, uno::UNO_QUERY_THROW);
+    xPropSet3->getPropertyValue("CharBackColor") >>= aColor;
+    CPPUNIT_ASSERT_EQUAL(COL_YELLOW, aColor);
+
+    uno::Reference<text::XTextRange> const xParagraph4(getParagraphFromShape(1, xShape2));
+    uno::Reference<text::XTextRange> xRun4(getRunFromParagraph(0, xParagraph4));
+    uno::Reference<beans::XPropertySet> xPropSet4(xRun4, uno::UNO_QUERY_THROW);
+    xPropSet4->getPropertyValue("CharBackColor") >>= aColor;
+    CPPUNIT_ASSERT_EQUAL(COL_AUTO, aColor);
+}
+
+void SdOOXMLExportTest3::testTdf143222_embeddedWorksheet()
+{
+    // Check import of embedded worksheet in slide.
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf143222.pptx"), PPTX);
+
+    const SdrPage* pPage = GetPage(1, xDocShRef.get());
+    const SdrOle2Obj* pOleObj = static_cast<SdrOle2Obj*>(pPage->GetObj(0));
+    CPPUNIT_ASSERT_MESSAGE("no object", pOleObj != nullptr);
+
+    // Without the fix we lost the graphic of ole object.
+    const Graphic* pGraphic = pOleObj->GetGraphic();
+    CPPUNIT_ASSERT_MESSAGE("no graphic", pGraphic != nullptr);
+
+    // Check export of embedded worksheet in slide.
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+
+    pPage = GetPage(1, xDocShRef.get());
+    pOleObj = static_cast<SdrOle2Obj*>(pPage->GetObj(0));
+    CPPUNIT_ASSERT_MESSAGE("no object after the export", pOleObj != nullptr);
+
+    pGraphic = pOleObj->GetGraphic();
+    CPPUNIT_ASSERT_MESSAGE("no graphic after the export", pGraphic != nullptr);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf143315()
+{
+    auto xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/ppt/tdf143315-WordartWithoutBullet.ppt"),
+        PPT);
+
+    utl::TempFile tmpfile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tmpfile);
+    xDocShRef->DoClose();
+
+    xmlDocUniquePtr pXml = parseExport(tmpfile, "ppt/slides/slide1.xml");
+
+    // Without the fix in place, this would have failed with
+    // - Expected:
+    // - Actual  : 216000
+    // - In <file:///tmp/lu161922zcvd.tmp>, XPath '/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:pPr' unexpected 'marL' attribute
+
+    assertXPathNoAttribute(pXml, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:pPr", "marL");
+    assertXPathNoAttribute(pXml, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:pPr", "indent");
+    assertXPath(pXml, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:pPr/a:buClr", 0);
+    assertXPath(pXml, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:pPr/a:buSzPct", 0);
+    assertXPath(pXml, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:pPr/a:buFont", 0);
+    assertXPath(pXml, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:pPr/a:buChar", 0);
+}
+
+void SdOOXMLExportTest3::testTdf147121()
+{
+    // Get the bugdoc
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdf147121.pptx"), PPTX);
+
+    CPPUNIT_ASSERT(xDocShRef);
+    // Get the second line props of the placeholder
+    uno::Reference<drawing::XDrawPage> xPage(getPage(0, xDocShRef));
+    uno::Reference<beans::XPropertySet> xShape(xPage->getByIndex(0), uno::UNO_QUERY_THROW);
+    uno::Reference<beans::XPropertySet> xRun(
+        getRunFromParagraph(2, getParagraphFromShape(0, xShape)), uno::UNO_QUERY_THROW);
+
+    // Save the font size
+    const auto nFontSizeBefore = xRun->getPropertyValue("CharHeight").get<float>() * 100;
+
+    // Save and reload
+    utl::TempFile tmpfile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tmpfile);
+    xDocShRef->DoClose();
+
+    // Parse the export
+    xmlDocUniquePtr pXml = parseExport(tmpfile, "ppt/slides/slide1.xml");
+    const auto nFontSizeAfter
+        = getXPath(pXml, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:br[1]/a:rPr", "sz").toFloat();
+
+    // The font size was not saved before now it must be equal with the saved one.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected font size", nFontSizeBefore, nFontSizeAfter);
+}
+
+void SdOOXMLExportTest3::testTdf140912_PicturePlaceholder()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/tdfpictureplaceholder.pptx"), PPTX);
+
+    uno::Reference<beans::XPropertySet> xShapeProps(getShapeFromPage(0, 0, xDocShRef));
+    bool bTextContourFrame = true;
+    xShapeProps->getPropertyValue("TextContourFrame") >>= bTextContourFrame;
+    CPPUNIT_ASSERT_EQUAL(false, bTextContourFrame);
+
+    text::GraphicCrop aGraphicCrop;
+    xShapeProps->getPropertyValue("GraphicCrop") >>= aGraphicCrop;
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-8490), aGraphicCrop.Top);
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testEnhancedPathViewBox()
+{
+    auto xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf147978_enhancedPath_viewBox.odp"),
+        ODP);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+    auto xShapeProps(getShapeFromPage(0, 0, xDocShRef));
+    awt::Rectangle aBoundRectangle;
+    xShapeProps->getPropertyValue("BoundRect") >>= aBoundRectangle;
+    // The shape has a Bézier curve which does not touch the right edge. Prior to the fix the curve
+    // was stretched to touch the edge, resulting in 5098 curve width instead of 2045.
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(2045), aBoundRectangle.Width);
+}
+
+void SdOOXMLExportTest3::testTdf74670()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/odp/tdf74670.odp"), ODP);
+    utl::TempFile tmpfile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tmpfile);
+    xDocShRef->DoClose();
+
+    uno::Reference<packages::zip::XZipFileAccess2> xNameAccess
+        = packages::zip::ZipFileAccess::createWithURL(comphelper::getComponentContext(m_xSFactory),
+                                                      tmpfile.GetURL());
+    const uno::Sequence<OUString> aNames(xNameAccess->getElementNames());
+    int nImageFiles = 0;
+    for (const auto& rElementName : aNames)
+        if (rElementName.startsWith("ppt/media/image"))
+            nImageFiles++;
+
+    // Without the accompanying fix in place, this test would have failed with:
+    // - Expected: 1
+    // - Actual  : 2
+    // i.e. the embedded picture would have been saved twice.
+    CPPUNIT_ASSERT_EQUAL(1, nImageFiles);
+}
+
+void SdOOXMLExportTest3::testTdf109169_OctagonBevel()
+{
+    // The document has a shape 'Octagon Bevel'. It consists of an octagon with 8 points and eight
+    // facets with 4 points each, total 8+8*4=40 points. Without the patch it was exported as
+    // rectangle and thus had 4 points.
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf109169_Octagon.odp"), ODP);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+
+    auto xPropSet(getShapeFromPage(0, 0, xDocShRef));
+    auto aGeomPropSeq = xPropSet->getPropertyValue("CustomShapeGeometry")
+                            .get<uno::Sequence<beans::PropertyValue>>();
+    comphelper::SequenceAsHashMap aCustomShapeGeometry(aGeomPropSeq);
+    auto aPathSeq((aCustomShapeGeometry["Path"]).get<uno::Sequence<beans::PropertyValue>>());
+    comphelper::SequenceAsHashMap aPath(aPathSeq);
+    auto aCoordinates(
+        (aPath["Coordinates"]).get<uno::Sequence<drawing::EnhancedCustomShapeParameterPair>>());
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(40), aCoordinates.getLength());
+}
+
+void SdOOXMLExportTest3::testTdf109169_DiamondBevel()
+{
+    // The document has a shape 'Diamond Bevel'. It consists of a diamond with 4 points and four
+    // facets with 4 points each, total 4+4*4=20 points. Without the patch it was exported as
+    // rectangle and thus had 4 points.
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf109169_Diamond.odp"), ODP);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+
+    auto xPropSet(getShapeFromPage(0, 0, xDocShRef));
+    auto aGeomPropSeq = xPropSet->getPropertyValue("CustomShapeGeometry")
+                            .get<uno::Sequence<beans::PropertyValue>>();
+    comphelper::SequenceAsHashMap aCustomShapeGeometry(aGeomPropSeq);
+    auto aPathSeq((aCustomShapeGeometry["Path"]).get<uno::Sequence<beans::PropertyValue>>());
+    comphelper::SequenceAsHashMap aPath(aPathSeq);
+    auto aCoordinates(
+        (aPath["Coordinates"]).get<uno::Sequence<drawing::EnhancedCustomShapeParameterPair>>());
+    CPPUNIT_ASSERT_EQUAL(sal_Int32(20), aCoordinates.getLength());
+}
+
+void SdOOXMLExportTest3::testTdf144092_emptyShapeTextProps()
+{
+    // Document contains one shape and one table. Both without any text but with
+    // text properties contained inside endParaRPr - The import and export
+    // of endParaRPr for empty cells and shapes are tested here
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"sd/qa/unit/data/pptx/tdf144092-emptyShapeTextProps.pptx"),
+        PPTX);
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+
+    Color aColor;
+    // check text properties of empty shape
+    uno::Reference<beans::XPropertySet> xRectShapeProps(getShapeFromPage(1, 0, xDocShRef));
+    CPPUNIT_ASSERT_EQUAL(OUString("Calibri"),
+                         xRectShapeProps->getPropertyValue("CharFontName").get<OUString>());
+    CPPUNIT_ASSERT_EQUAL(float(196), xRectShapeProps->getPropertyValue("CharHeight").get<float>());
+    xRectShapeProps->getPropertyValue("CharColor") >>= aColor;
+    CPPUNIT_ASSERT_EQUAL(Color(0x70AD47), aColor);
+
+    const SdrPage* pPage = GetPage(1, xDocShRef);
+    sdr::table::SdrTableObj* pTableObj = dynamic_cast<sdr::table::SdrTableObj*>(pPage->GetObj(0));
+    CPPUNIT_ASSERT(pTableObj);
+    uno::Reference<table::XCellRange> xTable(pTableObj->getTable(), uno::UNO_QUERY_THROW);
+    uno::Reference<beans::XPropertySet> xCell;
+
+    // check text properties of empty cells
+    xCell.set(xTable->getCellByPosition(0, 0), uno::UNO_QUERY_THROW);
+    xCell->getPropertyValue("CharColor") >>= aColor;
+    CPPUNIT_ASSERT_EQUAL(Color(0xFFFFFF), aColor);
+
+    xCell.set(xTable->getCellByPosition(0, 1), uno::UNO_QUERY_THROW);
+    xCell->getPropertyValue("CharColor") >>= aColor;
+    CPPUNIT_ASSERT_EQUAL(Color(0x70AD47), aColor);
+    CPPUNIT_ASSERT_EQUAL(float(96), xCell->getPropertyValue("CharHeight").get<float>());
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testTdf94122_autoColor()
+{
+    // Document contains three pages, with different scenarios for automatic
+    // color export to pptx.
+    // - First page: Page background light, automatic colored text on a FillType_NONE shape
+    // - Second page: Page background dark, automatic colored text on a FillType_NONE shape
+    // - Third page: Page background light, automatic colored text on a dark colored fill
+    //   and another automatic colored text on a light colored fill
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"sd/qa/unit/data/odp/tdf94122_autocolor.odp"), ODP);
+
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    // Without the accompanying fix in place, these tests would have failed with:
+    // - Expected: 1
+    // - Actual  : 0
+    // - In ..., XPath '/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:r/a:rPr/a:solidFill/a:srgbClr' number of nodes is incorrect
+    // i.e. automatic color wasn't resolved & exported
+
+    xmlDocUniquePtr pXmlDocContent1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent1,
+                "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:r/a:rPr/a:solidFill/a:srgbClr", "val",
+                "000000");
+
+    xmlDocUniquePtr pXmlDocContent2 = parseExport(tempFile, "ppt/slides/slide2.xml");
+    assertXPath(pXmlDocContent2,
+                "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p/a:r/a:rPr/a:solidFill/a:srgbClr", "val",
+                "ffffff");
+
+    xmlDocUniquePtr pXmlDocContent3 = parseExport(tempFile, "ppt/slides/slide3.xml");
+    assertXPath(pXmlDocContent3,
+                "/p:sld/p:cSld/p:spTree/p:sp[1]/p:txBody/a:p/a:r/a:rPr/a:solidFill/a:srgbClr",
+                "val", "ffffff");
+    assertXPath(pXmlDocContent3,
+                "/p:sld/p:cSld/p:spTree/p:sp[2]/p:txBody/a:p/a:r/a:rPr/a:solidFill/a:srgbClr",
+                "val", "000000");
+}
+
+void SdOOXMLExportTest3::testTdf124333()
+{
+    // Document contains one rectangle and one embedded OLE object.
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/ole.pptx"), PPTX);
+
+    // Without the fix in place, the number of shapes was 3.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("number of shapes is incorrect", sal_Int32(2),
+                                 getPage(0, xDocShRef)->getCount());
+
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+
+    // Check number of shapes after export.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("number of shapes is incorrect after export", sal_Int32(2),
+                                 getPage(0, xDocShRef)->getCount());
+
+    xDocShRef->DoClose();
+}
+
+void SdOOXMLExportTest3::testAutofittedTextboxIndent()
+{
+    ::sd::DrawDocShellRef xDocShRef = loadURL(
+        m_directories.getURLFromSrc(u"/sd/qa/unit/data/odp/autofitted-textbox-indent.odp"), ODP);
+
+    utl::TempFile tempFile;
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX, &tempFile);
+    xDocShRef->DoClose();
+
+    // Without the accompanying fix in place, these tests would have failed with:
+    // - Expected: 691200
+    // - Actual  : 1080000
+    // i.e. paragraph indent wasn't scaled proportionally to autofitted textbox
+    // font scale on export
+
+    xmlDocUniquePtr pXmlDocContent1 = parseExport(tempFile, "ppt/slides/slide1.xml");
+    assertXPath(pXmlDocContent1, "/p:sld/p:cSld/p:spTree/p:sp/p:txBody/a:p[1]/a:pPr", "marL",
+                "691200");
+}
+
+void SdOOXMLExportTest3::testTdf152436()
+{
+    ::sd::DrawDocShellRef xDocShRef
+        = loadURL(m_directories.getURLFromSrc(u"/sd/qa/unit/data/pptx/ole-emf_min.pptx"), PPTX);
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("number of shapes is incorrect", sal_Int32(1),
+                                 getPage(0, xDocShRef)->getCount());
+
+    xDocShRef = saveAndReload(xDocShRef.get(), PPTX);
+
+    // Check number of shapes after export.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("number of shapes is incorrect after export", sal_Int32(1),
+                                 getPage(0, xDocShRef)->getCount());
+
+    xDocShRef->DoClose();
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SdOOXMLExportTest3);
+
+CPPUNIT_PLUGIN_IMPLEMENT();
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */