From 267c6f2ac71f92999e969232431ba04678e7437e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 15 Apr 2024 07:54:39 +0200 Subject: Adding upstream version 4:24.2.0. Signed-off-by: Daniel Baumann --- sw/qa/extras/rtfexport/rtfexport6.cxx | 756 ++++++++++++++++++++++++++++++++++ 1 file changed, 756 insertions(+) create mode 100644 sw/qa/extras/rtfexport/rtfexport6.cxx (limited to 'sw/qa/extras/rtfexport/rtfexport6.cxx') diff --git a/sw/qa/extras/rtfexport/rtfexport6.cxx b/sw/qa/extras/rtfexport/rtfexport6.cxx new file mode 100644 index 0000000000..ff331caa73 --- /dev/null +++ b/sw/qa/extras/rtfexport/rtfexport6.cxx @@ -0,0 +1,756 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +using namespace css; + +class Test : public SwModelTestBase +{ +public: + Test() + : SwModelTestBase("/sw/qa/extras/rtfexport/data/", "Rich Text Format") + { + } +}; + +DECLARE_RTFEXPORT_TEST(testFdo85889pc, "fdo85889-pc.rtf") +{ + uno::Reference xTextRange = getRun(getParagraph(1), 1); + + CPPUNIT_ASSERT_EQUAL(u"\u00B1\u2265\u2264"_ustr, xTextRange->getString()); +} + +DECLARE_RTFEXPORT_TEST(testFdo85889pca, "fdo85889-pca.rtf") +{ + uno::Reference xTextRange = getRun(getParagraph(1), 1); + + CPPUNIT_ASSERT_EQUAL(u"\u00B1\u2017\u00BE"_ustr, xTextRange->getString()); +} + +DECLARE_RTFEXPORT_TEST(testFdo85889mac, "fdo85889-mac.rtf") +{ + uno::Reference xTextRange = getRun(getParagraph(1), 1); + + CPPUNIT_ASSERT_EQUAL(u"\u00D2\u00DA\u00DB"_ustr, xTextRange->getString()); +} + +CPPUNIT_TEST_FIXTURE(Test, testFdo72031) +{ + auto verify = [this]() { + CPPUNIT_ASSERT_EQUAL(u"\uF0C5"_ustr, getRun(getParagraph(1), 1)->getString()); + }; + + AllSettings aSavedSettings = Application::GetSettings(); + AllSettings aSettings(aSavedSettings); + aSettings.SetLanguageTag(LanguageTag("ru")); + Application::SetSettings(aSettings); + comphelper::ScopeGuard g([&aSavedSettings] { Application::SetSettings(aSavedSettings); }); + + createSwDoc("fdo72031.rtf"); + verify(); + saveAndReload("Rich Text Format"); + verify(); +} + +DECLARE_RTFEXPORT_TEST(testFdo86750, "fdo86750.rtf") +{ + // This was 'HYPERLINK#anchor', the URL of the hyperlink had the field type as a prefix, leading to broken links. + CPPUNIT_ASSERT_EQUAL(OUString("#anchor"), + getProperty(getRun(getParagraph(1), 1), "HyperLinkURL")); +} + +DECLARE_RTFEXPORT_TEST(testTdf88811, "tdf88811.rtf") +{ + // The problem was that shapes anchored to the paragraph that is moved into a textframe were lost, so this was 2. + CPPUNIT_ASSERT_EQUAL(4, getShapes()); +} + +DECLARE_RTFEXPORT_TEST(testFdo49893_2, "fdo49893-2.rtf") +{ + // Ensure that header text exists on each page (especially on second page) + CPPUNIT_ASSERT_EQUAL(OUString("HEADER"), parseDump("/root/page[1]/header/txt/text()"_ostr)); + CPPUNIT_ASSERT_EQUAL(OUString("HEADER"), parseDump("/root/page[2]/header/txt/text()"_ostr)); + CPPUNIT_ASSERT_EQUAL(OUString("HEADER"), parseDump("/root/page[3]/header/txt/text()"_ostr)); + CPPUNIT_ASSERT_EQUAL(OUString("HEADER"), parseDump("/root/page[4]/header/txt/text()"_ostr)); + CPPUNIT_ASSERT_EQUAL(OUString("HEADER"), parseDump("/root/page[5]/header/txt/text()"_ostr)); + CPPUNIT_ASSERT_EQUAL(5, getPages()); // Word has 5 +} + +DECLARE_RTFEXPORT_TEST(testFdo89496, "fdo89496.rtf") +{ + // Just ensure that document is loaded and shape exists + uno::Reference xShape = getShape(1); + CPPUNIT_ASSERT(xShape.is()); +} + +DECLARE_RTFEXPORT_TEST(testFdo75614, "tdf75614.rtf") +{ + // Text after the footnote was missing, so this resulted in a css::container::NoSuchElementException. + CPPUNIT_ASSERT_EQUAL(OUString("after."), getRun(getParagraph(1), 3)->getString()); +} + +DECLARE_RTFEXPORT_TEST(mathtype, "mathtype.rtf") +{ + OUString aFormula = getFormula(getRun(getParagraph(1), 1)); + CPPUNIT_ASSERT(!aFormula.isEmpty()); +} + +DECLARE_RTFEXPORT_TEST(testTdf86182, "tdf86182.rtf") +{ + // Writing mode was the default, i.e. text::WritingMode2::CONTEXT. + CPPUNIT_ASSERT_EQUAL(text::WritingMode2::RL_TB, + getProperty(getParagraph(1), "WritingMode")); +} + +DECLARE_RTFEXPORT_TEST(testTdf91074, "tdf91074.rtf") +{ + // The file failed to load, as the border color was imported using the LineColor UNO property. + uno::Reference xShape = getShape(1); + CPPUNIT_ASSERT_EQUAL( + COL_LIGHTRED, + Color(ColorTransparency, getProperty(xShape, "TopBorder").Color)); +} + +CPPUNIT_TEST_FIXTURE(Test, testTdf90260Nopar) +{ + createSwDoc("hello.rtf"); + uno::Reference xTextDocument(mxComponent, uno::UNO_QUERY); + uno::Reference xText = xTextDocument->getText(); + uno::Reference xEnd = xText->getEnd(); + paste(u"rtfexport/data/tdf90260-nopar.rtf", "com.sun.star.comp.Writer.RtfFilter", xEnd); + CPPUNIT_ASSERT_EQUAL(1, getParagraphs()); +} + +DECLARE_RTFEXPORT_TEST(testTdf86814, "tdf86814.rtf") +{ + // This was awt::FontWeight::NORMAL, i.e. the first run wasn't bold, when it should be bold (applied paragraph style with direct formatting). + CPPUNIT_ASSERT_EQUAL(awt::FontWeight::BOLD, + getProperty(getRun(getParagraph(1), 1), "CharWeight")); +} + +DECLARE_RTFEXPORT_TEST(testTdf108505_fieldCharFormat, "tdf108505_fieldCharFormat.rtf") +{ + uno::Reference xTable(getParagraphOrTable(1), uno::UNO_QUERY); + uno::Reference xCell(xTable->getCellByName("C1"), uno::UNO_QUERY); + uno::Reference xPara = getParagraphOfText(1, xCell->getText()); + + // Character formatting can be defined inside the field for part of it. It wasn't being applied. + // Bold and green are specified. \fldrslt's "bogus result" (with italic/red) should be ignored. + uno::Reference xRun = getRun(xPara, 3, u"MZ"_ustr); + CPPUNIT_ASSERT_EQUAL(awt::FontWeight::BOLD, getProperty(xRun, "CharWeight")); + CPPUNIT_ASSERT_EQUAL(awt::FontSlant_NONE, getProperty(xRun, "CharPosture")); + CPPUNIT_ASSERT_EQUAL(COL_LIGHTGREEN, getProperty(xRun, "CharColor")); + + CPPUNIT_ASSERT_EQUAL(OUString("Standard"), getProperty(xPara, "ParaStyleName")); +} + +DECLARE_RTFEXPORT_TEST(testTdf108505_fieldCharFormat2, "tdf108505_fieldCharFormat2.rtf") +{ + uno::Reference xTable(getParagraphOrTable(1), uno::UNO_QUERY); + uno::Reference xCell(xTable->getCellByName("C1"), uno::UNO_QUERY); + uno::Reference xPara = getParagraphOfText(1, xCell->getText()); + + const sal_Int32 nRun = isExported() ? 6 : 5; + const Color aColor = isExported() ? COL_BLACK : COL_AUTO; + + // Character formatting should only be defined by the \fldrslt, and not by prior formatting. + // Prior formatting is italic, red, 20pt. + uno::Reference xRun = getRun(xPara, nRun, u"xyz"_ustr); + CPPUNIT_ASSERT_EQUAL(awt::FontWeight::BOLD, getProperty(xRun, "CharWeight")); + CPPUNIT_ASSERT_EQUAL(awt::FontSlant_NONE, getProperty(xRun, "CharPosture")); + CPPUNIT_ASSERT_EQUAL(aColor, getProperty(xRun, "CharColor")); +} + +/** Make sure that the document variable "Unused", which is not referenced in the document, + is imported and exported. */ +DECLARE_RTFEXPORT_TEST(testTdf150267, "tdf150267.rtf") +{ + uno::Reference xModel(mxComponent, uno::UNO_QUERY); + uno::Reference xSupplier(xModel, uno::UNO_QUERY); + uno::Reference xTextFieldMasters = xSupplier->getTextFieldMasters(); + CPPUNIT_ASSERT_EQUAL(sal_True, + xTextFieldMasters->hasByName("com.sun.star.text.fieldmaster.User.Unused")); + + auto xFieldMaster = xTextFieldMasters->getByName("com.sun.star.text.fieldmaster.User.Unused"); + CPPUNIT_ASSERT_EQUAL(OUString("Hello World"), getProperty(xFieldMaster, "Content")); +} + +DECLARE_RTFEXPORT_TEST(testTdf151370, "tdf151370.rtf") +{ + uno::Reference xModel(mxComponent, uno::UNO_QUERY); + uno::Reference xSupplier(xModel, uno::UNO_QUERY); + uno::Reference xTextFieldMasters = xSupplier->getTextFieldMasters(); + // Here we try to read/write docvar having non-ascii name and value. So it is encoded in Unicode + OUString sFieldName(u"com.sun.star.text.fieldmaster.User." + "LocalChars\u00c1\u0072\u0076\u00ed\u007a\u0074\u0075\u0072\u006f\u0054" + "\u00fc\u006b\u00f6\u0072\u0066\u00fa\u0072\u00f3\u0067\u00e9\u0070"_ustr); + CPPUNIT_ASSERT_EQUAL(sal_True, xTextFieldMasters->hasByName(sFieldName)); + + auto xFieldMaster = xTextFieldMasters->getByName(sFieldName); + CPPUNIT_ASSERT_EQUAL(u"\u00e1\u0072\u0076\u00ed\u007a\u0074\u0075\u0072\u006f\u0074\u00fc" + "\u006b\u00f6\u0072\u0066\u00fa\u0072\u00f3\u0067\u00e9\u0070"_ustr, + getProperty(xFieldMaster, "Content")); +} + +DECLARE_RTFEXPORT_TEST(testTdf108416, "tdf108416.rtf") +{ + uno::Reference xCharacterStyles(getStyles("CharacterStyles")); + uno::Reference xListLabel(xCharacterStyles->getByName("ListLabel 1"), + uno::UNO_QUERY); + // This was awt::FontWeight::BOLD, list numbering got an unexpected bold formatting. + CPPUNIT_ASSERT_EQUAL(awt::FontWeight::NORMAL, getProperty(xListLabel, "CharWeight")); +} + +DECLARE_RTFEXPORT_TEST(testBinSkipping, "bin-skipping.rtf") +{ + // before, it was importing '/nMUST NOT IMPORT' + CPPUNIT_ASSERT_EQUAL(OUString("text"), getRun(getParagraph(1), 1)->getString()); +} + +DECLARE_RTFEXPORT_TEST(testTdf92061, "tdf92061.rtf") +{ + // This was "C", i.e. part of the footnote ended up in the body text. + CPPUNIT_ASSERT_EQUAL(OUString("body-after"), getRun(getParagraph(1), 3)->getString()); +} + +DECLARE_RTFEXPORT_TEST(testTdf92481, "tdf92481.rtf") +{ + // This was 0, RTF_WIDOWCTRL was not imported. + CPPUNIT_ASSERT_EQUAL(static_cast(2), + getProperty(getParagraph(1), "ParaWidows")); +} + +DECLARE_RTFEXPORT_TEST(testTdf94456, "tdf94456.rtf") +{ + // Paragraph left margin and first line indent wasn't imported correctly. + + // This was 1270. + CPPUNIT_ASSERT_EQUAL(static_cast(762), + getProperty(getParagraph(1), "ParaLeftMargin")); + // This was -635. + CPPUNIT_ASSERT_EQUAL(static_cast(-762), + getProperty(getParagraph(1), "ParaFirstLineIndent")); +} + +DECLARE_RTFEXPORT_TEST(testTdf94435, "tdf94435.rtf") +{ + // This was style::ParagraphAdjust_LEFT, \ltrpar undone the effect of \qc. + CPPUNIT_ASSERT_EQUAL( + style::ParagraphAdjust_CENTER, + static_cast(getProperty(getParagraph(1), "ParaAdjust"))); +} + +DECLARE_RTFEXPORT_TEST(testTdf54584, "tdf54584.rtf") +{ + uno::Reference xTextFieldsSupplier(mxComponent, uno::UNO_QUERY); + uno::Reference xFieldsAccess( + xTextFieldsSupplier->getTextFields()); + uno::Reference xFields(xFieldsAccess->createEnumeration()); + // \PAGE was ignored, so no fields were in document -> exception was thrown + CPPUNIT_ASSERT_NO_THROW_MESSAGE( + "No fields in document found: field \"\\PAGE\" was not properly read", + xFields->nextElement()); +} + +DECLARE_RTFEXPORT_TEST(testTdf96308Deftab, "tdf96308-deftab.rtf") +{ + uno::Reference xTextFactory(mxComponent, uno::UNO_QUERY); + uno::Reference xDefaults( + xTextFactory->createInstance("com.sun.star.text.Defaults"), uno::UNO_QUERY); + // This was 1270 as \deftab was ignored on import. + CPPUNIT_ASSERT_EQUAL(static_cast(convertTwipToMm100(284)), + getProperty(xDefaults, "TabStopDistance")); +} + +DECLARE_RTFEXPORT_TEST(testLandscape, "landscape.rtf") +{ + // Check landscape flag. + CPPUNIT_ASSERT_EQUAL(3, getPages()); + + // All pages should have flag orientation + uno::Reference pageStyles = getStyles("PageStyles"); + + // get a page cursor + uno::Reference xModel(mxComponent, uno::UNO_QUERY); + uno::Reference xTextViewCursorSupplier( + xModel->getCurrentController(), uno::UNO_QUERY); + uno::Reference xCursor(xTextViewCursorSupplier->getViewCursor(), + uno::UNO_QUERY); + + // check that the first page has landscape flag + xCursor->jumpToFirstPage(); + OUString pageStyleName = getProperty(xCursor, "PageStyleName"); + uno::Reference xStylePage(pageStyles->getByName(pageStyleName), uno::UNO_QUERY); + CPPUNIT_ASSERT_EQUAL(true, getProperty(xStylePage, "IsLandscape")); + + // check that the second page has landscape flag + xCursor->jumpToPage(2); + pageStyleName = getProperty(xCursor, "PageStyleName"); + xStylePage.set(pageStyles->getByName(pageStyleName), uno::UNO_QUERY); + CPPUNIT_ASSERT_EQUAL(true, getProperty(xStylePage, "IsLandscape")); + + // check that the last page has landscape flag + xCursor->jumpToLastPage(); + pageStyleName = getProperty(xCursor, "PageStyleName"); + xStylePage.set(pageStyles->getByName(pageStyleName), uno::UNO_QUERY); + CPPUNIT_ASSERT_EQUAL(true, getProperty(xStylePage, "IsLandscape")); +} + +DECLARE_RTFEXPORT_TEST(testTdf97035, "tdf97035.rtf") +{ + uno::Reference xTextTablesSupplier(mxComponent, uno::UNO_QUERY); + uno::Reference xTables(xTextTablesSupplier->getTextTables(), + uno::UNO_QUERY); + uno::Reference xTable(xTables->getByIndex(0), uno::UNO_QUERY); + + // First cell width of the second row should be 2300 + uno::Reference xTableRows = xTable->getRows(); + CPPUNIT_ASSERT_EQUAL(sal_Int16(2300), getProperty>( + xTableRows->getByIndex(1), "TableColumnSeparators")[0] + .Position); +} + +DECLARE_RTFEXPORT_TEST(testTdf87034, "tdf87034.rtf") +{ + // This was A1BC34D, i.e. the first "super" text portion was mis-imported, + // and was inserted instead right before the second "super" text portion. + CPPUNIT_ASSERT_EQUAL(OUString("A1B3C4D"), getParagraph(1)->getString()); +} + +CPPUNIT_TEST_FIXTURE(Test, testClassificatonPasteLevels) +{ + createSwDoc("classification-confidential.rtf"); + uno::Reference xTextDocument(mxComponent, uno::UNO_QUERY); + uno::Reference xText = xTextDocument->getText(); + uno::Reference xEnd = xText->getEnd(); + + // Classified source and classified destination, but internal only has a + // higher level than confidential: nothing should happen. + OUString aOld = xText->getString(); + paste(u"rtfexport/data/classification-yes.rtf", "com.sun.star.comp.Writer.RtfFilter", xEnd); + CPPUNIT_ASSERT_EQUAL(aOld, xText->getString()); +} + +DECLARE_RTFEXPORT_TEST(testTdf95707, "tdf95707.rtf") +{ + // Graphic was replaced with a "Read-Error" placeholder. + uno::Reference xGraphic + = getProperty>(getShape(1), "Graphic"); + CPPUNIT_ASSERT(xGraphic.is()); + CPPUNIT_ASSERT(xGraphic->getType() != graphic::GraphicType::EMPTY); +} + +DECLARE_RTFEXPORT_TEST(testTdf96275, "tdf96275.rtf") +{ + uno::Reference xTable(getParagraphOrTable(1), uno::UNO_QUERY); + uno::Reference xCell(xTable->getCellByName("A1"), uno::UNO_QUERY); + uno::Reference xParagraph = getParagraphOfText(3, xCell->getText()); + // This was text: the shape's frame was part of the 1st paragraph instead of the 3rd one. + CPPUNIT_ASSERT_EQUAL(OUString("Frame"), + getProperty(getRun(xParagraph, 1), "TextPortionType")); +} + +DECLARE_RTFEXPORT_TEST(testTdf82073, "tdf82073.rtf") +{ + uno::Reference xTable(getParagraphOrTable(2), uno::UNO_QUERY); + uno::Reference xCell(xTable->getCellByName("A1"), uno::UNO_QUERY); + // This was -1: the background color was automatic, not black. + CPPUNIT_ASSERT_EQUAL(COL_BLACK, getProperty(xCell, "BackColor")); +} + +DECLARE_RTFEXPORT_TEST(testTdf74795, "tdf74795.rtf") +{ + uno::Reference xTable(getParagraphOrTable(1), uno::UNO_QUERY); + uno::Reference xCell(xTable->getCellByName("A1"), uno::UNO_QUERY); + // This was 0, \trpaddl was ignored on import. + CPPUNIT_ASSERT_EQUAL(static_cast(635), + getProperty(xCell, "LeftBorderDistance")); + + xCell.set(xTable->getCellByName("A2"), uno::UNO_QUERY); + // Make sure that the scope of the default is only one row. + CPPUNIT_ASSERT_EQUAL(static_cast(0), + getProperty(xCell, "LeftBorderDistance")); +} + +DECLARE_RTFEXPORT_TEST(testTdf137085, "tdf137085.rtf") +{ + uno::Reference xTable(getParagraphOrTable(1), uno::UNO_QUERY); + // \trpaddl0 overrides \trgaph600 (-1058 mm100) and built-in default of 190 + CPPUNIT_ASSERT_EQUAL(static_cast(0), getProperty(xTable, "LeftMargin")); + + // the \trpaddl0 is applied to all cells + uno::Reference xCell(xTable->getCellByName("A1"), uno::UNO_QUERY); + CPPUNIT_ASSERT_EQUAL(static_cast(0), + getProperty(xCell, "LeftBorderDistance")); + + xCell.set(xTable->getCellByName("B1"), uno::UNO_QUERY); + CPPUNIT_ASSERT_EQUAL(static_cast(0), + getProperty(xCell, "LeftBorderDistance")); +} + +DECLARE_RTFEXPORT_TEST(testTdf77349, "tdf77349.rtf") +{ + uno::Reference xImage(getShape(1), uno::UNO_QUERY); + // This was empty: imported image wasn't named automatically. + CPPUNIT_ASSERT_EQUAL(OUString("Image1"), xImage->getName()); +} + +DECLARE_RTFEXPORT_TEST(testTdf50821, "tdf50821.rtf") +{ + uno::Reference xTable(getParagraphOrTable(2), uno::UNO_QUERY); + uno::Reference xCell(xTable->getCellByName("A1"), uno::UNO_QUERY); + // This was 0, \trpaddfl was mishandled on import. + CPPUNIT_ASSERT_EQUAL(static_cast(191), + getProperty(xCell, "LeftBorderDistance")); +} + +DECLARE_RTFEXPORT_TEST(testTdf100507, "tdf100507.rtf") +{ + // This was 0: left margin of the first paragraph was lost on import. + CPPUNIT_ASSERT_EQUAL(static_cast(6618), + getProperty(getParagraph(1), "ParaLeftMargin")); +} + +DECLARE_RTFEXPORT_TEST(testTdf44986, "tdf44986.rtf") +{ + // Check that the table at the second paragraph. + uno::Reference xTable(getParagraphOrTable(2), uno::UNO_QUERY); + uno::Reference xTableRows = xTable->getRows(); + // Check the first row of the table, it should have two cells (one separator). + // This was 0: the first row had no separators, so it had only one cell, which was too wide. + CPPUNIT_ASSERT_EQUAL(sal_Int32(1), getProperty>( + xTableRows->getByIndex(0), "TableColumnSeparators") + .getLength()); +} + +DECLARE_RTFEXPORT_TEST(testTdf90697, "tdf90697.rtf") +{ + // We want section breaks to be seen as section breaks, not as page breaks, + // so this document should have only one page, not three. + CPPUNIT_ASSERT_EQUAL(1, getPages()); +} + +DECLARE_RTFEXPORT_TEST(testTdf104317, "tdf104317.rtf") +{ + // This failed to load, we tried to set CustomShapeGeometry on a line shape. + CPPUNIT_ASSERT_EQUAL(1, getShapes()); +} + +DECLARE_RTFEXPORT_TEST(testTdf104744, "tdf104744.rtf") +{ + auto xRules = getProperty>( + getStyles("NumberingStyles")->getByName("WWNum1"), "NumberingRules"); + comphelper::SequenceAsHashMap aRule(xRules->getByIndex(0)); + // This was 0. + CPPUNIT_ASSERT_EQUAL(static_cast(1270), aRule["IndentAt"].get()); +} + +CPPUNIT_TEST_FIXTURE(SwModelTestBase, testChicagoNumberingFootnote) +{ + // Create a document, set footnote numbering type to SYMBOL_CHICAGO. + createSwDoc(); + uno::Reference xFootnotesSupplier(mxComponent, uno::UNO_QUERY); + uno::Reference xFootnoteSettings + = xFootnotesSupplier->getFootnoteSettings(); + sal_uInt16 nNumberingType = style::NumberingType::SYMBOL_CHICAGO; + xFootnoteSettings->setPropertyValue("NumberingType", uno::Any(nNumberingType)); + + // Insert a footnote. + uno::Reference xFactory(mxComponent, uno::UNO_QUERY); + uno::Reference xFootnote( + xFactory->createInstance("com.sun.star.text.Footnote"), uno::UNO_QUERY); + uno::Reference xTextDocument(mxComponent, uno::UNO_QUERY); + uno::Reference xTextContentAppend(xTextDocument->getText(), + uno::UNO_QUERY); + xTextContentAppend->appendTextContent(xFootnote, {}); + + saveAndReload("Rich Text Format"); + xFootnotesSupplier.set(mxComponent, uno::UNO_QUERY); + sal_uInt16 nExpected = style::NumberingType::SYMBOL_CHICAGO; + auto nActual + = getProperty(xFootnotesSupplier->getFootnoteSettings(), "NumberingType"); + // Without the accompanying fix in place, this test would have failed with: + // - Expected: 63 + // - Actual : 4 + // i.e. the numbering type was ARABIC, not SYMBOL_CHICAGO. + CPPUNIT_ASSERT_EQUAL(nExpected, nActual); +} + +DECLARE_RTFEXPORT_TEST(testTdf105852, "tdf105852.rtf") +{ + uno::Reference xTablesSupplier(mxComponent, uno::UNO_QUERY); + uno::Reference xTables(xTablesSupplier->getTextTables(), + uno::UNO_QUERY); + uno::Reference xTextTable(xTables->getByIndex(0), uno::UNO_QUERY); + uno::Reference xTableRows = xTextTable->getRows(); + // All rows but last were merged -> there were only 2 rows + CPPUNIT_ASSERT_EQUAL(sal_Int32(6), xTableRows->getCount()); + // The first row must have 4 cells. + CPPUNIT_ASSERT_EQUAL(sal_Int32(3), getProperty>( + xTableRows->getByIndex(0), "TableColumnSeparators") + .getLength()); + // The third row must have 1 merged cell. + CPPUNIT_ASSERT_EQUAL(sal_Int32(0), getProperty>( + xTableRows->getByIndex(2), "TableColumnSeparators") + .getLength()); +} + +DECLARE_RTFEXPORT_TEST(testTdf104287, "tdf104287.rtf") +{ + uno::Reference xShape(getShape(1), uno::UNO_QUERY); + CPPUNIT_ASSERT(xShape.is()); + // This failed, the bitmap had no valid anchor. + CPPUNIT_ASSERT(xShape->getAnchor().is()); +} + +DECLARE_RTFEXPORT_TEST(testTdf105729, "tdf105729.rtf") +{ + // This was style::ParagraphAdjust_LEFT, \ltrpar undone the effect of \qc from style. + CPPUNIT_ASSERT_EQUAL( + style::ParagraphAdjust_CENTER, + static_cast(getProperty(getParagraph(1), "ParaAdjust"))); +} + +DECLARE_RTFEXPORT_TEST(testTdf106694, "tdf106694.rtf") +{ + auto aTabs = getProperty>(getParagraph(1), "ParaTabStops"); + CPPUNIT_ASSERT_EQUAL(static_cast(1), aTabs.getLength()); + // This was 0, tab position was incorrect, looked like it was missing. + CPPUNIT_ASSERT_EQUAL(static_cast(14605), aTabs[0].Position); +} + +DECLARE_RTFEXPORT_TEST(testTdf107116, "tdf107116.rtf") +{ + // This was 0, upper border around text (and its distance) was missing. + CPPUNIT_ASSERT_EQUAL(static_cast(convertTwipToMm100(120)), + getProperty(getParagraph(2), "TopBorderDistance")); +} + +DECLARE_RTFEXPORT_TEST(testTdf106950, "tdf106950.rtf") +{ + uno::Reference xPara(getParagraph(1)); + // This was ParagraphAdjust_LEFT, trying to set CharShadingValue on a + // paragraph style thrown an exception, and remaining properties were not + // set. + CPPUNIT_ASSERT_EQUAL( + style::ParagraphAdjust_CENTER, + static_cast(getProperty(xPara, "ParaAdjust"))); +} + +CPPUNIT_TEST_FIXTURE(Test, testTdf116371) +{ + loadAndReload("tdf116371.odt"); + CPPUNIT_ASSERT_EQUAL(1, getShapes()); + CPPUNIT_ASSERT_EQUAL(1, getPages()); + auto xShape(getShape(1)); + // Without the accompanying fix in place, this test would have failed with + // 'Unknown property: RotateAngle', i.e. export lost the rotation, and then + // import created a Writer picture (instead of a Draw one). + CPPUNIT_ASSERT_DOUBLES_EQUAL(4700.0, getProperty(xShape, "RotateAngle"), 10); +} + +DECLARE_RTFEXPORT_TEST(testTdf133437, "tdf133437.rtf") +{ + CPPUNIT_ASSERT_EQUAL(3, getPages()); + CPPUNIT_ASSERT_EQUAL(560, getShapes()); // 285 \shp + 275 \poswX + + xmlDocUniquePtr pDump = parseLayoutDump(); + // Count shapes on first page + assertXPath(pDump, "/root/page[1]/body/txt[1]/anchored/SwAnchoredDrawObject"_ostr, 79); + + // Second page + assertXPath(pDump, "/root/page[2]/body/txt[2]/anchored/SwAnchoredDrawObject"_ostr, 120); + + // Third page + assertXPath(pDump, "/root/page[3]/body/txt[2]/anchored/SwAnchoredDrawObject"_ostr, 86); +} + +CPPUNIT_TEST_FIXTURE(Test, testTdf128320) +{ + loadAndReload("tdf128320.odt"); + CPPUNIT_ASSERT_EQUAL(1, getShapes()); + CPPUNIT_ASSERT_EQUAL(1, getPages()); + // Shape does exist in RTF output + auto xShape(getShape(1)); + CPPUNIT_ASSERT(xShape.is()); + + // Let's see what is inside output RTF file + SvStream* pStream = maTempFile.GetStream(StreamMode::READ); + CPPUNIT_ASSERT(pStream); + OString aRtfContent(read_uInt8s_ToOString(*pStream, pStream->TellEnd())); + + // There are some RTF tokens for shape props + // They are much more inside, but let's use \shpwr2 as an indicator + sal_Int32 nPos = aRtfContent.indexOf("\\shpwr2", 0); + CPPUNIT_ASSERT(nPos > 0); + + // It goes AFTER shape instruction (sadly here we do not check if it is contained inside) + sal_Int32 nPosShp = aRtfContent.indexOf("\\shpinst", 0); + CPPUNIT_ASSERT(nPosShp > 0); + + // But there are no more shape properties! + nPos = aRtfContent.indexOf("\\shpwr2", nPos + 1); + CPPUNIT_ASSERT_EQUAL(sal_Int32(-1), nPos); +} + +DECLARE_RTFEXPORT_TEST(testTdf129513, "tdf129513.rtf") +{ + // \pagebb after \intbl must not reset the "in table" flag + CPPUNIT_ASSERT_EQUAL(2, getParagraphs()); + // Make sure the first paragraph is imported in table + uno::Reference xTable(getParagraphOrTable(1), uno::UNO_QUERY_THROW); + CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTable->getCellNames().getLength()); + uno::Reference xCell(xTable->getCellByName("A1"), uno::UNO_QUERY_THROW); + CPPUNIT_ASSERT_EQUAL(OUString("In table"), xCell->getString()); +} + +DECLARE_RTFEXPORT_TEST(testTdf138210, "tdf138210.rtf") +{ + uno::Reference xTextFramesSupplier(mxComponent, uno::UNO_QUERY); + uno::Reference xIndexAccess(xTextFramesSupplier->getTextFrames(), + uno::UNO_QUERY); + CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount()); +} + +CPPUNIT_TEST_FIXTURE(Test, testTdf137894) +{ + loadAndReload("tdf137894.odt"); + CPPUNIT_ASSERT_EQUAL(1, getPages()); + lang::Locale locale1(getProperty(getRun(getParagraph(1), 1), "CharLocaleAsian")); + CPPUNIT_ASSERT_EQUAL(OUString("ja"), locale1.Language); + CPPUNIT_ASSERT_EQUAL(OUString("MS UI Gothic"), + getProperty(getRun(getParagraph(1), 1), "CharFontNameAsian")); + CPPUNIT_ASSERT_EQUAL(20.f, getProperty(getRun(getParagraph(1), 1), "CharHeightAsian")); + CPPUNIT_ASSERT_EQUAL(OUString("Mangal"), + getProperty(getRun(getParagraph(1), 1), "CharFontNameComplex")); + CPPUNIT_ASSERT_EQUAL(20.f, getProperty(getRun(getParagraph(1), 1), "CharHeightComplex")); + lang::Locale locale2( + getProperty(getRun(getParagraph(2), 1), "CharLocaleComplex")); + CPPUNIT_ASSERT_EQUAL(OUString("he"), locale2.Language); + CPPUNIT_ASSERT_EQUAL(32.f, getProperty(getRun(getParagraph(2), 1), "CharHeightComplex")); +} + +CPPUNIT_TEST_FIXTURE(Test, testTdf138779) +{ + loadAndReload("tdf138779.docx"); + // The text "2. Kozuka Mincho Pro, 8 pt Ruby ..." has font size 11pt ( was 20pt ). + CPPUNIT_ASSERT_EQUAL(11.f, getProperty(getRun(getParagraph(2), 14), "CharHeight")); +} + +CPPUNIT_TEST_FIXTURE(Test, testTdf144437) +{ + loadAndReload("tdf144437.odt"); + SvStream* pStream = maTempFile.GetStream(StreamMode::READ); + CPPUNIT_ASSERT(pStream); + OString aRtfContent(read_uInt8s_ToOString(*pStream, pStream->TellEnd())); + + sal_Int32 nTextEndPos = aRtfContent.indexOf("Bookmark here->", 0) + 14; + CPPUNIT_ASSERT_MESSAGE("Para content wasn't found in file", nTextEndPos > 0); + + sal_Int32 nBmkStartPos = aRtfContent.indexOf("{\\*\\bkmkstart bookmark}", 0); + CPPUNIT_ASSERT_MESSAGE("Bookmark start wasn't found in file", nBmkStartPos > 0); + + sal_Int32 nBmkEndPos = aRtfContent.indexOf("{\\*\\bkmkend bookmark}", 0); + CPPUNIT_ASSERT_MESSAGE("Bookmark end wasn't found in file", nBmkEndPos > 0); + + CPPUNIT_ASSERT_MESSAGE("Bookmark started in wrong position", nBmkStartPos > nTextEndPos); + CPPUNIT_ASSERT_MESSAGE("Bookmark ended in wrong position", nBmkEndPos > nTextEndPos); + CPPUNIT_ASSERT_MESSAGE("Bookmark start & end are wrong", nBmkEndPos > nBmkStartPos); +} + +DECLARE_RTFEXPORT_TEST(testTdf131234, "tdf131234.rtf") +{ + uno::Reference xRun = getRun(getParagraph(1), 1, u"Hello"_ustr); + + // Ensure that text has default font attrs in spite of style referenced + // E.g. 12pt, Times New Roman, black, no bold, no italic, no underline + CPPUNIT_ASSERT_EQUAL(12.f, getProperty(xRun, "CharHeight")); + CPPUNIT_ASSERT_EQUAL(COL_BLACK, getProperty(xRun, "CharColor")); + CPPUNIT_ASSERT_EQUAL(OUString("Times New Roman"), getProperty(xRun, "CharFontName")); + CPPUNIT_ASSERT_EQUAL(awt::FontWeight::NORMAL, getProperty(xRun, "CharWeight")); + CPPUNIT_ASSERT_EQUAL(awt::FontUnderline::NONE, getProperty(xRun, "CharUnderline")); + CPPUNIT_ASSERT_EQUAL(awt::FontSlant_NONE, getProperty(xRun, "CharPosture")); +} + +DECLARE_RTFEXPORT_TEST(testTdf118047, "tdf118047.rtf") +{ + uno::Reference xPara = getParagraph(1); + + // Ensure that default "Normal" style properties are not applied to text: + // text remains with fontsize 12pt and no huge margin below + CPPUNIT_ASSERT_EQUAL(12.f, getProperty(getRun(xPara, 1), "CharHeight")); + CPPUNIT_ASSERT_EQUAL(sal_Int32(0), getProperty(getParagraph(1), "ParaBottomMargin")); + + // Same for header, it should not derive props from "Normal" style + CPPUNIT_ASSERT_EQUAL(OUString("Header"), parseDump("/root/page[1]/header/txt/text()"_ostr)); + sal_Int32 nHeight + = parseDump("/root/page[1]/header/infos/bounds"_ostr, "height"_ostr).toInt32(); + CPPUNIT_ASSERT_MESSAGE("Header is too large", 1000 > nHeight); +} + +DECLARE_RTFEXPORT_TEST(testTdf104390, "tdf104390.rtf") +{ + uno::Reference xPara = getParagraph(1); + uno::Reference xRunEnumAccess(xPara, uno::UNO_QUERY); + uno::Reference xRunEnum = xRunEnumAccess->createEnumeration(); + + // Check font in first run + uno::Reference xRun(xRunEnum->nextElement(), uno::UNO_QUERY); + CPPUNIT_ASSERT_EQUAL(36.f, getProperty(xRun, "CharHeight")); + CPPUNIT_ASSERT_EQUAL(OUString("Courier New"), getProperty(xRun, "CharFontName")); + + // Ensure this run covers whole paragraph text (ignore possible empty "paragraph marker" run) + CPPUNIT_ASSERT_EQUAL(xPara->getString().getLength(), xRun->getString().getLength()); +} + +DECLARE_RTFEXPORT_TEST(testTdf153681, "tdf153681.odt") +{ + uno::Reference xTablesSupplier(mxComponent, uno::UNO_QUERY_THROW); + uno::Reference xTables(xTablesSupplier->getTextTables(), + uno::UNO_QUERY_THROW); + + // This is outside table + uno::Reference xTable(xTables->getByIndex(1), uno::UNO_QUERY_THROW); + // Without the accompanying fix in place, this test would have failed with: + // - Expected: 2 + // - Actual : 3 + // Generates extra cell + CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTable->getRows()->getCount()); + CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTable->getColumns()->getCount()); +} + +CPPUNIT_PLUGIN_IMPLEMENT(); + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3