diff options
Diffstat (limited to 'writerperfect/qa/unit/EPUBExportTest.cxx')
| -rw-r--r-- | writerperfect/qa/unit/EPUBExportTest.cxx | 880 |
1 files changed, 880 insertions, 0 deletions
diff --git a/writerperfect/qa/unit/EPUBExportTest.cxx b/writerperfect/qa/unit/EPUBExportTest.cxx new file mode 100644 index 000000000..e6ca36fed --- /dev/null +++ b/writerperfect/qa/unit/EPUBExportTest.cxx @@ -0,0 +1,880 @@ +/* -*- 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 <libepubgen/libepubgen.h> + +#include <com/sun/star/document/XFilter.hpp> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/frame/XStorable.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/packages/zip/ZipFileAccess.hpp> + +#include <comphelper/propertysequence.hxx> +#include <comphelper/string.hxx> +#include <o3tl/safeint.hxx> +#include <test/bootstrapfixture.hxx> +#include <test/xmltesttools.hxx> +#include <unotest/macros_test.hxx> +#include <unotools/docinfohelper.hxx> +#include <unotools/mediadescriptor.hxx> +#include <unotools/tempfile.hxx> +#include <unotools/ucbstreamhelper.hxx> + +using namespace ::com::sun::star; + +namespace +{ +char const DATA_DIRECTORY[] = "/writerperfect/qa/unit/data/writer/epubexport/"; + +/// Tests the EPUB export filter. +class EPUBExportTest : public test::BootstrapFixture, + public unotest::MacrosTest, + public XmlTestTools +{ +protected: + uno::Reference<lang::XComponent> mxComponent; + utl::TempFile maTempFile; + xmlDocUniquePtr mpXmlDoc; + uno::Reference<packages::zip::XZipFileAccess2> mxZipFile; + OUString maFilterOptions; + +public: + void setUp() override; + void tearDown() override; + void registerNamespaces(xmlXPathContextPtr& pXmlXpathCtx) override; + void createDoc(const OUString& rFile, const uno::Sequence<beans::PropertyValue>& rFilterData); + /// Returns an XML representation of the stream named rName in the exported package. + xmlDocUniquePtr parseExport(const OUString& rName); + /// Parses a CSS representation of the stream named rName and returns it. + std::map<OUString, std::vector<OUString>> parseCss(const OUString& rName); + /// Looks up a key of a class in rCss. + static OUString getCss(std::map<OUString, std::vector<OUString>>& rCss, const OUString& rClass, + const OUString& rKey); +}; + +void EPUBExportTest::setUp() +{ + test::BootstrapFixture::setUp(); + + mxDesktop.set(frame::Desktop::create(mxComponentContext)); +} + +void EPUBExportTest::tearDown() +{ + if (mxComponent.is()) + mxComponent->dispose(); + + mpXmlDoc.reset(); + + test::BootstrapFixture::tearDown(); +} + +void EPUBExportTest::registerNamespaces(xmlXPathContextPtr& pXmlXpathCtx) +{ + xmlXPathRegisterNs(pXmlXpathCtx, BAD_CAST("dc"), BAD_CAST("http://purl.org/dc/elements/1.1/")); + xmlXPathRegisterNs(pXmlXpathCtx, BAD_CAST("opf"), BAD_CAST("http://www.idpf.org/2007/opf")); + xmlXPathRegisterNs(pXmlXpathCtx, BAD_CAST("xhtml"), BAD_CAST("http://www.w3.org/1999/xhtml")); + xmlXPathRegisterNs(pXmlXpathCtx, BAD_CAST("svg"), BAD_CAST("http://www.w3.org/2000/svg")); +} + +void EPUBExportTest::createDoc(const OUString& rFile, + const uno::Sequence<beans::PropertyValue>& rFilterData) +{ + // Import the bugdoc and export as EPUB. + OUString aURL = m_directories.getURLFromSrc(DATA_DIRECTORY) + rFile; + mxComponent = loadFromDesktop(aURL); + CPPUNIT_ASSERT(mxComponent.is()); + + uno::Reference<frame::XStorable> xStorable(mxComponent, uno::UNO_QUERY); + maTempFile.EnableKillingFile(); + utl::MediaDescriptor aMediaDescriptor; + aMediaDescriptor["FilterName"] <<= OUString("EPUB"); + if (maFilterOptions.isEmpty()) + aMediaDescriptor["FilterData"] <<= rFilterData; + else + aMediaDescriptor["FilterOptions"] <<= maFilterOptions; + xStorable->storeToURL(maTempFile.GetURL(), aMediaDescriptor.getAsConstPropertyValueList()); + mxZipFile + = packages::zip::ZipFileAccess::createWithURL(mxComponentContext, maTempFile.GetURL()); +} + +xmlDocUniquePtr EPUBExportTest::parseExport(const OUString& rName) +{ + uno::Reference<io::XInputStream> xInputStream(mxZipFile->getByName(rName), uno::UNO_QUERY); + std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(xInputStream, true)); + return parseXmlStream(pStream.get()); +} + +std::map<OUString, std::vector<OUString>> EPUBExportTest::parseCss(const OUString& rName) +{ + std::map<OUString, std::vector<OUString>> aRet; + + uno::Reference<io::XInputStream> xInputStream(mxZipFile->getByName(rName), uno::UNO_QUERY); + std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(xInputStream, true)); + + // Minimal CSS handler till orcus is up to our needs. + OString aLine; + OUString aRuleName; + while (!pStream->eof()) + { + pStream->ReadLine(aLine); + if (aLine.endsWith("{")) + // '.name {' -> 'name' + aRuleName = OUString::fromUtf8(aLine.copy(1, aLine.getLength() - 3)); + else if (aLine.endsWith(";")) + aRet[aRuleName].push_back(OUString::fromUtf8(aLine)); + } + + return aRet; +} + +OUString EPUBExportTest::getCss(std::map<OUString, std::vector<OUString>>& rCss, + const OUString& rClass, const OUString& rKey) +{ + OUString aRet; + + auto it = rCss.find(rClass); + CPPUNIT_ASSERT(it != rCss.end()); + + for (const auto& rKeyValue : it->second) + { + OUString aKeyValue = rKeyValue.trim(); + std::vector<OUString> aTokens = comphelper::string::split(aKeyValue, ':'); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), aTokens.size()); + if (aTokens[0].trim() == rKey) + { + aRet = aTokens[1].trim(); + if (aRet.endsWith(";")) + // Ignore trailing semicolon. + aRet = aRet.copy(0, aRet.getLength() - 1); + break; + } + } + + return aRet; +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testOutlineLevel) +{ + createDoc("outline-level.fodt", {}); + + // Make sure that the output is split into two. + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/sections/section0001.xhtml")); + // This failed, output was a single section. + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/sections/section0002.xhtml")); + CPPUNIT_ASSERT(!mxZipFile->hasByName("OEBPS/sections/section0003.xhtml")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testMimetype) +{ + createDoc("hello.fodt", {}); + + // Check that the mime type is written uncompressed at the expected location. + SvFileStream aFileStream(maTempFile.GetURL(), StreamMode::READ); + SvMemoryStream aMemoryStream; + aMemoryStream.WriteStream(aFileStream); + OString aExpected("application/epub+zip"); + CPPUNIT_ASSERT(aMemoryStream.GetSize() > static_cast<sal_uInt64>(aExpected.getLength()) + 38); + + OString aActual(static_cast<const char*>(aMemoryStream.GetData()) + 38, aExpected.getLength()); + // This failed: actual data was some garbage, not the uncompressed mime type. + CPPUNIT_ASSERT_EQUAL(aExpected, aActual); + + mpXmlDoc = parseExport("OEBPS/content.opf"); + // Default is EPUB3. + assertXPath(mpXmlDoc, "/opf:package", "version", "3.0"); + + // This was just "libepubgen/x.y.z", i.e. the LO version was missing. + OUString aGenerator + = getXPath(mpXmlDoc, "/opf:package/opf:metadata/opf:meta[@name='generator']", "content"); + CPPUNIT_ASSERT(aGenerator.startsWith(utl::DocInfoHelper::GetGeneratorString())); + + uno::Reference<lang::XMultiServiceFactory> xMSF(mxComponentContext->getServiceManager(), + uno::UNO_QUERY); + const OUString aServiceName("com.sun.star.comp.Writer.EPUBExportFilter"); + uno::Reference<document::XFilter> xFilter(xMSF->createInstance(aServiceName), uno::UNO_QUERY); + // Should result in no errors. + xFilter->cancel(); + // We got back what we expected. + uno::Reference<lang::XServiceInfo> xServiceInfo(xFilter, uno::UNO_QUERY); + CPPUNIT_ASSERT_EQUAL(aServiceName, xServiceInfo->getImplementationName()); + CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.document.ExportFilter")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testEPUB2) +{ + uno::Sequence<beans::PropertyValue> aFilterData(comphelper::InitPropertySequence( + { // Explicitly request EPUB2. + { "EPUBVersion", uno::makeAny(static_cast<sal_Int32>(20)) } })); + createDoc("hello.fodt", aFilterData); + + mpXmlDoc = parseExport("OEBPS/content.opf"); + // This was 3.0, EPUBVersion filter option was ignored and we always emitted EPUB3. + assertXPath(mpXmlDoc, "/opf:package", "version", "2.0"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testEPUBFixedLayout) +{ + uno::Sequence<beans::PropertyValue> aFilterData(comphelper::InitPropertySequence( + { // Explicitly request fixed layout. + { "EPUBLayoutMethod", + uno::makeAny(static_cast<sal_Int32>(libepubgen::EPUB_LAYOUT_METHOD_FIXED)) } })); + createDoc("hello.fodt", aFilterData); + + mpXmlDoc = parseExport("OEBPS/content.opf"); + // This was missing, EPUBLayoutMethod filter option was ignored and we always emitted reflowable layout. + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/opf:meta[@property='rendition:layout']", + "pre-paginated"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testEPUBFixedLayoutOption) +{ + // Explicitly request fixed layout, this time via FilterOptions. + maFilterOptions = "layout=fixed"; + createDoc("hello.fodt", {}); + + // This failed, fixed layout was only working via the FilterData map. + mpXmlDoc = parseExport("OEBPS/content.opf"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/opf:meta[@property='rendition:layout']", + "pre-paginated"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testEPUBFixedLayoutImplicitBreak) +{ + uno::Sequence<beans::PropertyValue> aFilterData(comphelper::InitPropertySequence( + { // Explicitly request fixed layout. + { "EPUBLayoutMethod", + uno::makeAny(static_cast<sal_Int32>(libepubgen::EPUB_LAYOUT_METHOD_FIXED)) } })); + createDoc("fxl-2page.fodt", aFilterData); + + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/sections/section0001.xhtml")); + // This was missing, implicit page break (as calculated by the layout) was lost on export. + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/sections/section0002.xhtml")); + CPPUNIT_ASSERT(!mxZipFile->hasByName("OEBPS/sections/section0003.xhtml")); + + // Make sure that fixed layout has chapter names in the navigation + // document. + mpXmlDoc = parseExport("OEBPS/toc.xhtml"); + // This was 'Page 1' instead. + assertXPathContent(mpXmlDoc, "//xhtml:li[1]/xhtml:a", "First chapter"); + assertXPathContent(mpXmlDoc, "//xhtml:li[2]/xhtml:a", "Second chapter"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testPageBreakSplit) +{ + uno::Sequence<beans::PropertyValue> aFilterData(comphelper::InitPropertySequence( + { // Explicitly request split on page break (instead of on heading). + { "EPUBSplitMethod", + uno::makeAny(static_cast<sal_Int32>(libepubgen::EPUB_SPLIT_METHOD_PAGE_BREAK)) } })); + createDoc("2pages.fodt", aFilterData); + + // Make sure that the output is split into two. + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/sections/section0001.xhtml")); + // This failed, output was a single section. + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/sections/section0002.xhtml")); + CPPUNIT_ASSERT(!mxZipFile->hasByName("OEBPS/sections/section0003.xhtml")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testSpanAutostyle) +{ + createDoc("span-autostyle.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:span[1]", "class", "span0"); + // This failed, it was still span1, i.e. the bold and the italic formatting + // did not differ. + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:span[2]", "class", "span1"); + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:span[3]", "class", "span2"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testParaAutostyleCharProps) +{ + createDoc("para-autostyle-char-props.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // This failed, para-level char props were not exported. + assertXPath(mpXmlDoc, "//xhtml:p[1]/xhtml:span", "class", "span0"); + assertXPath(mpXmlDoc, "//xhtml:p[2]/xhtml:span", "class", "span1"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testMeta) +{ + createDoc("meta.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/content.opf"); + // This was "Unknown Author", <meta:initial-creator> was not handled. + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:creator", "A U Thor"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:title", "Title"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:language", "hu"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/opf:meta[@property='dcterms:modified']", + "2017-09-27T09:51:19Z"); + + // Make sure that cover image next to the source document is picked up. + assertXPath(mpXmlDoc, "/opf:package/opf:manifest/opf:item[@href='images/image0001.png']", + "properties", "cover-image"); + assertXPath(mpXmlDoc, "/opf:package/opf:manifest/opf:item[@href='images/image0001.png']", + "media-type", "image/png"); + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/images/image0001.png")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testMetaXMP) +{ + createDoc("meta-xmp.fodt", {}); + mpXmlDoc = parseExport("OEBPS/content.opf"); + + // These were the libepubgen default values, metadata from a matching .xmp file was not picked up. + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:identifier", + "deadbeef-e394-4cd6-9b83-7172794612e5"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:title", "unknown title from xmp"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:creator", "unknown author from xmp"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:language", "nl"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/opf:meta[@property='dcterms:modified']", + "2016-11-20T17:16:07Z"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testMetaAPI) +{ + uno::Sequence<beans::PropertyValue> aFilterData(comphelper::InitPropertySequence( + { { "RVNGIdentifier", uno::makeAny(OUString("deadc0de-e394-4cd6-9b83-7172794612e5")) }, + { "RVNGTitle", uno::makeAny(OUString("unknown title from api")) }, + { "RVNGInitialCreator", uno::makeAny(OUString("unknown author from api")) }, + { "RVNGLanguage", uno::makeAny(OUString("hu")) }, + { "RVNGDate", uno::makeAny(OUString("2015-11-20T17:16:07Z")) } })); + createDoc("meta-xmp.fodt", aFilterData); + mpXmlDoc = parseExport("OEBPS/content.opf"); + + // These were values from XMP (deadbeef, etc.), not from API. + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:identifier", + "deadc0de-e394-4cd6-9b83-7172794612e5"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:title", "unknown title from api"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:creator", "unknown author from api"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/dc:language", "hu"); + assertXPathContent(mpXmlDoc, "/opf:package/opf:metadata/opf:meta[@property='dcterms:modified']", + "2015-11-20T17:16:07Z"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testCoverImage) +{ + OUString aCoverURL = m_directories.getURLFromSrc(DATA_DIRECTORY) + "meta.cover-image.png"; + uno::Sequence<beans::PropertyValue> aFilterData( + comphelper::InitPropertySequence({ { "RVNGCoverImage", uno::makeAny(aCoverURL) } })); + createDoc("hello.fodt", aFilterData); + mpXmlDoc = parseExport("OEBPS/content.opf"); + + // Make sure that the explicitly set cover image is used. + // This failed, as the image was not part of the package. + assertXPath(mpXmlDoc, "/opf:package/opf:manifest/opf:item[@href='images/image0001.png']", + "properties", "cover-image"); + assertXPath(mpXmlDoc, "/opf:package/opf:manifest/opf:item[@href='images/image0001.png']", + "media-type", "image/png"); + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/images/image0001.png")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testParaNamedstyle) +{ + createDoc("para-namedstyle.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + assertXPath(mpXmlDoc, "//xhtml:p[1]", "class", "para0"); + // This failed, paragraph properties from style were not exported. + assertXPath(mpXmlDoc, "//xhtml:p[2]", "class", "para1"); + + // Test character properties from named paragraph style. + assertXPath(mpXmlDoc, "//xhtml:p[1]/xhtml:span", "class", "span0"); + // This failed, character properties from paragraph style were not exported. + assertXPath(mpXmlDoc, "//xhtml:p[2]/xhtml:span", "class", "span1"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testCharNamedstyle) +{ + createDoc("char-namedstyle.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + + // Test character properties from named text style. + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:span[1]", "class", "span0"); + // This failed, character properties from text style were not exported. + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:span[2]", "class", "span1"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testNamedStyleInheritance) +{ + createDoc("named-style-inheritance.fodt", {}); + + // Find the CSS rule for the blue text. + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + OUString aBlue = getXPath(mpXmlDoc, "//xhtml:p[2]/xhtml:span[2]", "class"); + + CPPUNIT_ASSERT_EQUAL(OUString("#0000ff"), EPUBExportTest::getCss(aCssDoc, aBlue, "color")); + // This failed, the span only had the properties from its style, but not + // from the style's parent(s). + CPPUNIT_ASSERT_EQUAL(OUString("'Liberation Mono'"), + EPUBExportTest::getCss(aCssDoc, aBlue, "font-family")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testNestedSpan) +{ + createDoc("nested-span.fodt", {}); + + // Check textural content of nested span. + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + // This crashed, span had no content. + assertXPathContent(mpXmlDoc, "//xhtml:p/xhtml:span[2]", "red"); + + // Check formatting of nested span. + OUString aRed = getXPath(mpXmlDoc, "//xhtml:p/xhtml:span[2]", "class"); + // This failed, direct formatting on top of named style was lost. + CPPUNIT_ASSERT_EQUAL(OUString("#ff0000"), EPUBExportTest::getCss(aCssDoc, aRed, "color")); + CPPUNIT_ASSERT_EQUAL(OUString("'Liberation Mono'"), + EPUBExportTest::getCss(aCssDoc, aRed, "font-family")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testLineBreak) +{ + createDoc("line-break.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // This was 0, line break was not handled. + assertXPath(mpXmlDoc, "//xhtml:p[1]/xhtml:span/xhtml:br", 1); + // This was 0, line break inside span was not handled. + assertXPath(mpXmlDoc, "//xhtml:p[2]/xhtml:span/xhtml:br", 1); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testEscape) +{ + createDoc("escape.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // This was lost. + assertXPathContent(mpXmlDoc, "//xhtml:p[1]/xhtml:span[1]", OUString::fromUtf8("\xc2\xa0")); + // Make sure escaping happens only once. + assertXPathContent(mpXmlDoc, "//xhtml:p[1]/xhtml:span[2]", "a&b"); + // This was also lost. + assertXPathContent( + mpXmlDoc, "//xhtml:p[1]/xhtml:span[3]", + OUString::fromUtf8("\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2" + "\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0 ")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testParaCharProps) +{ + createDoc("para-char-props.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + // Check formatting of the middle span. + OUString aMiddle = getXPath(mpXmlDoc, "//xhtml:p/xhtml:span[2]", "class"); + CPPUNIT_ASSERT_EQUAL(OUString("italic"), + EPUBExportTest::getCss(aCssDoc, aMiddle, "font-style")); + // Direct para formatting was lost, only direct char formatting was + // written, so this failed. + CPPUNIT_ASSERT_EQUAL(OUString("bold"), EPUBExportTest::getCss(aCssDoc, aMiddle, "font-weight")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testSection) +{ + createDoc("section.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // This was "After.", i.e. in-section content was ignored. + assertXPathContent(mpXmlDoc, "//xhtml:p[2]/xhtml:span", "In section."); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testList) +{ + createDoc("list.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // This was "C", i.e. in-list content was ignored. + assertXPathContent(mpXmlDoc, "//xhtml:p[2]/xhtml:span", "B"); + // Test nested list content. + assertXPathContent(mpXmlDoc, "//xhtml:p[6]/xhtml:span", "F"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testImage) +{ + createDoc("image.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:img", 1); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testImageBorder) +{ + createDoc("image-border.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + + OUString aClass = getXPath(mpXmlDoc, "//xhtml:img", "class"); + // This failed, image had no border. + CPPUNIT_ASSERT_EQUAL(OUString("0.99pt dashed #ed1c24"), + EPUBExportTest::getCss(aCssDoc, aClass, "border")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testImageNospan) +{ + createDoc("image-nospan.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // Image outside a span was lost. + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:img", 1); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTable) +{ + createDoc("table.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + assertXPath(mpXmlDoc, "//xhtml:table/xhtml:tbody/xhtml:tr/xhtml:td", 4); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTableRowSpan) +{ + createDoc("table-row-span.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // This failed, row span wasn't exported. + assertXPath(mpXmlDoc, "//xhtml:table/xhtml:tbody/xhtml:tr[1]/xhtml:td[1]", "rowspan", "2"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTableCellBorder) +{ + createDoc("table-cell-border.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + + OUString aClass + = getXPath(mpXmlDoc, "//xhtml:table/xhtml:tbody/xhtml:tr[1]/xhtml:td[1]", "class"); + // This failed, cell border wasn't exported. + CPPUNIT_ASSERT_EQUAL(OUString("0.05pt solid #000000"), + EPUBExportTest::getCss(aCssDoc, aClass, "border-left")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTableCellWidth) +{ + createDoc("table-cell-width.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + OUString aClass1 + = getXPath(mpXmlDoc, "//xhtml:table/xhtml:tbody/xhtml:tr[1]/xhtml:td[1]", "class"); + OUString aClass2 + = getXPath(mpXmlDoc, "//xhtml:table/xhtml:tbody/xhtml:tr[1]/xhtml:td[2]", "class"); + OUString aClass3 + = getXPath(mpXmlDoc, "//xhtml:table/xhtml:tbody/xhtml:tr[1]/xhtml:td[3]", "class"); + // These failed, all widths were 0. + CPPUNIT_ASSERT_GREATER(EPUBExportTest::getCss(aCssDoc, aClass2, "width").toDouble(), + EPUBExportTest::getCss(aCssDoc, aClass1, "width").toDouble()); + CPPUNIT_ASSERT_GREATER(EPUBExportTest::getCss(aCssDoc, aClass3, "width").toDouble(), + EPUBExportTest::getCss(aCssDoc, aClass1, "width").toDouble()); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTableRowHeight) +{ + createDoc("table-row-height.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + OUString aClass1 = getXPath(mpXmlDoc, "//xhtml:table/xhtml:tbody/xhtml:tr[1]", "class"); + OUString aClass2 = getXPath(mpXmlDoc, "//xhtml:table/xhtml:tbody/xhtml:tr[2]", "class"); + // These failed, both heights were 0. + CPPUNIT_ASSERT_GREATER(EPUBExportTest::getCss(aCssDoc, aClass2, "height").toDouble(), + EPUBExportTest::getCss(aCssDoc, aClass1, "height").toDouble()); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testLink) +{ + createDoc("link.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + assertXPathContent(mpXmlDoc, "//xhtml:p/xhtml:a/xhtml:span", "https://libreoffice.org/"); + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:a", "href", "https://libreoffice.org/"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testLinkInvalid) +{ + createDoc("link-invalid.odt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // This was 1, invalid relative link was not filtered out. + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:a", 0); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testLinkCharFormat) +{ + createDoc("link-charformat.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // <span> was lost, link text having a char format was missing. + assertXPathContent(mpXmlDoc, "//xhtml:p/xhtml:a/xhtml:span", "https://libreoffice.org/"); + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:a", "href", "https://libreoffice.org/"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testLinkNamedCharFormat) +{ + // Character properties from named character style on hyperlink was lost. + createDoc("link-namedcharformat.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + // This failed, there was no span inside the hyperlink. + assertXPathContent(mpXmlDoc, "//xhtml:p/xhtml:a/xhtml:span", "http://libreoffice.org"); + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:a", "href", "http://libreoffice.org/"); + + OUString aClass = getXPath(mpXmlDoc, "//xhtml:p/xhtml:a/xhtml:span", "class"); + CPPUNIT_ASSERT_EQUAL(OUString("#ff0000"), EPUBExportTest::getCss(aCssDoc, aClass, "color")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTableWidth) +{ + createDoc("table-width.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + + OUString aClass = getXPath(mpXmlDoc, "//xhtml:table", "class"); + // This failed, relative total width of table was lost. + CPPUNIT_ASSERT_EQUAL(OUString("50%"), EPUBExportTest::getCss(aCssDoc, aClass, "width")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTextBox) +{ + createDoc("text-box.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + + // This failed, image with caption was lost. + assertXPath(mpXmlDoc, "//xhtml:img", "class", "frame1"); + // Expected spans: + // 1) break after the image + // 2) "Illustration " + // 3) The sequence field, this was missing (was ": foo" instead). + assertXPathContent(mpXmlDoc, "//xhtml:div/xhtml:p/xhtml:span[3]", "1"); + + OUString aClass = getXPath(mpXmlDoc, "//xhtml:div/xhtml:p/xhtml:span[3]", "class"); + // This failed, the 3rd span was not italic. + CPPUNIT_ASSERT_EQUAL(OUString("italic"), EPUBExportTest::getCss(aCssDoc, aClass, "font-style")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testFontEmbedding) +{ +#if !defined(MACOSX) + createDoc("font-embedding.fodt", {}); + + // Make sure that the params of defineEmbeddedFont() are all handled. + // librevenge:name + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + // 'SketchFlow Print' or ''SketchFlow Print1' + CPPUNIT_ASSERT(EPUBExportTest::getCss(aCssDoc, "font-face", "font-family") + .startsWith("'SketchFlow Print")); + // librevenge:mime-type + mpXmlDoc = parseExport("OEBPS/content.opf"); + assertXPath(mpXmlDoc, "/opf:package/opf:manifest/opf:item[@href='fonts/font0001.otf']", + "media-type", "application/vnd.ms-opentype"); + // office:binary-data + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/fonts/font0001.otf")); + // librevenge:font-style + CPPUNIT_ASSERT_EQUAL(OUString("normal"), + EPUBExportTest::getCss(aCssDoc, "font-face", "font-style")); + // librevenge:font-weight + CPPUNIT_ASSERT_EQUAL(OUString("normal"), + EPUBExportTest::getCss(aCssDoc, "font-face", "font-weight")); +#endif +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testImageLink) +{ + createDoc("image-link.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // This failed, image was missing. + assertXPath(mpXmlDoc, "//xhtml:p/xhtml:a/xhtml:img", 1); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testFootnote) +{ + createDoc("footnote.fodt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // These were missing, footnote was lost. + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:p/xhtml:sup/xhtml:a", "type", "noteref"); + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:aside", "type", "footnote"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testPopup) +{ + createDoc("popup.odt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // Test image popup anchor. + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:p[1]/xhtml:a", "type", "noteref"); + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:p[1]/xhtml:a/xhtml:img", 1); + // Test image popup content. + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:aside[1]", "type", "footnote"); + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:aside[1]/xhtml:img", 1); + + // Test text popup anchor. + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:p[2]/xhtml:span/xhtml:a", "type", "noteref"); + assertXPathContent(mpXmlDoc, "//xhtml:body/xhtml:p[2]/xhtml:span/xhtml:a", "link"); + // Test text popup content. + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:aside[2]", "type", "footnote"); + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:aside[2]/xhtml:img", 1); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testPopupMedia) +{ + // This is the same as testPopup(), but the links point to images in the + // default media directory, not in the document directory. + createDoc("popup-media.odt", {}); + + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // Test image popup anchor. This failed, number of XPath nodes was 0. + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:p[1]/xhtml:a", "type", "noteref"); + assertXPath(mpXmlDoc, "//xhtml:body/xhtml:p[1]/xhtml:a/xhtml:img", 1); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testPopupAPI) +{ + // Make sure that the popup works with data from a media directory. + OUString aMediaDir = m_directories.getURLFromSrc(DATA_DIRECTORY) + "popup"; + uno::Sequence<beans::PropertyValue> aFilterData( + comphelper::InitPropertySequence({ { "RVNGMediaDir", uno::makeAny(aMediaDir) } })); + createDoc("popup-api.odt", aFilterData); + + // We have a non-empty anchor image. + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + OUString aAnchor = getXPath(mpXmlDoc, "//xhtml:body/xhtml:p[1]/xhtml:a/xhtml:img", "src"); + CPPUNIT_ASSERT(!aAnchor.isEmpty()); + // We have a non-empty popup image. + OUString aData = getXPath(mpXmlDoc, "//xhtml:body/xhtml:aside[1]/xhtml:img", "src"); + CPPUNIT_ASSERT(!aData.isEmpty()); + // The anchor is different from the popup image. + CPPUNIT_ASSERT(aAnchor != aData); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testPageSize) +{ + uno::Sequence<beans::PropertyValue> aFilterData(comphelper::InitPropertySequence( + { { "EPUBLayoutMethod", + uno::makeAny(static_cast<sal_Int32>(libepubgen::EPUB_LAYOUT_METHOD_FIXED)) } })); + createDoc("hello.fodt", aFilterData); + + // This failed, viewport was empty, so page size was lost. + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + // 21,59cm x 27.94cm (letter). + assertXPath(mpXmlDoc, "/xhtml:html/xhtml:head/xhtml:meta[@name='viewport']", "content", + "width=816, height=1056"); + + mpXmlDoc = parseExport("OEBPS/images/image0001.svg"); + // This was 288mm, logic->logic conversion input was a pixel value. + assertXPath(mpXmlDoc, "/svg:svg", "width", "216mm"); + assertXPath(mpXmlDoc, "/svg:svg", "height", "279mm"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testSVG) +{ + uno::Sequence<beans::PropertyValue> aFilterData(comphelper::InitPropertySequence( + { { "EPUBLayoutMethod", + uno::makeAny(static_cast<sal_Int32>(libepubgen::EPUB_LAYOUT_METHOD_FIXED)) } })); + createDoc("hello.fodt", aFilterData); + + CPPUNIT_ASSERT(mxZipFile->hasByName("OEBPS/images/image0001.svg")); + uno::Reference<io::XInputStream> xInputStream( + mxZipFile->getByName("OEBPS/images/image0001.svg"), uno::UNO_QUERY); + std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(xInputStream, true)); + + SvMemoryStream aMemoryStream; + aMemoryStream.WriteStream(*pStream); + OString aExpected("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n<svg"); + CPPUNIT_ASSERT(aMemoryStream.GetSize() > o3tl::make_unsigned(aExpected.getLength())); + + // This failed, there was a '<!DOCTYPE' line between the xml and the svg + // one, causing a validation error. + OString aActual(static_cast<const char*>(aMemoryStream.GetData()), aExpected.getLength()); + CPPUNIT_ASSERT_EQUAL(aExpected, aActual); + + // This failed, we used the xlink attribute namespace, but we did not + // define its URL. + mpXmlDoc = parseExport("OEBPS/images/image0001.svg"); + assertXPathNSDef(mpXmlDoc, "/svg:svg", "xlink", "http://www.w3.org/1999/xlink"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTdf115623SingleWritingMode) +{ + // Simple page that has single writing mode should work. + createDoc("tdf115623-single-writing-mode.odt", {}); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + OUString aClass = getXPath(mpXmlDoc, "//xhtml:body", "class"); + CPPUNIT_ASSERT_EQUAL(OUString("vertical-rl"), + EPUBExportTest::getCss(aCssDoc, aClass, "writing-mode")); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTdf115623SplitByChapter) +{ + createDoc("tdf115623-split-by-chapter.odt", {}); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + { + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + OUString aClass = getXPath(mpXmlDoc, "//xhtml:body", "class"); + CPPUNIT_ASSERT_EQUAL(OUString("vertical-rl"), + EPUBExportTest::getCss(aCssDoc, aClass, "writing-mode")); + } + // Split HTML should keep the same writing-mode. + { + mpXmlDoc = parseExport("OEBPS/sections/section0002.xhtml"); + OUString aClass = getXPath(mpXmlDoc, "//xhtml:body", "class"); + CPPUNIT_ASSERT_EQUAL(OUString("vertical-rl"), + EPUBExportTest::getCss(aCssDoc, aClass, "writing-mode")); + } +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testTdf115623ManyPageSpans) +{ + createDoc("tdf115623-many-pagespans.odt", {}); + std::map<OUString, std::vector<OUString>> aCssDoc = parseCss("OEBPS/styles/stylesheet.css"); + // Two pages should have different writing modes. + { + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + OUString aClass = getXPath(mpXmlDoc, "//xhtml:body", "class"); + CPPUNIT_ASSERT_EQUAL(OUString("vertical-rl"), + EPUBExportTest::getCss(aCssDoc, aClass, "writing-mode")); + } + { + mpXmlDoc = parseExport("OEBPS/sections/section0002.xhtml"); + OUString aClass = getXPath(mpXmlDoc, "//xhtml:body", "class"); + CPPUNIT_ASSERT_EQUAL(OUString("horizontal-tb"), + EPUBExportTest::getCss(aCssDoc, aClass, "writing-mode")); + } +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testSimpleRuby) +{ + createDoc("simple-ruby.odt", {}); + mpXmlDoc = parseExport("OEBPS/sections/section0001.xhtml"); + assertXPathContent(mpXmlDoc, "//xhtml:body/xhtml:p/xhtml:ruby/xhtml:span", "base text"); + assertXPathContent(mpXmlDoc, "//xhtml:body/xhtml:p/xhtml:ruby/xhtml:rt", "ruby text"); +} + +CPPUNIT_TEST_FIXTURE(EPUBExportTest, testAbi11105) +{ + // This crashed because the paragraph style "P5" which had a master-page-name + // appeared in a table cell messed up page spans. + createDoc("abi11105.abw", {}); +} +} + +CPPUNIT_PLUGIN_IMPLEMENT(); + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |