diff options
Diffstat (limited to 'sc/qa/unit/subsequent_export-test.cxx')
| -rw-r--r-- | sc/qa/unit/subsequent_export-test.cxx | 5210 |
1 files changed, 5210 insertions, 0 deletions
diff --git a/sc/qa/unit/subsequent_export-test.cxx b/sc/qa/unit/subsequent_export-test.cxx new file mode 100644 index 000000000..9647d0964 --- /dev/null +++ b/sc/qa/unit/subsequent_export-test.cxx @@ -0,0 +1,5210 @@ +/* -*- 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 <sal/config.h> +#include <config_features.h> + +#include <sfx2/docfile.hxx> +#include <sfx2/frame.hxx> +#include <sfx2/sfxmodelfactory.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/docfilt.hxx> + +#include "helper/debughelper.hxx" +#include "helper/qahelper.hxx" +#include "helper/xpath.hxx" +#include "helper/shared_test_impl.hxx" + +#include <userdat.hxx> +#include <docsh.hxx> +#include <patattr.hxx> +#include <docpool.hxx> +#include <scitems.hxx> +#include <attrib.hxx> +#include <stlpool.hxx> +#include <document.hxx> +#include <formulacell.hxx> +#include <tokenarray.hxx> +#include <editutil.hxx> +#include <scopetools.hxx> +#include <cellvalue.hxx> +#include <postit.hxx> +#include <tokenstringcontext.hxx> +#include <chgtrack.hxx> +#include <validat.hxx> +#include <global.hxx> +#include <scmod.hxx> +#include <dpcache.hxx> +#include <dpobject.hxx> +#include <clipparam.hxx> + +#include <svx/svdpage.hxx> +#include <svx/svdograf.hxx> +#include <tabprotection.hxx> +#include <editeng/wghtitem.hxx> +#include <editeng/postitem.hxx> +#include <editeng/editdata.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/editobj.hxx> +#include <editeng/section.hxx> +#include <editeng/crossedoutitem.hxx> +#include <editeng/borderline.hxx> +#include <editeng/escapementitem.hxx> +#include <editeng/fontitem.hxx> +#include <editeng/udlnitem.hxx> +#include <editeng/flditem.hxx> +#include <editeng/colritem.hxx> +#include <formula/grammar.hxx> +#include <unotools/useroptions.hxx> +#include <comphelper/scopeguard.hxx> +#include <unotools/syslocaleoptions.hxx> +#include <tools/datetime.hxx> +#include <tools/fldunit.hxx> +#include <svl/zformat.hxx> + +#include <test/xmltesttools.hxx> +#include <com/sun/star/drawing/XDrawPageSupplier.hpp> +#include <com/sun/star/awt/XBitmap.hpp> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/graphic/GraphicType.hpp> +#include <com/sun/star/sheet/GlobalSheetSettings.hpp> +#include <comphelper/storagehelper.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +class ScExportTest : public ScBootstrapFixture, public XmlTestTools +{ +protected: + virtual void registerNamespaces(xmlXPathContextPtr& pXmlXPathCtx) override; +public: + ScExportTest(); + + virtual void setUp() override; + virtual void tearDown() override; + + ScDocShellRef saveAndReloadPassword( ScDocShell*, const OUString&, const OUString&, const OUString&, SfxFilterFlags ); + + void test(); + void testTdf111876(); + void testPasswordExportODS(); + void testTdf134332(); + void testConditionalFormatExportODS(); + void testConditionalFormatExportXLSX(); + void testCondFormatExportCellIs(); + void testTdf99856_dataValidationTest(); + void testProtectionKeyODS_UTF16LErtlSHA1(); + void testProtectionKeyODS_UTF8SHA1(); + void testProtectionKeyODS_UTF8SHA256ODF12(); + void testProtectionKeyODS_UTF8SHA256W3C(); + void testProtectionKeyODS_XL_SHA1(); + void testColorScaleExportODS(); + void testColorScaleExportXLSX(); + void testDataBarExportODS(); + void testDataBarExportXLSX(); + void testConditionalFormatRangeListXLSX(); + void testConditionalFormatContainsTextXLSX(); + void testConditionalFormatPriorityCheckXLSX(); + void testConditionalFormatOriginXLSX(); + void testMiscRowHeightExport(); + void testNamedRangeBugfdo62729(); + void testBuiltinRangesXLSX(); + void testRichTextExportODS(); + void testRichTextCellFormatXLSX(); + void testFormulaRefSheetNameODS(); + + void testCellValuesExportODS(); + void testCellNoteExportODS(); + void testCellNoteExportXLS(); + void testFormatExportODS(); + + void testCommentExportXLSX(); + void testCommentExportXLSX_2_XLSX(); +#if HAVE_MORE_FONTS + void testCustomColumnWidthExportXLSX(); +#endif + void testXfDefaultValuesXLSX(); + void testODF13(); + void testColumnWidthResaveXLSX(); +#if HAVE_MORE_FONTS + void testColumnWidthExportFromODStoXLSX(); +#endif + void testOutlineExportXLSX(); + void testHiddenEmptyRowsXLSX(); + void testAllRowsHiddenXLSX(); + void testLandscapeOrientationXLSX(); + + void testInlineArrayXLS(); + void testEmbeddedChartODS(); + void testEmbeddedChartXLS(); + void testCellAnchoredGroupXLS(); + + void testFormulaReferenceXLS(); + void testSheetProtectionXLSX(); + void testSheetProtectionXLSB(); + + void testCellBordersXLS(); + void testCellBordersXLSX(); + void testBordersExchangeXLSX(); + void testTrackChangesSimpleXLSX(); + void testSheetTabColorsXLSX(); + + void testSharedFormulaExportXLS(); + void testSharedFormulaExportXLSX(); + void testSharedFormulaStringResultExportXLSX(); + + void testFunctionsExcel2010( sal_uLong nFormatType ); + void testFunctionsExcel2010XLSX(); + void testFunctionsExcel2010XLS(); + void testFunctionsExcel2010ODS(); + + void testCeilingFloor( sal_uLong nFormatType ); + void testCeilingFloorXLSX(); + void testCeilingFloorODSToXLSX(); + void testCeilingFloorXLS(); + void testCeilingFloorODS(); + + void testCustomXml(); + + void testRelativePathsODS(); + void testSheetProtectionODS(); + + void testSwappedOutImageExport(); + void testLinkedGraphicRT(); + void testImageWithSpecialID(); + + void testSupBookVirtualPathXLS(); + void testAbsNamedRangeHTML(); + void testSheetLocalRangeNameXLS(); + void testRelativeNamedExpressionsXLS(); + void testSheetTextBoxHyperlinkXLSX(); + void testFontSizeXLSX(); + void testSheetCharacterKerningSpaceXLSX(); + void testSheetCondensedCharacterSpaceXLSX(); + void testTextUnderlineColorXLSX(); + void testSheetRunParagraphPropertyXLSX(); + void testHiddenShapeXLS(); + void testHiddenShapeXLSX(); + void testShapeAutofitXLSX(); + void testHyperlinkXLSX(); + void testMoveCellAnchoredShapesODS(); + void testMatrixMultiplicationXLSX(); + void testPreserveTextWhitespaceXLSX(); + void testPreserveTextWhitespace2XLSX(); + void testTextDirectionXLSX(); + void testTdf66668(); + void testTdf130108(); + void testTdf76949(); + void testTdf55417(); + void testTdf129985(); + void testTdf73063(); + + xmlDocUniquePtr testTdf95640(const OUString& rFileName, sal_Int32 nSourceFormat, + sal_Int32 nDestFormat); + void testTdf95640_ods_to_xlsx(); + void testTdf95640_ods_to_xlsx_with_standard_list(); + void testTdf95640_xlsx_to_xlsx(); + + void testRefStringXLSX(); + void testRefStringConfigXLSX(); + void testRefStringUnspecified(); + void testHeaderImageODS(); + + void testTdf88657ODS(); + void testTdf41722(); + void testTdf113621(); + void testEscapeCharInNumberFormatXLSX(); + void testNatNumInNumberFormatXLSX(); + void testExponentWithoutSignFormatXLSX(); + void testExtendedLCIDXLSX(); + + void testHiddenRepeatedRowsODS(); + void testHyperlinkTargetFrameODS(); + void testOpenDocumentAsReadOnly(); + void testKeepSettingsOfBlankRows(); + + void testTdf105272(); + void testTdf118990(); + void testTdf121612(); + void testTdf112936(); + void testPivotCacheAfterExportXLSX(); + void testTdf114969XLSX(); + void testTdf115192XLSX(); + void testTdf91634XLSX(); + void testTdf115159(); + void testTdf112567(); + void testTdf112567b(); + void testTdf123645XLSX(); + void testTdf125173XLSX(); + void testTdf79972XLSX(); + void testTdf126024XLSX(); + void testTdf126177XLSX(); + void testCommentTextVAlignment(); + void testCommentTextHAlignment(); + void testValidationCopyPaste(); + + void testXltxExport(); + void testRotatedImageODS(); + void testTdf128976(); + void testTdf120502(); + void testTdf131372(); + void testTdf122331(); + void testTdf83779(); + void testTdf134817_HeaderFooterTextWith2SectionXLSX(); + + CPPUNIT_TEST_SUITE(ScExportTest); + CPPUNIT_TEST(test); + CPPUNIT_TEST(testTdf111876); + CPPUNIT_TEST(testPasswordExportODS); + CPPUNIT_TEST(testTdf134332); + CPPUNIT_TEST(testConditionalFormatExportODS); + CPPUNIT_TEST(testCondFormatExportCellIs); + CPPUNIT_TEST(testConditionalFormatExportXLSX); + CPPUNIT_TEST(testTdf99856_dataValidationTest); + CPPUNIT_TEST(testProtectionKeyODS_UTF16LErtlSHA1); + CPPUNIT_TEST(testProtectionKeyODS_UTF8SHA1); + CPPUNIT_TEST(testProtectionKeyODS_UTF8SHA256ODF12); + CPPUNIT_TEST(testProtectionKeyODS_UTF8SHA256W3C); + CPPUNIT_TEST(testProtectionKeyODS_XL_SHA1); + CPPUNIT_TEST(testColorScaleExportODS); + CPPUNIT_TEST(testColorScaleExportXLSX); + CPPUNIT_TEST(testDataBarExportODS); + CPPUNIT_TEST(testDataBarExportXLSX); + CPPUNIT_TEST(testConditionalFormatRangeListXLSX); + CPPUNIT_TEST(testConditionalFormatContainsTextXLSX); + CPPUNIT_TEST(testConditionalFormatPriorityCheckXLSX); + CPPUNIT_TEST(testConditionalFormatOriginXLSX); + CPPUNIT_TEST(testMiscRowHeightExport); + CPPUNIT_TEST(testNamedRangeBugfdo62729); + CPPUNIT_TEST(testBuiltinRangesXLSX); + CPPUNIT_TEST(testRichTextExportODS); + CPPUNIT_TEST(testRichTextCellFormatXLSX); + CPPUNIT_TEST(testFormulaRefSheetNameODS); + CPPUNIT_TEST(testCellValuesExportODS); + CPPUNIT_TEST(testCellNoteExportODS); + CPPUNIT_TEST(testCellNoteExportXLS); + CPPUNIT_TEST(testFormatExportODS); + CPPUNIT_TEST(testCommentExportXLSX); + CPPUNIT_TEST(testCommentExportXLSX_2_XLSX); +#if HAVE_MORE_FONTS + CPPUNIT_TEST(testCustomColumnWidthExportXLSX); +#endif + CPPUNIT_TEST(testXfDefaultValuesXLSX); + CPPUNIT_TEST(testODF13); + CPPUNIT_TEST(testColumnWidthResaveXLSX); +#if HAVE_MORE_FONTS + CPPUNIT_TEST(testColumnWidthExportFromODStoXLSX); +#endif + CPPUNIT_TEST(testOutlineExportXLSX); + CPPUNIT_TEST(testHiddenEmptyRowsXLSX); + CPPUNIT_TEST(testAllRowsHiddenXLSX); + CPPUNIT_TEST(testLandscapeOrientationXLSX); + CPPUNIT_TEST(testInlineArrayXLS); + CPPUNIT_TEST(testEmbeddedChartODS); + CPPUNIT_TEST(testEmbeddedChartXLS); + CPPUNIT_TEST(testCellAnchoredGroupXLS); + + CPPUNIT_TEST(testFormulaReferenceXLS); + CPPUNIT_TEST(testSheetProtectionXLSX); + CPPUNIT_TEST(testSheetProtectionXLSB); + CPPUNIT_TEST(testCellBordersXLS); + CPPUNIT_TEST(testCellBordersXLSX); + CPPUNIT_TEST(testBordersExchangeXLSX); + CPPUNIT_TEST(testTrackChangesSimpleXLSX); + CPPUNIT_TEST(testSheetTabColorsXLSX); + CPPUNIT_TEST(testSharedFormulaExportXLS); + CPPUNIT_TEST(testSharedFormulaExportXLSX); + CPPUNIT_TEST(testSharedFormulaStringResultExportXLSX); + CPPUNIT_TEST(testFunctionsExcel2010XLSX); + CPPUNIT_TEST(testFunctionsExcel2010XLS); + CPPUNIT_TEST(testFunctionsExcel2010ODS); + CPPUNIT_TEST(testCeilingFloorXLSX); + CPPUNIT_TEST(testCeilingFloorODSToXLSX); + CPPUNIT_TEST(testCeilingFloorXLS); + CPPUNIT_TEST(testCeilingFloorODS); + CPPUNIT_TEST(testCustomXml); + CPPUNIT_TEST(testRelativePathsODS); + CPPUNIT_TEST(testSheetProtectionODS); + CPPUNIT_TEST(testSupBookVirtualPathXLS); + CPPUNIT_TEST(testSwappedOutImageExport); + CPPUNIT_TEST(testLinkedGraphicRT); + CPPUNIT_TEST(testImageWithSpecialID); + CPPUNIT_TEST(testPreserveTextWhitespaceXLSX); + CPPUNIT_TEST(testPreserveTextWhitespace2XLSX); + CPPUNIT_TEST(testAbsNamedRangeHTML); + CPPUNIT_TEST(testSheetLocalRangeNameXLS); + CPPUNIT_TEST(testRelativeNamedExpressionsXLS); + CPPUNIT_TEST(testSheetTextBoxHyperlinkXLSX); + CPPUNIT_TEST(testFontSizeXLSX); + CPPUNIT_TEST(testSheetCharacterKerningSpaceXLSX); + CPPUNIT_TEST(testSheetCondensedCharacterSpaceXLSX); + CPPUNIT_TEST(testTextUnderlineColorXLSX); + CPPUNIT_TEST(testSheetRunParagraphPropertyXLSX); + CPPUNIT_TEST(testHiddenShapeXLS); + CPPUNIT_TEST(testHiddenShapeXLSX); + CPPUNIT_TEST(testShapeAutofitXLSX); + CPPUNIT_TEST(testHyperlinkXLSX); + CPPUNIT_TEST(testMoveCellAnchoredShapesODS); + CPPUNIT_TEST(testMatrixMultiplicationXLSX); + CPPUNIT_TEST(testTextDirectionXLSX); + CPPUNIT_TEST(testTdf66668); + CPPUNIT_TEST(testTdf130108); + CPPUNIT_TEST(testTdf76949); + CPPUNIT_TEST(testTdf55417); + CPPUNIT_TEST(testTdf129985); + CPPUNIT_TEST(testTdf73063); + CPPUNIT_TEST(testTdf95640_ods_to_xlsx); + CPPUNIT_TEST(testTdf95640_ods_to_xlsx_with_standard_list); + CPPUNIT_TEST(testTdf95640_xlsx_to_xlsx); + + CPPUNIT_TEST(testRefStringXLSX); + CPPUNIT_TEST(testRefStringConfigXLSX); + CPPUNIT_TEST(testRefStringUnspecified); + CPPUNIT_TEST(testHeaderImageODS); + + CPPUNIT_TEST(testTdf88657ODS); + CPPUNIT_TEST(testTdf41722); + CPPUNIT_TEST(testTdf113621); + CPPUNIT_TEST(testEscapeCharInNumberFormatXLSX); + CPPUNIT_TEST(testNatNumInNumberFormatXLSX); + CPPUNIT_TEST(testExponentWithoutSignFormatXLSX); + CPPUNIT_TEST(testExtendedLCIDXLSX); + + CPPUNIT_TEST(testHiddenRepeatedRowsODS); + CPPUNIT_TEST(testHyperlinkTargetFrameODS); + CPPUNIT_TEST(testOpenDocumentAsReadOnly); + CPPUNIT_TEST(testKeepSettingsOfBlankRows); + + CPPUNIT_TEST(testTdf105272); + CPPUNIT_TEST(testTdf118990); + CPPUNIT_TEST(testTdf121612); + CPPUNIT_TEST(testTdf112936); + CPPUNIT_TEST(testPivotCacheAfterExportXLSX); + CPPUNIT_TEST(testTdf114969XLSX); + CPPUNIT_TEST(testTdf115192XLSX); + CPPUNIT_TEST(testTdf91634XLSX); + CPPUNIT_TEST(testTdf115159); + CPPUNIT_TEST(testTdf112567); + CPPUNIT_TEST(testTdf112567b); + CPPUNIT_TEST(testTdf123645XLSX); + CPPUNIT_TEST(testTdf125173XLSX); + CPPUNIT_TEST(testTdf79972XLSX); + CPPUNIT_TEST(testTdf126024XLSX); + CPPUNIT_TEST(testTdf126177XLSX); + CPPUNIT_TEST(testCommentTextVAlignment); + CPPUNIT_TEST(testCommentTextHAlignment); + CPPUNIT_TEST(testValidationCopyPaste); + + CPPUNIT_TEST(testXltxExport); + CPPUNIT_TEST(testRotatedImageODS); + CPPUNIT_TEST(testTdf128976); + CPPUNIT_TEST(testTdf120502); + CPPUNIT_TEST(testTdf131372); + CPPUNIT_TEST(testTdf122331); + CPPUNIT_TEST(testTdf83779); + CPPUNIT_TEST(testTdf134817_HeaderFooterTextWith2SectionXLSX); + + CPPUNIT_TEST_SUITE_END(); + +private: + void testExcelCellBorders( sal_uLong nFormatType ); + + uno::Reference<uno::XInterface> m_xCalcComponent; + +}; + +void ScExportTest::registerNamespaces(xmlXPathContextPtr& pXmlXPathCtx) +{ + static const struct { xmlChar* pPrefix; xmlChar* pURI; } aNamespaces[] = + { + { BAD_CAST("w"), BAD_CAST("http://schemas.openxmlformats.org/wordprocessingml/2006/main") }, + { BAD_CAST("x"), BAD_CAST("http://schemas.openxmlformats.org/spreadsheetml/2006/main") }, + { BAD_CAST("v"), BAD_CAST("urn:schemas-microsoft-com:vml") }, + { BAD_CAST("c"), BAD_CAST("http://schemas.openxmlformats.org/drawingml/2006/chart") }, + { BAD_CAST("a"), BAD_CAST("http://schemas.openxmlformats.org/drawingml/2006/main") }, + { BAD_CAST("mc"), BAD_CAST("http://schemas.openxmlformats.org/markup-compatibility/2006") }, + { BAD_CAST("wps"), BAD_CAST("http://schemas.microsoft.com/office/word/2010/wordprocessingShape") }, + { BAD_CAST("wpg"), BAD_CAST("http://schemas.microsoft.com/office/word/2010/wordprocessingGroup") }, + { BAD_CAST("wp"), BAD_CAST("http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing") }, + { BAD_CAST("office"), BAD_CAST("urn:oasis:names:tc:opendocument:xmlns:office:1.0") }, + { BAD_CAST("table"), BAD_CAST("urn:oasis:names:tc:opendocument:xmlns:table:1.0") }, + { BAD_CAST("text"), BAD_CAST("urn:oasis:names:tc:opendocument:xmlns:text:1.0") }, + { BAD_CAST("style"), BAD_CAST("urn:oasis:names:tc:opendocument:xmlns:style:1.0") }, + { BAD_CAST("draw"), BAD_CAST("urn:oasis:names:tc:opendocument:xmlns:drawing:1.0") }, + { BAD_CAST("xlink"), BAD_CAST("http://www.w3c.org/1999/xlink") }, + { BAD_CAST("xdr"), BAD_CAST("http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing") }, + { BAD_CAST("xx"), BAD_CAST("urn:schemas-microsoft-com:office:excel") }, + { BAD_CAST("r"), BAD_CAST("http://schemas.openxmlformats.org/package/2006/relationships") }, + { BAD_CAST("number"), BAD_CAST("urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0") }, + { BAD_CAST("loext"), BAD_CAST("urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0") }, + { BAD_CAST("tableooo"), BAD_CAST("http://openoffice.org/2009/table") }, + { BAD_CAST("ContentType"), BAD_CAST("http://schemas.openxmlformats.org/package/2006/content-types") }, + { BAD_CAST("x14"), BAD_CAST("http://schemas.microsoft.com/office/spreadsheetml/2009/9/main") }, + { BAD_CAST("xm"), BAD_CAST("http://schemas.microsoft.com/office/excel/2006/main") }, + }; + for(size_t i = 0; i < SAL_N_ELEMENTS(aNamespaces); ++i) + { + xmlXPathRegisterNs(pXmlXPathCtx, aNamespaces[i].pPrefix, aNamespaces[i].pURI ); + } +} + +ScDocShellRef ScExportTest::saveAndReloadPassword(ScDocShell* pShell, const OUString &rFilter, + const OUString &rUserData, const OUString& rTypeName, SfxFilterFlags nFormatType) +{ + utl::TempFile aTempFile; + aTempFile.EnableKillingFile(); + SfxMedium aStoreMedium( aTempFile.GetURL(), StreamMode::STD_WRITE ); + SotClipboardFormatId nExportFormat = SotClipboardFormatId::NONE; + if (nFormatType == ODS_FORMAT_TYPE) + nExportFormat = SotClipboardFormatId::STARCHART_8; + auto pExportFilter = std::make_shared<SfxFilter>( + rFilter, + OUString(), nFormatType, nExportFormat, rTypeName, OUString(), + rUserData, "private:factory/scalc*" ); + pExportFilter->SetVersion(SOFFICE_FILEFORMAT_CURRENT); + aStoreMedium.SetFilter(pExportFilter); + SfxItemSet* pExportSet = aStoreMedium.GetItemSet(); + uno::Sequence< beans::NamedValue > aEncryptionData = comphelper::OStorageHelper::CreatePackageEncryptionData( "test" ); + pExportSet->Put(SfxUnoAnyItem(SID_ENCRYPTIONDATA, makeAny(aEncryptionData))); + + uno::Reference< embed::XStorage > xMedStorage = aStoreMedium.GetStorage(); + ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( xMedStorage, aEncryptionData ); + + pShell->DoSaveAs( aStoreMedium ); + pShell->DoClose(); + + //std::cout << "File: " << aTempFile.GetURL() << std::endl; + + SotClipboardFormatId nFormat = SotClipboardFormatId::NONE; + if (nFormatType == ODS_FORMAT_TYPE) + nFormat = SotClipboardFormatId::STARCALC_8; + + OUString aPass("test"); + return load(aTempFile.GetURL(), rFilter, rUserData, rTypeName, nFormatType, nFormat, SOFFICE_FILEFORMAT_CURRENT, &aPass); +} + +void ScExportTest::test() +{ + ScDocShell* pShell = new ScDocShell( + SfxModelFlags::EMBEDDED_OBJECT | + SfxModelFlags::DISABLE_EMBEDDED_SCRIPTS | + SfxModelFlags::DISABLE_DOCUMENT_RECOVERY); + pShell->DoInitNew(); + + ScDocument& rDoc = pShell->GetDocument(); + + rDoc.SetValue(0,0,0, 1.0); + + ScDocShellRef xDocSh = saveAndReload(pShell, FORMAT_ODS); + + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument& rLoadedDoc = xDocSh->GetDocument(); + double aVal = rLoadedDoc.GetValue(0,0,0); + ASSERT_DOUBLES_EQUAL(aVal, 1.0); + xDocSh->DoClose(); +} + +void ScExportTest::testTdf111876() + { + // Document with relative path hyperlink + + ScDocShellRef xShell = loadDoc("tdf111876.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/_rels/sheet1.xml.rels", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + OUString sTarget = getXPath(pDoc, "/r:Relationships/r:Relationship", "Target"); + + // Document is saved to the temporary directory, relative path should be different than original one + CPPUNIT_ASSERT(sTarget != "../xls/bug-fixes.xls"); + + xDocSh->DoClose(); +} + +void ScExportTest::testPasswordExportODS() +{ + ScDocShell* pShell = new ScDocShell( + SfxModelFlags::EMBEDDED_OBJECT | + SfxModelFlags::DISABLE_EMBEDDED_SCRIPTS | + SfxModelFlags::DISABLE_DOCUMENT_RECOVERY); + pShell->DoInitNew(); + + ScDocument& rDoc = pShell->GetDocument(); + + rDoc.SetValue(0, 0, 0, 1.0); + + sal_Int32 nFormat = FORMAT_ODS; + OUString aFilterName(getFileFormats()[nFormat].pFilterName, strlen(getFileFormats()[nFormat].pFilterName), RTL_TEXTENCODING_UTF8) ; + OUString aFilterType(getFileFormats()[nFormat].pTypeName, strlen(getFileFormats()[nFormat].pTypeName), RTL_TEXTENCODING_UTF8); + ScDocShellRef xDocSh = saveAndReloadPassword(pShell, aFilterName, OUString(), aFilterType, getFileFormats()[nFormat].nFormatType); + + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument& rLoadedDoc = xDocSh->GetDocument(); + double aVal = rLoadedDoc.GetValue(0,0,0); + ASSERT_DOUBLES_EQUAL(aVal, 1.0); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf134332() +{ + ScDocShellRef xShell = loadDoc("tdf134332.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocument& rDoc = xShell->GetDocument(); + + ASSERT_DOUBLES_EQUAL(190.0, rDoc.GetValue(ScAddress(0,0,0))); + + ASSERT_DOUBLES_EQUAL(238.0, rDoc.GetValue(ScAddress(0,10144,0))); + + sal_Int32 nFormat = FORMAT_ODS; + OUString aFilterName(getFileFormats()[nFormat].pFilterName, strlen(getFileFormats()[nFormat].pFilterName), RTL_TEXTENCODING_UTF8) ; + OUString aFilterType(getFileFormats()[nFormat].pTypeName, strlen(getFileFormats()[nFormat].pTypeName), RTL_TEXTENCODING_UTF8); + ScDocShellRef xDocSh = saveAndReloadPassword(static_cast<ScDocShell*>(rDoc.GetDocumentShell()), aFilterName, OUString(), + aFilterType, getFileFormats()[nFormat].nFormatType); + + // Without the fixes in place, it would have failed here + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument& rLoadedDoc = xDocSh->GetDocument(); + ASSERT_DOUBLES_EQUAL(190.0, rLoadedDoc.GetValue(ScAddress(0,0,0))); + + ASSERT_DOUBLES_EQUAL(238.0, rLoadedDoc.GetValue(ScAddress(0,10144,0))); + + xDocSh->DoClose(); +} + +void ScExportTest::testConditionalFormatExportODS() +{ + ScDocShellRef xShell = loadDoc("new_cond_format_test_export.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument& rDoc = xDocSh->GetDocument(); + OUString aCSVPath; + createCSVPath( "new_cond_format_test_export.", aCSVPath ); + testCondFile(aCSVPath, &rDoc, 0); + + xDocSh->DoClose(); +} + +void ScExportTest::testCondFormatExportCellIs() +{ + ScDocShellRef xShell = loadDoc("condFormat_cellis.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + CPPUNIT_ASSERT_EQUAL(size_t(1), rDoc.GetCondFormList(0)->size()); + + ScConditionalFormat* pFormat = rDoc.GetCondFormat(0, 0, 0); + CPPUNIT_ASSERT(pFormat); + + const ScFormatEntry* pEntry = pFormat->GetEntry(0); + CPPUNIT_ASSERT(pEntry); + CPPUNIT_ASSERT_EQUAL(ScFormatEntry::Type::ExtCondition, pEntry->GetType()); + + const ScCondFormatEntry* pCondition = static_cast<const ScCondFormatEntry*>(pEntry); + CPPUNIT_ASSERT_EQUAL( ScConditionMode::Equal, pCondition->GetOperation()); + + OUString aStr = pCondition->GetExpression(ScAddress(0, 0, 0), 0); + CPPUNIT_ASSERT_EQUAL( OUString("$Sheet2.$A$1"), aStr ); + + pEntry = pFormat->GetEntry(1); + CPPUNIT_ASSERT(pEntry); + CPPUNIT_ASSERT_EQUAL(ScFormatEntry::Type::ExtCondition, pEntry->GetType()); + + pCondition = static_cast<const ScCondFormatEntry*>(pEntry); + CPPUNIT_ASSERT_EQUAL( ScConditionMode::Equal, pCondition->GetOperation()); + + aStr = pCondition->GetExpression(ScAddress(0, 0, 0), 0); + CPPUNIT_ASSERT_EQUAL( OUString("$Sheet2.$A$2"), aStr ); + + xDocSh->DoClose(); +} + +void ScExportTest::testConditionalFormatExportXLSX() +{ + ScDocShellRef xShell = loadDoc("new_cond_format_test_export.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument& rDoc = xDocSh->GetDocument(); + { + OUString aCSVPath; + createCSVPath( "new_cond_format_test_export.", aCSVPath ); + testCondFile(aCSVPath, &rDoc, 0); + } + { + OUString aCSVPath; + createCSVPath( "new_cond_format_test_sheet2.", aCSVPath ); + testCondFile(aCSVPath, &rDoc, 1); + } + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf99856_dataValidationTest() +{ + ScDocShellRef xShell = loadDoc("tdf99856_dataValidationTest.", FORMAT_ODS); + CPPUNIT_ASSERT_MESSAGE("Failed to load doc", xShell.is()); + + ScDocShellRef xDocSh = saveAndReload( xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to reload doc", xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + const ScValidationData* pData = rDoc.GetValidationEntry(2); + CPPUNIT_ASSERT(pData); + + // Excel can't open corrupt file if the list is longer than 255 characters + std::vector<ScTypedStrData> aList; + pData->FillSelectionList(aList, ScAddress(0, 1, 1)); + CPPUNIT_ASSERT_EQUAL(size_t(18), aList.size()); + CPPUNIT_ASSERT_EQUAL(OUString("18 Missis"), aList[17].GetString()); + + xDocSh->DoClose(); +} + +void ScExportTest::testProtectionKeyODS_UTF16LErtlSHA1() +{ + OUString const password("1012345678901234567890123456789012345678901234567890"); + + ScDocShellRef xShell = loadDoc("protection-key1.", FORMAT_FODS); + CPPUNIT_ASSERT_MESSAGE("Failed to load doc", xShell.is()); + + ScDocument& rDoc = xShell->GetDocument(); + ScDocProtection *const pDocProt(rDoc.GetDocProtection()); + CPPUNIT_ASSERT(pDocProt->verifyPassword(password)); + ScTableProtection *const pTabProt(rDoc.GetTabProtection(0)); + CPPUNIT_ASSERT(pTabProt->verifyPassword(password)); + + // we can't assume that the user entered the password; check that we + // round-trip the password as-is + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_ODS); + xmlDocUniquePtr pXmlDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "content.xml"); + assertXPath(pXmlDoc, "//office:spreadsheet[@table:structure-protected='true' and @table:protection-key='vbnhxyBKtPHCA1wB21zG1Oha8ZA=' and @table:protection-key-digest-algorithm='http://www.w3.org/2000/09/xmldsig#sha1']"); + assertXPath(pXmlDoc, "//table:table[@table:protected='true' and @table:protection-key='vbnhxyBKtPHCA1wB21zG1Oha8ZA=' and @table:protection-key-digest-algorithm='http://www.w3.org/2000/09/xmldsig#sha1']"); + + xShell->DoClose(); +} + +void ScExportTest::testProtectionKeyODS_UTF8SHA1() +{ + OUString const password("1012345678901234567890123456789012345678901234567890"); + + ScDocShellRef xShell = loadDoc("protection-key2.", FORMAT_FODS); + CPPUNIT_ASSERT_MESSAGE("Failed to load doc", xShell.is()); + + ScDocument& rDoc = xShell->GetDocument(); + ScDocProtection *const pDocProt(rDoc.GetDocProtection()); + CPPUNIT_ASSERT(pDocProt->verifyPassword(password)); + ScTableProtection *const pTabProt(rDoc.GetTabProtection(0)); + CPPUNIT_ASSERT(pTabProt->verifyPassword(password)); + + // we can't assume that the user entered the password; check that we + // round-trip the password as-is + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_ODS); + xmlDocUniquePtr pXmlDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "content.xml"); + assertXPath(pXmlDoc, "//office:spreadsheet[@table:structure-protected='true' and @table:protection-key='nLHas0RIwepGDaH4c2hpyIUvIS8=' and @table:protection-key-digest-algorithm='http://www.w3.org/2000/09/xmldsig#sha1']"); + assertXPath(pXmlDoc, "//table:table[@table:protected='true' and @table:protection-key='nLHas0RIwepGDaH4c2hpyIUvIS8=' and @table:protection-key-digest-algorithm='http://www.w3.org/2000/09/xmldsig#sha1']"); + + xShell->DoClose(); +} + +void ScExportTest::testProtectionKeyODS_UTF8SHA256ODF12() +{ + OUString const password("1012345678901234567890123456789012345678901234567890"); + + ScDocShellRef xShell = loadDoc("protection-key3.", FORMAT_FODS); + CPPUNIT_ASSERT_MESSAGE("Failed to load doc", xShell.is()); + + ScDocument& rDoc = xShell->GetDocument(); + ScDocProtection *const pDocProt(rDoc.GetDocProtection()); + CPPUNIT_ASSERT(pDocProt->verifyPassword(password)); + ScTableProtection *const pTabProt(rDoc.GetTabProtection(0)); + CPPUNIT_ASSERT(pTabProt->verifyPassword(password)); + + // we can't assume that the user entered the password; check that we + // round-trip the password as-is + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_ODS); + xmlDocUniquePtr pXmlDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "content.xml"); + assertXPath(pXmlDoc, "//office:spreadsheet[@table:structure-protected='true' and @table:protection-key='1tnJohagR2T0yF/v69hLPuumSTsj32CumW97nkKGuSQ=' and @table:protection-key-digest-algorithm='http://www.w3.org/2000/09/xmldsig#sha256']"); + assertXPath(pXmlDoc, "//table:table[@table:protected='true' and @table:protection-key='1tnJohagR2T0yF/v69hLPuumSTsj32CumW97nkKGuSQ=' and @table:protection-key-digest-algorithm='http://www.w3.org/2000/09/xmldsig#sha256']"); + + xShell->DoClose(); +} + +void ScExportTest::testProtectionKeyODS_UTF8SHA256W3C() +{ + OUString const password("1012345678901234567890123456789012345678901234567890"); + + ScDocShellRef xShell = loadDoc("protection-key4.", FORMAT_FODS); + CPPUNIT_ASSERT_MESSAGE("Failed to load doc", xShell.is()); + + ScDocument& rDoc = xShell->GetDocument(); + ScDocProtection *const pDocProt(rDoc.GetDocProtection()); + CPPUNIT_ASSERT(pDocProt->verifyPassword(password)); + ScTableProtection *const pTabProt(rDoc.GetTabProtection(0)); + CPPUNIT_ASSERT(pTabProt->verifyPassword(password)); + + // we can't assume that the user entered the password; check that we + // round-trip the password as-is + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_ODS); + xmlDocUniquePtr pXmlDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "content.xml"); + assertXPath(pXmlDoc, "//office:spreadsheet[@table:structure-protected='true' and @table:protection-key='1tnJohagR2T0yF/v69hLPuumSTsj32CumW97nkKGuSQ=' and @table:protection-key-digest-algorithm='http://www.w3.org/2000/09/xmldsig#sha256']"); + assertXPath(pXmlDoc, "//table:table[@table:protected='true' and @table:protection-key='1tnJohagR2T0yF/v69hLPuumSTsj32CumW97nkKGuSQ=' and @table:protection-key-digest-algorithm='http://www.w3.org/2000/09/xmldsig#sha256']"); + + xShell->DoClose(); +} + +void ScExportTest::testProtectionKeyODS_XL_SHA1() +{ + OUString const password("1012345678901234567890123456789012345678901234567890"); + + ScDocShellRef xShell = loadDoc("protection-key5.", FORMAT_FODS); + CPPUNIT_ASSERT_MESSAGE("Failed to load doc", xShell.is()); + + ScDocument& rDoc = xShell->GetDocument(); + ScDocProtection *const pDocProt(rDoc.GetDocProtection()); + CPPUNIT_ASSERT(pDocProt->verifyPassword(password)); + ScTableProtection *const pTabProt(rDoc.GetTabProtection(0)); + CPPUNIT_ASSERT(pTabProt->verifyPassword(password)); + + // we can't assume that the user entered the password; check that we + // round-trip the password as-is + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_ODS); + xmlDocUniquePtr pXmlDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "content.xml"); + assertXPath(pXmlDoc, "//office:spreadsheet[@table:structure-protected='true' and @table:protection-key='OX3WkEe79fv1PE+FUmfOLdwVoqI=' and @table:protection-key-digest-algorithm='http://docs.oasis-open.org/office/ns/table/legacy-hash-excel' and @loext:protection-key-digest-algorithm-2='http://www.w3.org/2000/09/xmldsig#sha1']"); + assertXPath(pXmlDoc, "//table:table[@table:protected='true' and @table:protection-key='OX3WkEe79fv1PE+FUmfOLdwVoqI=' and @table:protection-key-digest-algorithm='http://docs.oasis-open.org/office/ns/table/legacy-hash-excel' and @loext:protection-key-digest-algorithm-2='http://www.w3.org/2000/09/xmldsig#sha1']"); + + xShell->DoClose(); +} + +void ScExportTest::testColorScaleExportODS() +{ + ScDocShellRef xShell = loadDoc("colorscale.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + testColorScale2Entry_Impl(rDoc); + testColorScale3Entry_Impl(rDoc); + + xDocSh->DoClose(); +} + +void ScExportTest::testColorScaleExportXLSX() +{ + ScDocShellRef xShell = loadDoc("colorscale.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + testColorScale2Entry_Impl(rDoc); + testColorScale3Entry_Impl(rDoc); + + xDocSh->DoClose(); +} + +void ScExportTest::testDataBarExportODS() +{ + ScDocShellRef xShell = loadDoc("databar.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + testDataBar_Impl(rDoc); + + xDocSh->DoClose(); +} + +void ScExportTest::testFormatExportODS() +{ + ScDocShellRef xShell = loadDoc("formats.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + testFormats(this, &rDoc, FORMAT_ODS); + + xDocSh->DoClose(); +} + +void ScExportTest::testCommentExportXLSX() +{ + //tdf#104729 FILESAVE OpenOffice do not save author of the comment during export to .xlsx + ScDocShellRef xShell = loadDoc("comment.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile + = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pComments + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/comments1.xml"); + CPPUNIT_ASSERT(pComments); + + assertXPathContent(pComments, "/x:comments/x:authors/x:author[1]", "BAKO"); + assertXPath(pComments, "/x:comments/x:authors/x:author", 1); + + assertXPathContent(pComments, "/x:comments/x:commentList/x:comment/x:text/x:r/x:t", + "Komentarz"); + + xmlDocUniquePtr pVmlDrawing + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/vmlDrawing1.vml"); + CPPUNIT_ASSERT(pVmlDrawing); + + //assertXPath(pVmlDrawing, "/xml/v:shapetype", "coordsize", "21600,21600"); + assertXPath(pVmlDrawing, "/xml/v:shapetype", "spt", "202"); + assertXPath(pVmlDrawing, "/xml/v:shapetype/v:stroke", "joinstyle", "miter"); + const OUString sShapeTypeId = "#" + getXPath(pVmlDrawing, "/xml/v:shapetype", "id"); + + assertXPath(pVmlDrawing, "/xml/v:shape", "type", sShapeTypeId); + assertXPath(pVmlDrawing, "/xml/v:shape/v:shadow", "color", "black"); + assertXPath(pVmlDrawing, "/xml/v:shape/v:shadow", "obscured", "t"); + + //tdf#117274 fix MSO interoperability with the secret VML shape type id + assertXPath(pVmlDrawing, "/xml/v:shapetype", "id", "_x0000_t202"); + assertXPath(pVmlDrawing, "/xml/v:shape", "type", "#_x0000_t202"); + + xShell->DoClose(); +} + +void ScExportTest::testCommentExportXLSX_2_XLSX() +{ + //tdf#117287 FILESAVE XLSX: Comments always disappear after opening the exported XLSX file with Excel + ScDocShellRef xShell = loadDoc("tdf117287_comment.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + + ScDocument& rDoc = xShell->GetDocument(); + ScAddress aPosC9(2, 8, 0); + ScPostIt *pNote = rDoc.GetNote(aPosC9); + + CPPUNIT_ASSERT(pNote); + CPPUNIT_ASSERT(!pNote->IsCaptionShown()); + + pNote->ShowCaption(aPosC9, true); + + std::shared_ptr<utl::TempFile> pXPathFile + = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pComments + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/comments1.xml"); + CPPUNIT_ASSERT(pComments); + + assertXPathContent(pComments, "/x:comments/x:commentList/x:comment/x:text/x:r/x:t", + "visible comment"); + + xmlDocUniquePtr pVmlDrawing + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/vmlDrawing1.vml"); + CPPUNIT_ASSERT(pVmlDrawing); + + assertXPath(pVmlDrawing, "/xml/v:shape/x:ClientData/x:Visible", 0); + + xShell->DoClose(); +} + +#if HAVE_MORE_FONTS +void ScExportTest::testCustomColumnWidthExportXLSX() +{ + //tdf#100946 FILESAVE Excel on macOS ignored column widths in XLSX last saved by LO + ScDocShellRef xShell = loadDoc("custom_column_width.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + // tdf#124741: check that we export default width, otherwise the skipped columns would have + // wrong width. Previously defaultColWidth attribute was missing + double nDefWidth + = getXPath(pSheet, "/x:worksheet/x:sheetFormatPr", "defaultColWidth").toDouble(); + CPPUNIT_ASSERT_DOUBLES_EQUAL(11.53515625, nDefWidth, 0.01); + + // First column, has everything default (width in Calc: 1280), skipped + + // Second column, has custom width (width in Calc: 1225) + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "outlineLevel", "0"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "customWidth", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "min", "2"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "max", "2"); + + // Third column, has everything default (width in Calc: 1280), skipped + + // Fourth column has custom width. Columns from 4 to 7 are hidden + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "outlineLevel", "0"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "customWidth", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "min", "4"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "max", "4"); + + // 5th column has custom width. Columns from 4 to 7 are hidden + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "outlineLevel", "0"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "customWidth", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "min", "5"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "max", "5"); + + // 6th and 7th columns have default width and they are hidden + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "outlineLevel", "0"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "customWidth", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "min", "6"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "max", "7"); + + // 8th column has everything default - skipped + + // 9th column has custom width + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "outlineLevel", "0"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "customWidth", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "min", "9"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "max", "9"); + + // We expected that exactly 5 unique Nodes will be produced + assertXPath(pSheet, "/x:worksheet/x:cols/x:col", 5); + + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "outlineLevel", "0"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "customFormat", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "customHeight", "false"); + + xShell->DoClose(); +} +#endif + +void ScExportTest::testXfDefaultValuesXLSX() +{ + //tdf#70565 FORMATTING: User Defined Custom Formatting is not applied during importing XLSX documents + ScDocShellRef xShell = loadDoc("xf_default_values.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/styles.xml"); + CPPUNIT_ASSERT(pSheet); + + // cellStyleXfs don't need xfId, so we need to make sure it is not saved + assertXPathNoAttribute(pSheet, "/x:styleSheet/x:cellStyleXfs/x:xf[1]", "xfId"); + + // Because numFmtId fontId fillId borderId xfId are not existing during import + // it should be created during export, with values set to "0" + assertXPath(pSheet, "/x:styleSheet/x:cellXfs/x:xf[1]", "xfId", "0"); + assertXPath(pSheet, "/x:styleSheet/x:cellXfs/x:xf[2]", "xfId", "0"); + assertXPath(pSheet, "/x:styleSheet/x:cellXfs/x:xf[3]", "xfId", "0"); + assertXPath(pSheet, "/x:styleSheet/x:cellXfs/x:xf[4]", "xfId", "0"); + + // We expected that exactly 15 cellXfs:xf Nodes will be produced + assertXPath(pSheet, "/x:styleSheet/x:cellXfs/x:xf", 14); + + xShell->DoClose(); +} + +namespace { + +// TODO where to put this? +class Resetter +{ +private: + std::function<void ()> m_Func; + +public: + Resetter(std::function<void ()> const& rFunc) + : m_Func(rFunc) + { + } + ~Resetter() + { + try + { + m_Func(); + } + catch (...) // has to be reliable + { + fprintf(stderr, "resetter failed with exception\n"); + abort(); + } + } +}; + +} // namespace + +static auto verifySpreadsheet13(char const*const pTestName, ScDocShellRef& pShell) -> void +{ + ScDocument const& rDoc(pShell->GetDocument()); + // OFFICE-2173 table:tab-color + CPPUNIT_ASSERT_EQUAL_MESSAGE(pTestName, Color(0xff3838), rDoc.GetTabBgColor(0)); + // OFFICE-3857 table:scale-to-X/table:scale-to-Y + OUString styleName = rDoc.GetPageStyle(0); + ScStyleSheetPool * pStylePool = rDoc.GetStyleSheetPool(); + SfxStyleSheetBase * pStyleSheet = pStylePool->Find(styleName, SfxStyleFamily::Page); + CPPUNIT_ASSERT_MESSAGE(pTestName, pStyleSheet); + + SfxItemSet const& rSet = pStyleSheet->GetItemSet(); + ScPageScaleToItem const& rItem(rSet.Get(ATTR_PAGE_SCALETO)); + CPPUNIT_ASSERT_EQUAL_MESSAGE(pTestName, sal_uInt16(2), rItem.GetWidth()); + CPPUNIT_ASSERT_EQUAL_MESSAGE(pTestName, sal_uInt16(3), rItem.GetHeight()); +} + +void ScExportTest::testODF13() +{ + // import + ScDocShellRef pShell = loadDoc("spreadsheet13e.", FORMAT_ODS); + + // check model + verifySpreadsheet13("import", pShell); + + Resetter _([]() { + std::shared_ptr<comphelper::ConfigurationChanges> pBatch( + comphelper::ConfigurationChanges::create()); + officecfg::Office::Common::Save::ODF::DefaultVersion::set(3, pBatch); + return pBatch->commit(); + }); + + { + // export ODF 1.3 + std::shared_ptr<comphelper::ConfigurationChanges> pBatch( + comphelper::ConfigurationChanges::create()); + officecfg::Office::Common::Save::ODF::DefaultVersion::set(10, pBatch); + pBatch->commit(); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*pShell), FORMAT_ODS); + + // check XML + xmlDocUniquePtr pContentXml = XPathHelper::parseExport(pXPathFile, m_xSFactory, "content.xml"); + assertXPath(pContentXml, "/office:document-content/office:automatic-styles/style:style/style:table-properties[@table:tab-color='#ff3838']"); + xmlDocUniquePtr pStylesXml = XPathHelper::parseExport(pXPathFile, m_xSFactory, "styles.xml"); + assertXPath(pStylesXml, "/office:document-styles/office:automatic-styles/style:page-layout/style:page-layout-properties[@style:scale-to-X='2']"); + assertXPath(pStylesXml, "/office:document-styles/office:automatic-styles/style:page-layout/style:page-layout-properties[@style:scale-to-Y='3']"); + + // reload + pShell = load(pXPathFile->GetURL(), "calc8", OUString(), OUString(), ODS_FORMAT_TYPE, SotClipboardFormatId::STARCALC_8); + + // check model + verifySpreadsheet13("1.3 reload", pShell); + } + { + // export ODF 1.2 Extended + std::shared_ptr<comphelper::ConfigurationChanges> pBatch( + comphelper::ConfigurationChanges::create()); + officecfg::Office::Common::Save::ODF::DefaultVersion::set(9, pBatch); + pBatch->commit(); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::saveAs(&(*pShell), FORMAT_ODS); + pShell->DoClose(); + + // check XML + xmlDocUniquePtr pContentXml = XPathHelper::parseExport(pXPathFile, m_xSFactory, "content.xml"); + assertXPath(pContentXml, "/office:document-content/office:automatic-styles/style:style/style:table-properties[@tableooo:tab-color='#ff3838']"); + xmlDocUniquePtr pStylesXml = XPathHelper::parseExport(pXPathFile, m_xSFactory, "styles.xml"); + assertXPath(pStylesXml, "/office:document-styles/office:automatic-styles/style:page-layout/style:page-layout-properties[@loext:scale-to-X='2']"); + assertXPath(pStylesXml, "/office:document-styles/office:automatic-styles/style:page-layout/style:page-layout-properties[@loext:scale-to-Y='3']"); + + // reload + pShell = load(pXPathFile->GetURL(), "calc8", OUString(), OUString(), ODS_FORMAT_TYPE, SotClipboardFormatId::STARCALC_8); + + // check model + verifySpreadsheet13("1.2 Extended reload", pShell); + } + { + // export ODF 1.2 + std::shared_ptr<comphelper::ConfigurationChanges> pBatch( + comphelper::ConfigurationChanges::create()); + officecfg::Office::Common::Save::ODF::DefaultVersion::set(4, pBatch); + pBatch->commit(); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::saveAs(&(*pShell), FORMAT_ODS); + pShell->DoClose(); + + // check XML + xmlDocUniquePtr pContentXml = XPathHelper::parseExport(pXPathFile, m_xSFactory, "content.xml"); + assertXPathNoAttribute(pContentXml, "/office:document-content/office:automatic-styles/style:style/style:table-properties", "tab-color"); + xmlDocUniquePtr pStylesXml = XPathHelper::parseExport(pXPathFile, m_xSFactory, "styles.xml"); + assertXPathNoAttribute(pStylesXml, "/office:document-styles/office:automatic-styles/style:page-layout[1]/style:page-layout-properties", "scale-to-X"); + assertXPathNoAttribute(pStylesXml, "/office:document-styles/office:automatic-styles/style:page-layout[1]/style:page-layout-properties", "scale-to-Y"); + + // don't reload - no point + } +} + +void ScExportTest::testColumnWidthResaveXLSX() +{ + // tdf#91475 FILESAVE: Column width is not preserved in XLSX / after round trip. + // Test if after resave .xlsx file, columns width is identical with previous one + ScDocShellRef xShell = loadDoc("different-column-width-excel2010.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + // In original Excel document the width is "24" + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "width", "24"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "customWidth", "true"); + + // In original Excel document the width is "12" + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "width", "12"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "customWidth", "true"); + + // In original Excel document the width is "6" + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "width", "6"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "customWidth", "true"); + + // In original Excel document the width is "1" + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "width", "1"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "customWidth", "true"); + + // In original Excel document the width is "250" + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "width", "250"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "customWidth", "true"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col", 5); + + xShell->DoClose(); +} + +#if HAVE_MORE_FONTS +void ScExportTest::testColumnWidthExportFromODStoXLSX() +{ + // tdf#91475 FILESAVE: Column width is not preserved in XLSX / after round trip. + // Test if after export .ods to .xlsx format, displayed columns width + // is identical with previous (.ods) one + + ScDocShellRef xShell = loadDoc("different-column-width.", FORMAT_ODS); + + CPPUNIT_ASSERT( xShell.is() ); + + ScDocument& rOdsDoc = xShell->GetDocument(); + + // Col 1, Tab 0 (Column width 2.00 in) + sal_uInt16 nExpectedColumn0Width = rOdsDoc.GetColWidth(static_cast<SCCOL>(0), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( static_cast< sal_uInt16 >( 2880 ), nExpectedColumn0Width ); + + // Col 2, Tab 0 (Column width 1.00 in) + sal_uInt16 nExpectedColumn1Width = rOdsDoc.GetColWidth(static_cast<SCCOL>(1), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( static_cast< sal_uInt16 >( 1440 ), nExpectedColumn1Width ); + + // Col 3, Tab 0 (Column width 0.50 in) + sal_uInt16 nExpectedColumn2Width = rOdsDoc.GetColWidth(static_cast<SCCOL>(2), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( static_cast< sal_uInt16 >( 720 ), nExpectedColumn2Width ); + + // Col 4, Tab 0 (Column width 0.25 in) + sal_uInt16 nExpectedColumn3Width = rOdsDoc.GetColWidth(static_cast<SCCOL>(3), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( static_cast< sal_uInt16 >( 360 ), nExpectedColumn3Width ); + + // Col 5, Tab 0 (Column width 13.57 in) + sal_uInt16 nExpectedColumn4Width = rOdsDoc.GetColWidth(static_cast<SCCOL>(4), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( static_cast< sal_uInt16 >( 19539 ), nExpectedColumn4Width ); + + // Export to .xlsx and compare column width with the .ods + // We expect that column width from .ods will be exactly the same as imported from .xlsx + + ScDocShellRef xXlsxDocSh = saveAndReload( xShell.get(), FORMAT_XLSX ); + CPPUNIT_ASSERT( xXlsxDocSh.is() ); + + ScDocument& rDoc = xXlsxDocSh->GetDocument(); + + // Col 1, Tab 0 + sal_uInt16 nCalcWidth; + nCalcWidth = rDoc.GetColWidth(static_cast<SCCOL>(0), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( nExpectedColumn0Width, nCalcWidth ); + + // Col 2, Tab 0 + nCalcWidth = rDoc.GetColWidth(static_cast<SCCOL>(1), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( nExpectedColumn1Width, nCalcWidth ); + + // Col 3, Tab 0 + nCalcWidth = rDoc.GetColWidth(static_cast<SCCOL>(2), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( nExpectedColumn2Width, nCalcWidth ); + + // Col 4, Tab 0 + nCalcWidth = rDoc.GetColWidth(static_cast<SCCOL>(3), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( nExpectedColumn3Width, nCalcWidth ); + + // Col 5, Tab 0 + nCalcWidth = rDoc.GetColWidth(static_cast<SCCOL>(4), static_cast<SCTAB>(0), false); + CPPUNIT_ASSERT_EQUAL( nExpectedColumn4Width, nCalcWidth ); + + xXlsxDocSh->DoClose(); +} +#endif + +void ScExportTest::testOutlineExportXLSX() +{ + //tdf#100347 FILESAVE FILEOPEN after exporting to .xlsx format grouping are lost + //tdf#51524 FILESAVE .xlsx and.xls looses width information for hidden/collapsed grouped columns + ScDocShellRef xShell = loadDoc("outline.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + // Maximum Outline Row is 4 for this document + assertXPath(pSheet, "/x:worksheet/x:sheetFormatPr", "outlineLevelRow", "4"); + // Maximum Outline Column is 4 for this document + assertXPath(pSheet, "/x:worksheet/x:sheetFormatPr", "outlineLevelCol", "4"); + + // First XML node, creates two columns (from min=1 to max=2) + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "outlineLevel", "1"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "min", "1"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[1]", "max", "2"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "outlineLevel", "2"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "min", "3"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[2]", "max", "3"); + + // Column 4 has custom width and it is hidden. We need to make sure that it is created + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "outlineLevel", "2"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "min", "4"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[3]", "max", "4"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "outlineLevel", "3"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "min", "5"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[4]", "max", "6"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "outlineLevel", "4"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "min", "7"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[5]", "max", "7"); + + // Column 8 has custom width and it is hidden. We need to make sure that it is created + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[6]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[6]", "outlineLevel", "4"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[6]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[6]", "min", "8"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[6]", "max", "8"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[7]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[7]", "outlineLevel", "4"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[7]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[7]", "min", "9"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[7]", "max", "19"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[8]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[8]", "outlineLevel", "3"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[8]", "collapsed", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[8]", "min", "20"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[8]", "max", "20"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[9]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[9]", "outlineLevel", "3"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[9]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[9]", "min", "21"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[9]", "max", "21"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[10]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[10]", "outlineLevel", "2"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[10]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[10]", "min", "22"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[10]", "max", "23"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[11]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[11]", "outlineLevel", "1"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[11]", "collapsed", "true"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[11]", "min", "24"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[11]", "max", "24"); + + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[12]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[12]", "outlineLevel", "1"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[12]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[12]", "min", "25"); + assertXPath(pSheet, "/x:worksheet/x:cols/x:col[12]", "max", "26"); + + // We expected that exactly 12 unique Nodes will be produced + assertXPath(pSheet, "/x:worksheet/x:cols/x:col", 12); + + // First row is empty and default so it is not written into XML file + // so we need to save 29 rows, as it provides information about outLineLevel + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "r", "2"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "outlineLevel", "1"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[2]", "r", "3"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[2]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[2]", "outlineLevel", "2"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[2]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[3]", "r", "4"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[3]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[3]", "outlineLevel", "2"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[3]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[4]", "r", "5"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[4]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[4]", "outlineLevel", "3"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[4]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[5]", "r", "6"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[5]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[5]", "outlineLevel", "3"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[5]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[6]", "r", "7"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[6]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[6]", "outlineLevel", "4"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[6]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[7]", "r", "8"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[7]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[7]", "outlineLevel", "4"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[7]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[8]", "r", "9"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[8]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[8]", "outlineLevel", "4"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[8]", "collapsed", "false"); + // Next rows are the same as the previous one but it needs to be preserved, + // as they contain information about outlineLevel + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[20]", "r", "21"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[20]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[20]", "outlineLevel", "4"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[20]", "collapsed", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[21]", "r", "22"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[21]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[21]", "outlineLevel", "3"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[21]", "collapsed", "true"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[22]", "r", "23"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[22]", "hidden", "false"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[22]", "outlineLevel", "3"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[22]", "collapsed", "false"); + + // We expected that exactly 29 Row Nodes will be produced + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row", 29); + + xShell->DoClose(); +} + +void ScExportTest::testAllRowsHiddenXLSX() +{ + ScDocShellRef xOrigDocSh = loadDoc("tdf105840_allRowsHidden.", FORMAT_XLSX); + CPPUNIT_ASSERT(xOrigDocSh.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xOrigDocSh), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + assertXPath(pSheet, "/x:worksheet/x:sheetFormatPr", "zeroHeight", "true" ); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row", 0); + + xOrigDocSh->DoClose(); +} + +void ScExportTest::testHiddenEmptyRowsXLSX() +{ + //tdf#98106 FILESAVE: Hidden and empty rows became visible when export to .XLSX + ScDocShellRef xShell = loadDoc("hidden-empty-rows.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + assertXPath(pSheet, "/x:worksheet/x:sheetFormatPr", "zeroHeight", "false" ); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[1]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[2]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[3]", "hidden", "true"); + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row[4]", "hidden", "false"); + + xShell->DoClose(); +} + +void ScExportTest::testLandscapeOrientationXLSX() +{ + //tdf#48767 - Landscape page orientation is not loaded from .xlsx format with MS Excel, after export with Libre Office + ScDocShellRef xShell = loadDoc("hidden-empty-rows.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + // the usePrinterDefaults cannot be saved to allow opening sheets in Landscape mode via MS Excel + assertXPathNoAttribute(pSheet, "/x:worksheet/x:pageSetup", "usePrinterDefaults"); + assertXPath(pSheet, "/x:worksheet/x:pageSetup", "orientation", "landscape"); + + xShell->DoClose(); +} + +void ScExportTest::testDataBarExportXLSX() +{ + ScDocShellRef xShell = loadDoc("databar.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + testDataBar_Impl(rDoc); + + xDocSh->DoClose(); +} + +void ScExportTest::testMiscRowHeightExport() +{ + static const TestParam::RowData DfltRowData[] = + { + { 0, 4, 0, 529, 0, false }, + { 5, 10, 0, 1058, 0, false }, + { 17, 20, 0, 1767, 0, false }, + // check last couple of row in document to ensure + // they are 5.29mm ( effective default row xlsx height ) + { 1048573, 1048575, 0, 529, 0, false }, + }; + + static const TestParam::RowData EmptyRepeatRowData[] = + { + // rows 0-4, 5-10, 17-20 are all set at various + // heights, there is no content in the rows, there + // was a bug where only the first row ( of repeated rows ) + // was set after export + { 0, 4, 0, 529, 0, false }, + { 5, 10, 0, 1058, 0, false }, + { 17, 20, 0, 1767, 0, false }, + }; + + TestParam aTestValues[] = + { + // Checks that some distributed ( non-empty ) heights remain set after export (roundtrip) + // additionally there is effectively a default row height ( 5.29 mm ). So we test the + // unset rows at the end of the document to ensure the effective xlsx default height + // is set there too. + { "miscrowheights.", FORMAT_XLSX, FORMAT_XLSX, SAL_N_ELEMENTS(DfltRowData), DfltRowData }, + // Checks that some distributed ( non-empty ) heights remain set after export (to xls) + { "miscrowheights.", FORMAT_XLSX, FORMAT_XLS, SAL_N_ELEMENTS(DfltRowData), DfltRowData }, + // Checks that repreated rows ( of various heights ) remain set after export ( to xlsx ) + { "miscemptyrepeatedrowheights.", FORMAT_ODS, FORMAT_XLSX, SAL_N_ELEMENTS(EmptyRepeatRowData), EmptyRepeatRowData }, + // Checks that repreated rows ( of various heights ) remain set after export ( to xls ) + { "miscemptyrepeatedrowheights.", FORMAT_ODS, FORMAT_XLS, SAL_N_ELEMENTS(EmptyRepeatRowData), EmptyRepeatRowData }, + }; + miscRowHeightsTest( aTestValues, SAL_N_ELEMENTS(aTestValues) ); +} + +namespace { + +void setAttribute( ScFieldEditEngine& rEE, sal_Int32 nPara, sal_Int32 nStart, sal_Int32 nEnd, sal_uInt16 nType, Color nColor = COL_BLACK ) +{ + ESelection aSel; + aSel.nStartPara = aSel.nEndPara = nPara; + aSel.nStartPos = nStart; + aSel.nEndPos = nEnd; + + SfxItemSet aItemSet = rEE.GetEmptyItemSet(); + switch (nType) + { + case EE_CHAR_WEIGHT: + { + SvxWeightItem aWeight(WEIGHT_BOLD, nType); + aItemSet.Put(aWeight); + rEE.QuickSetAttribs(aItemSet, aSel); + } + break; + case EE_CHAR_ITALIC: + { + SvxPostureItem aItalic(ITALIC_NORMAL, nType); + aItemSet.Put(aItalic); + rEE.QuickSetAttribs(aItemSet, aSel); + } + break; + case EE_CHAR_STRIKEOUT: + { + SvxCrossedOutItem aCrossOut(STRIKEOUT_SINGLE, nType); + aItemSet.Put(aCrossOut); + rEE.QuickSetAttribs(aItemSet, aSel); + } + break; + case EE_CHAR_OVERLINE: + { + SvxOverlineItem aItem(LINESTYLE_DOUBLE, nType); + aItemSet.Put(aItem); + rEE.QuickSetAttribs(aItemSet, aSel); + } + break; + case EE_CHAR_UNDERLINE: + { + SvxUnderlineItem aItem(LINESTYLE_DOUBLE, nType); + aItemSet.Put(aItem); + rEE.QuickSetAttribs(aItemSet, aSel); + } + break; + case EE_CHAR_COLOR: + { + SvxColorItem aItem(nColor, nType); + aItemSet.Put(aItem); + rEE.QuickSetAttribs(aItemSet, aSel); + } + break; + default: + ; + } +} + +void setFont( ScFieldEditEngine& rEE, sal_Int32 nPara, sal_Int32 nStart, sal_Int32 nEnd, const OUString& rFontName ) +{ + ESelection aSel; + aSel.nStartPara = aSel.nEndPara = nPara; + aSel.nStartPos = nStart; + aSel.nEndPos = nEnd; + + SfxItemSet aItemSet = rEE.GetEmptyItemSet(); + SvxFontItem aItem(FAMILY_MODERN, rFontName, "", PITCH_VARIABLE, RTL_TEXTENCODING_UTF8, EE_CHAR_FONTINFO); + aItemSet.Put(aItem); + rEE.QuickSetAttribs(aItemSet, aSel); +} + +void setEscapement( ScFieldEditEngine& rEE, sal_Int32 nPara, sal_Int32 nStart, sal_Int32 nEnd, short nEsc, sal_uInt8 nRelSize ) +{ + ESelection aSel; + aSel.nStartPara = aSel.nEndPara = nPara; + aSel.nStartPos = nStart; + aSel.nEndPos = nEnd; + + SfxItemSet aItemSet = rEE.GetEmptyItemSet(); + SvxEscapementItem aItem(nEsc, nRelSize, EE_CHAR_ESCAPEMENT); + aItemSet.Put(aItem); + rEE.QuickSetAttribs(aItemSet, aSel); +} + +} + +void ScExportTest::testNamedRangeBugfdo62729() +{ + ScDocShellRef xShell = loadDoc("fdo62729.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + ScDocument& rDoc = xShell->GetDocument(); + + ScRangeName* pNames = rDoc.GetRangeName(); + //should be just a single named range + CPPUNIT_ASSERT_EQUAL(size_t(1), pNames->size()); + rDoc.DeleteTab(0); + //should be still a single named range + CPPUNIT_ASSERT_EQUAL(size_t(1), pNames->size()); + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_ODS); + xShell->DoClose(); + + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument& rDoc2 = xDocSh->GetDocument(); + + pNames = rDoc2.GetRangeName(); + //after reload should still have a named range + CPPUNIT_ASSERT_EQUAL(size_t(1), pNames->size()); + + xDocSh->DoClose(); +} + +void ScExportTest::testBuiltinRangesXLSX() +{ + ScDocShellRef xShell = loadDoc("built-in_ranges.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + xShell->DoClose(); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/workbook.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + //assert the existing OOXML built-in names are still there + assertXPathContent(pDoc, "/x:workbook/x:definedNames/x:definedName[@name='_xlnm._FilterDatabase'][@localSheetId='0']", "'Sheet1 Test'!$A$1:$A$5"); + assertXPathContent(pDoc, "/x:workbook/x:definedNames/x:definedName[@name='_xlnm._FilterDatabase'][@localSheetId='1']", "'Sheet2 Test'!$K$10:$K$14"); + assertXPathContent(pDoc, "/x:workbook/x:definedNames/x:definedName[@name='_xlnm.Print_Area'][@localSheetId='0']", "'Sheet1 Test'!$A$1:$A$5"); + assertXPathContent(pDoc, "/x:workbook/x:definedNames/x:definedName[@name='_xlnm.Print_Area'][@localSheetId='1']", "'Sheet2 Test'!$K$10:$M$18"); + + //...and that no extra ones are added (see tdf#112571) + assertXPath(pDoc, "/x:workbook/x:definedNames/x:definedName[@name='_xlnm._FilterDatabase_0'][@localSheetId='0']", 0); + assertXPath(pDoc, "/x:workbook/x:definedNames/x:definedName[@name='_xlnm._FilterDatabase_0'][@localSheetId='1']", 0); + assertXPath(pDoc, "/x:workbook/x:definedNames/x:definedName[@name='_xlnm.Print_Area_0'][@localSheetId='0']", 0); + assertXPath(pDoc, "/x:workbook/x:definedNames/x:definedName[@name='_xlnm.Print_Area_0'][@localSheetId='1']", 0); + + xDocSh->DoClose(); +} + +void ScExportTest::testRichTextExportODS() +{ + struct + { + static bool isBold(const editeng::Section& rAttr) + { + return std::any_of(rAttr.maAttributes.begin(), rAttr.maAttributes.end(), [](const SfxPoolItem* p) { + return p->Which() == EE_CHAR_WEIGHT && + static_cast<const SvxWeightItem*>(p)->GetWeight() == WEIGHT_BOLD; }); + } + + static bool isItalic(const editeng::Section& rAttr) + { + return std::any_of(rAttr.maAttributes.begin(), rAttr.maAttributes.end(), [](const SfxPoolItem* p) { + return p->Which() == EE_CHAR_ITALIC && + static_cast<const SvxPostureItem*>(p)->GetPosture() == ITALIC_NORMAL; }); + } + + static bool isStrikeOut(const editeng::Section& rAttr) + { + return std::any_of(rAttr.maAttributes.begin(), rAttr.maAttributes.end(), [](const SfxPoolItem* p) { + return p->Which() == EE_CHAR_STRIKEOUT && + static_cast<const SvxCrossedOutItem*>(p)->GetStrikeout() == STRIKEOUT_SINGLE; }); + } + + static bool isOverline(const editeng::Section& rAttr, FontLineStyle eStyle) + { + return std::any_of(rAttr.maAttributes.begin(), rAttr.maAttributes.end(), [&eStyle](const SfxPoolItem* p) { + return p->Which() == EE_CHAR_OVERLINE && + static_cast<const SvxOverlineItem*>(p)->GetLineStyle() == eStyle; }); + } + + static bool isUnderline(const editeng::Section& rAttr, FontLineStyle eStyle) + { + return std::any_of(rAttr.maAttributes.begin(), rAttr.maAttributes.end(), [&eStyle](const SfxPoolItem* p) { + return p->Which() == EE_CHAR_UNDERLINE && + static_cast<const SvxUnderlineItem*>(p)->GetLineStyle() == eStyle; }); + } + + static bool isFont(const editeng::Section& rAttr, const OUString& rFontName) + { + return std::any_of(rAttr.maAttributes.begin(), rAttr.maAttributes.end(), [&rFontName](const SfxPoolItem* p) { + return p->Which() == EE_CHAR_FONTINFO && + static_cast<const SvxFontItem*>(p)->GetFamilyName() == rFontName; }); + } + + static bool isEscapement(const editeng::Section& rAttr, short nEsc, sal_uInt8 nRelSize) + { + return std::any_of(rAttr.maAttributes.begin(), rAttr.maAttributes.end(), + [&nEsc, &nRelSize](const SfxPoolItem* p) { + if (p->Which() != EE_CHAR_ESCAPEMENT) + return false; + const SvxEscapementItem* pItem = static_cast<const SvxEscapementItem*>(p); + return ((pItem->GetEsc() == nEsc) && (pItem->GetProportionalHeight() == nRelSize)); + }); + } + + static bool isColor(const editeng::Section& rAttr, Color nColor) + { + return std::any_of(rAttr.maAttributes.begin(), rAttr.maAttributes.end(), [&nColor](const SfxPoolItem* p) { + return p->Which() == EE_CHAR_COLOR && + static_cast<const SvxColorItem*>(p)->GetValue() == nColor; }); + } + + bool checkB2(const EditTextObject* pText) const + { + if (!pText) + return false; + + if (pText->GetParagraphCount() != 1) + return false; + + if (pText->GetText(0) != "Bold and Italic") + return false; + + std::vector<editeng::Section> aSecAttrs; + pText->GetAllSections(aSecAttrs); + if (aSecAttrs.size() != 3) + return false; + + // Check the first bold section. + const editeng::Section* pAttr = aSecAttrs.data(); + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 0 || pAttr->mnEnd != 4) + return false; + + if (pAttr->maAttributes.size() != 1 || !isBold(*pAttr)) + return false; + + // The middle section should be unformatted. + pAttr = &aSecAttrs[1]; + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 4 || pAttr->mnEnd != 9) + return false; + + if (!pAttr->maAttributes.empty()) + return false; + + // The last section should be italic. + pAttr = &aSecAttrs[2]; + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 9 || pAttr->mnEnd != 15) + return false; + + if (pAttr->maAttributes.size() != 1 || !isItalic(*pAttr)) + return false; + + return true; + } + + bool checkB4(const EditTextObject* pText) const + { + if (!pText) + return false; + + if (pText->GetParagraphCount() != 3) + return false; + + if (pText->GetText(0) != "One") + return false; + + if (pText->GetText(1) != "Two") + return false; + + if (pText->GetText(2) != "Three") + return false; + + return true; + } + + bool checkB5(const EditTextObject* pText) const + { + if (!pText) + return false; + + if (pText->GetParagraphCount() != 6) + return false; + + if (!pText->GetText(0).isEmpty()) + return false; + + if (pText->GetText(1) != "Two") + return false; + + if (pText->GetText(2) != "Three") + return false; + + if (!pText->GetText(3).isEmpty()) + return false; + + if (pText->GetText(4) != "Five") + return false; + + if (!pText->GetText(5).isEmpty()) + return false; + + return true; + } + + bool checkB6(const EditTextObject* pText) const + { + if (!pText) + return false; + + if (pText->GetParagraphCount() != 1) + return false; + + if (pText->GetText(0) != "Strike Me") + return false; + + std::vector<editeng::Section> aSecAttrs; + pText->GetAllSections(aSecAttrs); + if (aSecAttrs.size() != 2) + return false; + + // Check the first strike-out section. + const editeng::Section* pAttr = aSecAttrs.data(); + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 0 || pAttr->mnEnd != 6) + return false; + + if (pAttr->maAttributes.size() != 1 || !isStrikeOut(*pAttr)) + return false; + + // The last section should be unformatted. + pAttr = &aSecAttrs[1]; + return pAttr->mnParagraph == 0 && pAttr->mnStart == 6 && pAttr->mnEnd == 9; + } + + bool checkB7(const EditTextObject* pText) const + { + if (!pText) + return false; + + if (pText->GetParagraphCount() != 1) + return false; + + if (pText->GetText(0) != "Font1 and Font2") + return false; + + std::vector<editeng::Section> aSecAttrs; + pText->GetAllSections(aSecAttrs); + if (aSecAttrs.size() != 3) + return false; + + // First section should have "Courier" font applied. + const editeng::Section* pAttr = aSecAttrs.data(); + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 0 || pAttr->mnEnd != 5) + return false; + + if (pAttr->maAttributes.size() != 1 || !isFont(*pAttr, "Courier")) + return false; + + // Last section should have "Luxi Mono" applied. + pAttr = &aSecAttrs[2]; + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 10 || pAttr->mnEnd != 15) + return false; + + if (pAttr->maAttributes.size() != 1 || !isFont(*pAttr, "Luxi Mono")) + return false; + + return true; + } + + bool checkB8(const EditTextObject* pText) const + { + if (!pText) + return false; + + if (pText->GetParagraphCount() != 1) + return false; + + if (pText->GetText(0) != "Over and Under") + return false; + + std::vector<editeng::Section> aSecAttrs; + pText->GetAllSections(aSecAttrs); + if (aSecAttrs.size() != 3) + return false; + + // First section shoul have overline applied. + const editeng::Section* pAttr = aSecAttrs.data(); + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 0 || pAttr->mnEnd != 4) + return false; + + if (pAttr->maAttributes.size() != 1 || !isOverline(*pAttr, LINESTYLE_DOUBLE)) + return false; + + // Last section should have underline applied. + pAttr = &aSecAttrs[2]; + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 9 || pAttr->mnEnd != 14) + return false; + + if (pAttr->maAttributes.size() != 1 || !isUnderline(*pAttr, LINESTYLE_DOUBLE)) + return false; + + return true; + } + + bool checkB9(const EditTextObject* pText) const + { + if (!pText) + return false; + + if (pText->GetParagraphCount() != 1) + return false; + + if (pText->GetText(0) != "Sub and Super") + return false; + + std::vector<editeng::Section> aSecAttrs; + pText->GetAllSections(aSecAttrs); + if (aSecAttrs.size() != 3) + return false; + + // superscript + const editeng::Section* pAttr = aSecAttrs.data(); + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 0 || pAttr->mnEnd != 3) + return false; + + if (pAttr->maAttributes.size() != 1 || !isEscapement(*pAttr, 32, 64)) + return false; + + // subscript + pAttr = &aSecAttrs[2]; + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 8 || pAttr->mnEnd != 13) + return false; + + if (pAttr->maAttributes.size() != 1 || !isEscapement(*pAttr, -32, 66)) + return false; + + return true; + } + + bool checkB10(const EditTextObject* pText) const + { + if (!pText) + return false; + + if (pText->GetParagraphCount() != 1) + return false; + + if (pText->GetText(0) != "BLUE AUTO") + return false; + + std::vector<editeng::Section> aSecAttrs; + pText->GetAllSections(aSecAttrs); + if (aSecAttrs.size() != 2) + return false; + + // auto color + const editeng::Section* pAttr = &aSecAttrs[1]; + if (pAttr->mnParagraph != 0 ||pAttr->mnStart != 5 || pAttr->mnEnd != 9) + return false; + + if (pAttr->maAttributes.size() != 1 || !isColor(*pAttr, COL_AUTO)) + return false; + + return true; + } + + } aCheckFunc; + + // Start with an empty document, put one edit text cell, and make sure it + // survives the save and reload. + ScDocShellRef xOrigDocSh = loadDoc("empty.", FORMAT_ODS, true); + const EditTextObject* pEditText; + { + ScDocument& rDoc = xOrigDocSh->GetDocument(); + CPPUNIT_ASSERT_MESSAGE("This document should at least have one sheet.", rDoc.GetTableCount() > 0); + + // Insert an edit text cell. + ScFieldEditEngine* pEE = &rDoc.GetEditEngine(); + pEE->SetTextCurrentDefaults("Bold and Italic"); + // Set the 'Bold' part bold. + setAttribute(*pEE, 0, 0, 4, EE_CHAR_WEIGHT); + // Set the 'Italic' part italic. + setAttribute(*pEE, 0, 9, 15, EE_CHAR_ITALIC); + ESelection aSel; + aSel.nStartPara = aSel.nEndPara = 0; + + // Set this edit text to cell B2. + rDoc.SetEditText(ScAddress(1,1,0), pEE->CreateTextObject()); + pEditText = rDoc.GetEditText(ScAddress(1,1,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B2 value.", aCheckFunc.checkB2(pEditText)); + } + + // Now, save and reload this document. + ScDocShellRef xNewDocSh = saveAndReload(xOrigDocSh.get(), FORMAT_ODS); + { + xOrigDocSh->DoClose(); + CPPUNIT_ASSERT(xNewDocSh.is()); + ScDocument& rDoc2 = xNewDocSh->GetDocument(); + CPPUNIT_ASSERT_MESSAGE("Reloaded document should at least have one sheet.", rDoc2.GetTableCount() > 0); + ScFieldEditEngine* pEE = &rDoc2.GetEditEngine(); + + // Make sure the content of B2 is still intact. + CPPUNIT_ASSERT_MESSAGE("Incorrect B2 value.", aCheckFunc.checkB2(pEditText)); + + // Insert a multi-line content to B4. + pEE->Clear(); + pEE->SetTextCurrentDefaults("One\nTwo\nThree"); + rDoc2.SetEditText(ScAddress(1,3,0), pEE->CreateTextObject()); + pEditText = rDoc2.GetEditText(ScAddress(1,3,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B4 value.", aCheckFunc.checkB4(pEditText)); + } + + // Reload the doc again, and check the content of B2 and B4. + ScDocShellRef xNewDocSh2 = saveAndReload(xNewDocSh.get(), FORMAT_ODS); + { + ScDocument& rDoc3 = xNewDocSh2->GetDocument(); + ScFieldEditEngine* pEE = &rDoc3.GetEditEngine(); + xNewDocSh->DoClose(); + + pEditText = rDoc3.GetEditText(ScAddress(1,1,0)); + CPPUNIT_ASSERT_MESSAGE("B2 should be an edit text.", pEditText); + pEditText = rDoc3.GetEditText(ScAddress(1,3,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B4 value.", aCheckFunc.checkB4(pEditText)); + + // Insert a multi-line content to B5, but this time, set some empty paragraphs. + pEE->Clear(); + pEE->SetTextCurrentDefaults("\nTwo\nThree\n\nFive\n"); + rDoc3.SetEditText(ScAddress(1,4,0), pEE->CreateTextObject()); + pEditText = rDoc3.GetEditText(ScAddress(1,4,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B5 value.", aCheckFunc.checkB5(pEditText)); + + // Insert a text with strikethrough in B6. + pEE->Clear(); + pEE->SetTextCurrentDefaults("Strike Me"); + // Set the 'Strike' part strikethrough. + setAttribute(*pEE, 0, 0, 6, EE_CHAR_STRIKEOUT); + rDoc3.SetEditText(ScAddress(1,5,0), pEE->CreateTextObject()); + pEditText = rDoc3.GetEditText(ScAddress(1,5,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B6 value.", aCheckFunc.checkB6(pEditText)); + + // Insert a text with different font segments in B7. + pEE->Clear(); + pEE->SetTextCurrentDefaults("Font1 and Font2"); + setFont(*pEE, 0, 0, 5, "Courier"); + setFont(*pEE, 0, 10, 15, "Luxi Mono"); + rDoc3.SetEditText(ScAddress(1,6,0), pEE->CreateTextObject()); + pEditText = rDoc3.GetEditText(ScAddress(1,6,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B7 value.", aCheckFunc.checkB7(pEditText)); + + // Insert a text with overline and underline in B8. + pEE->Clear(); + pEE->SetTextCurrentDefaults("Over and Under"); + setAttribute(*pEE, 0, 0, 4, EE_CHAR_OVERLINE); + setAttribute(*pEE, 0, 9, 14, EE_CHAR_UNDERLINE); + rDoc3.SetEditText(ScAddress(1,7,0), pEE->CreateTextObject()); + pEditText = rDoc3.GetEditText(ScAddress(1,7,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B8 value.", aCheckFunc.checkB8(pEditText)); + + pEE->Clear(); + pEE->SetTextCurrentDefaults("Sub and Super"); + setEscapement(*pEE, 0, 0, 3, 32, 64); + setEscapement(*pEE, 0, 8, 13, -32, 66); + rDoc3.SetEditText(ScAddress(1,8,0), pEE->CreateTextObject()); + pEditText = rDoc3.GetEditText(ScAddress(1,8,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B9 value.", aCheckFunc.checkB9(pEditText)); + + ScPatternAttr aCellFontColor(rDoc3.GetPool()); + aCellFontColor.GetItemSet().Put(SvxColorItem(COL_BLUE, ATTR_FONT_COLOR)); + // Set font color of B10 to blue. + rDoc3.ApplyPattern(1, 9, 0, aCellFontColor); + pEE->Clear(); + pEE->SetTextCurrentDefaults("BLUE AUTO"); + // Set the color of the string "AUTO" to automatic color. + setAttribute(*pEE, 0, 5, 9, EE_CHAR_COLOR, COL_AUTO); + rDoc3.SetEditText(ScAddress(1, 9, 0), pEE->CreateTextObject()); + pEditText = rDoc3.GetEditText(ScAddress(1, 9, 0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B10 value.", aCheckFunc.checkB10(pEditText)); + } + + // Reload the doc again, and check the content of B2, B4, B6 and B7. + ScDocShellRef xNewDocSh3 = saveAndReload(xNewDocSh2.get(), FORMAT_ODS); + ScDocument& rDoc4 = xNewDocSh3->GetDocument(); + xNewDocSh2->DoClose(); + + pEditText = rDoc4.GetEditText(ScAddress(1,1,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B2 value after save and reload.", aCheckFunc.checkB2(pEditText)); + pEditText = rDoc4.GetEditText(ScAddress(1,3,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B4 value after save and reload.", aCheckFunc.checkB4(pEditText)); + pEditText = rDoc4.GetEditText(ScAddress(1,4,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B5 value after save and reload.", aCheckFunc.checkB5(pEditText)); + pEditText = rDoc4.GetEditText(ScAddress(1,5,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B6 value after save and reload.", aCheckFunc.checkB6(pEditText)); + pEditText = rDoc4.GetEditText(ScAddress(1,6,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B7 value after save and reload.", aCheckFunc.checkB7(pEditText)); + pEditText = rDoc4.GetEditText(ScAddress(1,7,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B8 value after save and reload.", aCheckFunc.checkB8(pEditText)); + pEditText = rDoc4.GetEditText(ScAddress(1,9,0)); + CPPUNIT_ASSERT_MESSAGE("Incorrect B10 value after save and reload.", aCheckFunc.checkB10(pEditText)); + + xNewDocSh3->DoClose(); +} + +void ScExportTest::testRichTextCellFormatXLSX() +{ + ScDocShellRef xDocSh = loadDoc("cellformat.", FORMAT_XLS); + CPPUNIT_ASSERT(xDocSh.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xDocSh), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + // make sure the only cell in this doc is assigned some formatting record + OUString aCellFormat = getXPath(pSheet, "/x:worksheet/x:sheetData/x:row/x:c", "s"); + CPPUNIT_ASSERT_MESSAGE("Cell format is missing", !aCellFormat.isEmpty()); + + xmlDocUniquePtr pStyles = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/styles.xml"); + CPPUNIT_ASSERT(pStyles); + + OString nFormatIdx = OString::number( aCellFormat.toInt32() + 1 ); + const OString aXPath1( "/x:styleSheet/x:cellXfs/x:xf[" + nFormatIdx + "]/x:alignment" ); + // formatting record is set to wrap text + assertXPath(pStyles, aXPath1, "wrapText", "true"); + + // see what font it references + const OString aXPath2( "/x:styleSheet/x:cellXfs/x:xf[" + nFormatIdx +"]" ); + OUString aFontId = getXPath(pStyles, aXPath2, "fontId"); + OString nFontIdx = OString::number( aFontId.toInt32() + 1 ); + + // that font should be bold + const OString aXPath3("/x:styleSheet/x:fonts/x:font[" + nFontIdx + "]/x:b"); + assertXPath(pStyles, aXPath3, "val", "true"); + + xDocSh->DoClose(); +} + +void ScExportTest::testFormulaRefSheetNameODS() +{ + ScDocShellRef xDocSh = loadDoc("formula-quote-in-sheet-name.", FORMAT_ODS, true); + { + ScDocument& rDoc = xDocSh->GetDocument(); + + sc::AutoCalcSwitch aACSwitch(rDoc, true); // turn on auto calc. + rDoc.SetString(ScAddress(1,1,0), "='90''s Data'.B2"); + CPPUNIT_ASSERT_EQUAL(1.1, rDoc.GetValue(ScAddress(1,1,0))); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(1,1,0), "'90''s Data'.B2", "Wrong formula"); + } + // Now, save and reload this document. + ScDocShellRef xNewDocSh = saveAndReload(xDocSh.get(), FORMAT_ODS); + xDocSh->DoClose(); + + ScDocument& rDoc = xNewDocSh->GetDocument(); + rDoc.CalcAll(); + CPPUNIT_ASSERT_EQUAL(1.1, rDoc.GetValue(ScAddress(1,1,0))); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(1,1,0), "'90''s Data'.B2", "Wrong formula"); + + xNewDocSh->DoClose(); +} + +void ScExportTest::testCellValuesExportODS() +{ + // Start with an empty document + ScDocShellRef xOrigDocSh = loadDoc("empty.", FORMAT_ODS); + { + ScDocument& rDoc = xOrigDocSh->GetDocument(); + CPPUNIT_ASSERT_MESSAGE("This document should at least have one sheet.", rDoc.GetTableCount() > 0); + + // set a value double + rDoc.SetValue(ScAddress(0,0,0), 2.0); // A1 + + // set a formula + rDoc.SetValue(ScAddress(2,0,0), 3.0); // C1 + rDoc.SetValue(ScAddress(3,0,0), 3); // D1 + rDoc.SetString(ScAddress(4,0,0), "=10*C1/4"); // E1 + rDoc.SetValue(ScAddress(5,0,0), 3.0); // F1 + rDoc.SetString(ScAddress(7,0,0), "=SUM(C1:F1)"); //H1 + + // set a string + rDoc.SetString(ScAddress(0,2,0), "a simple line"); //A3 + + // set a digit string + rDoc.SetString(ScAddress(0,4,0), "'12"); //A5 + // set a contiguous value + rDoc.SetValue(ScAddress(0,5,0), 12.0); //A6 + // set a contiguous string + rDoc.SetString(ScAddress(0,6,0), "a string"); //A7 + // set a contiguous formula + rDoc.SetString(ScAddress(0,7,0), "=$A$6"); //A8 + } + // save and reload + ScDocShellRef xNewDocSh = saveAndReload(xOrigDocSh.get(), FORMAT_ODS); + xOrigDocSh->DoClose(); + CPPUNIT_ASSERT(xNewDocSh.is()); + ScDocument& rDoc = xNewDocSh->GetDocument(); + CPPUNIT_ASSERT_MESSAGE("Reloaded document should at least have one sheet.", rDoc.GetTableCount() > 0); + + // check value + CPPUNIT_ASSERT_EQUAL(2.0, rDoc.GetValue(0,0,0)); + CPPUNIT_ASSERT_EQUAL(3.0, rDoc.GetValue(2,0,0)); + CPPUNIT_ASSERT_EQUAL(3.0, rDoc.GetValue(3,0,0)); + CPPUNIT_ASSERT_EQUAL(7.5, rDoc.GetValue(4,0,0)); + CPPUNIT_ASSERT_EQUAL(3.0, rDoc.GetValue(5,0,0)); + + // check formula + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(4,0,0), "10*C1/4", "Wrong formula =10*C1/4"); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(7,0,0), "SUM(C1:F1)", "Wrong formula =SUM(C1:F1)"); + CPPUNIT_ASSERT_EQUAL(16.5, rDoc.GetValue(7,0,0)); + + // check string + ScRefCellValue aCell; + aCell.assign(rDoc, ScAddress(0,2,0)); + CPPUNIT_ASSERT_EQUAL( CELLTYPE_STRING, aCell.meType ); + + // check for an empty cell + aCell.assign(rDoc, ScAddress(0,3,0)); + CPPUNIT_ASSERT_EQUAL( CELLTYPE_NONE, aCell.meType); + + // check a digit string + aCell.assign(rDoc, ScAddress(0,4,0)); + CPPUNIT_ASSERT_EQUAL( CELLTYPE_STRING, aCell.meType); + + //check contiguous values + CPPUNIT_ASSERT_EQUAL( 12.0, rDoc.GetValue(0,5,0) ); + CPPUNIT_ASSERT_EQUAL( OUString("a string"), rDoc.GetString(0,6,0) ); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(0,7,0), "$A$6", "Wrong formula =$A$6"); + CPPUNIT_ASSERT_EQUAL( rDoc.GetValue(0,5,0), rDoc.GetValue(0,7,0) ); + + xNewDocSh->DoClose(); +} + +void ScExportTest::testCellNoteExportODS() +{ + ScDocShellRef xOrigDocSh = loadDoc("single-note.", FORMAT_ODS); + ScAddress aPos(0,0,0); // Start with A1. + { + ScDocument& rDoc = xOrigDocSh->GetDocument(); + + CPPUNIT_ASSERT_MESSAGE("There should be a note at A1.", rDoc.HasNote(aPos)); + + aPos.IncRow(); // Move to A2. + ScPostIt* pNote = rDoc.GetOrCreateNote(aPos); + pNote->SetText(aPos, "Note One"); + pNote->SetAuthor("Author One"); + CPPUNIT_ASSERT_MESSAGE("There should be a note at A2.", rDoc.HasNote(aPos)); + } + // save and reload + ScDocShellRef xNewDocSh = saveAndReload(xOrigDocSh.get(), FORMAT_ODS); + xOrigDocSh->DoClose(); + CPPUNIT_ASSERT(xNewDocSh.is()); + ScDocument& rDoc = xNewDocSh->GetDocument(); + + aPos.SetRow(0); // Move back to A1. + CPPUNIT_ASSERT_MESSAGE("There should be a note at A1.", rDoc.HasNote(aPos)); + aPos.IncRow(); // Move to A2. + CPPUNIT_ASSERT_MESSAGE("There should be a note at A2.", rDoc.HasNote(aPos)); + + xNewDocSh->DoClose(); +} + +void ScExportTest::testCellNoteExportXLS() +{ + // Start with an empty document.s + ScDocShellRef xOrigDocSh = loadDoc("notes-on-3-sheets.", FORMAT_ODS); + { + ScDocument& rDoc = xOrigDocSh->GetDocument(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("This document should have 3 sheets.", SCTAB(3), rDoc.GetTableCount()); + + // Check note's presence. + CPPUNIT_ASSERT( rDoc.HasNote(ScAddress(0,0,0))); + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,1,0))); + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,2,0))); + + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,0,1))); + CPPUNIT_ASSERT( rDoc.HasNote(ScAddress(0,1,1))); + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,2,1))); + + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,0,2))); + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,1,2))); + CPPUNIT_ASSERT( rDoc.HasNote(ScAddress(0,2,2))); + } + // save and reload as XLS. + ScDocShellRef xNewDocSh = saveAndReload(xOrigDocSh.get(), FORMAT_XLS); + { + xOrigDocSh->DoClose(); + CPPUNIT_ASSERT(xNewDocSh.is()); + ScDocument& rDoc = xNewDocSh->GetDocument(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("This document should have 3 sheets.", SCTAB(3), rDoc.GetTableCount()); + + // Check note's presence again. + CPPUNIT_ASSERT( rDoc.HasNote(ScAddress(0,0,0))); + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,1,0))); + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,2,0))); + + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,0,1))); + CPPUNIT_ASSERT( rDoc.HasNote(ScAddress(0,1,1))); + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,2,1))); + + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,0,2))); + CPPUNIT_ASSERT(!rDoc.HasNote(ScAddress(0,1,2))); + CPPUNIT_ASSERT( rDoc.HasNote(ScAddress(0,2,2))); + + xNewDocSh->DoClose(); + } +} + +namespace { + +void checkMatrixRange(ScDocument& rDoc, const ScRange& rRange) +{ + ScRange aMatRange; + ScAddress aMatOrigin; + for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol) + { + for (SCROW nRow = rRange.aStart.Row(); nRow <= rRange.aEnd.Row(); ++nRow) + { + ScAddress aPos(nCol, nRow, rRange.aStart.Tab()); + bool bIsMatrix = rDoc.GetMatrixFormulaRange(aPos, aMatRange); + CPPUNIT_ASSERT_MESSAGE("Matrix expected, but not found.", bIsMatrix); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong matrix range.", rRange, aMatRange); + const ScFormulaCell* pCell = rDoc.GetFormulaCell(aPos); + CPPUNIT_ASSERT_MESSAGE("This must be a formula cell.", pCell); + + bIsMatrix = pCell->GetMatrixOrigin(&rDoc, aMatOrigin); + CPPUNIT_ASSERT_MESSAGE("Not a part of matrix formula.", bIsMatrix); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong matrix origin.", aMatRange.aStart, aMatOrigin); + } + } +} + +} + +void ScExportTest::testInlineArrayXLS() +{ + ScDocShellRef xShell = loadDoc("inline-array.", FORMAT_XLS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLS); + xShell->DoClose(); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + // B2:C3 contains a matrix. + checkMatrixRange(rDoc, ScRange(1,1,0,2,2,0)); + + // B5:D6 contains a matrix. + checkMatrixRange(rDoc, ScRange(1,4,0,3,5,0)); + + // B8:C10 as well. + checkMatrixRange(rDoc, ScRange(1,7,0,2,9,0)); + + xDocSh->DoClose(); +} + +void ScExportTest::testEmbeddedChartODS() +{ + ScDocShellRef xShell = loadDoc("embedded-chart.", FORMAT_XLS); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pTempFile( + ScBootstrapFixture::exportTo(xShell.get(), FORMAT_ODS)); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport(pTempFile, m_xSFactory, "content.xml"); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, + "/office:document-content/office:body/office:spreadsheet/table:table[2]/table:table-row[7]/table:table-cell[2]/draw:frame/draw:object", + "notify-on-update-of-ranges", + "Chart1.B3:Chart1.B5 Chart1.C2:Chart1.C2 Chart1.C3:Chart1.C5"); + + xShell->DoClose(); +} + +void ScExportTest::testEmbeddedChartXLS() +{ + ScDocShellRef xShell = loadDoc("embedded-chart.", FORMAT_XLS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLS); + xShell->DoClose(); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + // Make sure the 2nd sheet is named 'Chart1'. + OUString aName; + rDoc.GetName(1, aName); + CPPUNIT_ASSERT_EQUAL(OUString("Chart1"), aName); + + const SdrOle2Obj* pOleObj = getSingleChartObject(rDoc, 1); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve a chart object from the 2nd sheet.", pOleObj); + + ScRangeList aRanges = getChartRanges(rDoc, *pOleObj); + CPPUNIT_ASSERT_MESSAGE("Label range (B3:B5) not found.", aRanges.In(ScRange(1,2,1,1,4,1))); + CPPUNIT_ASSERT_MESSAGE("Data label (C2) not found.", aRanges.In(ScAddress(2,1,1))); + CPPUNIT_ASSERT_MESSAGE("Data range (C3:C5) not found.", aRanges.In(ScRange(2,2,1,2,4,1))); + + xDocSh->DoClose(); +} + +void ScExportTest::testCellAnchoredGroupXLS() +{ + ScDocShellRef xDocSh_in = loadDoc("cell-anchored-group.", FORMAT_XLS); + CPPUNIT_ASSERT_MESSAGE("Failed to load cell-anchored-group.xls", xDocSh_in.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xDocSh_in), FORMAT_ODS); + CPPUNIT_ASSERT_MESSAGE("Failed to save and reload cell-anchored-group.ods", xDocSh.is()); + + // the document contains a group anchored on the first cell, make sure it's there in the right place + ScDocument& rDoc = xDocSh->GetDocument(); + CPPUNIT_ASSERT_MESSAGE("There should be at least one sheet.", rDoc.GetTableCount() > 0); + ScDrawLayer* pDrawLayer = rDoc.GetDrawLayer(); + SdrPage* pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("draw page for sheet 1 should exist.", pPage); + const size_t nCount = pPage->GetObjCount(); + CPPUNIT_ASSERT_EQUAL_MESSAGE( + "There should be 1 objects.", static_cast<size_t>(1), nCount); + + SdrObject* pObj = pPage->GetObj(0); + CPPUNIT_ASSERT_MESSAGE("Failed to get drawing object.", pObj); + ScDrawObjData* pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + CPPUNIT_ASSERT_MESSAGE("Upper left of bounding rectangle should be nonnegative.", + pData->getShapeRect().Left() >= 0 || pData->getShapeRect().Top() >= 0); + xDocSh->DoClose(); +} + +void ScExportTest::testFormulaReferenceXLS() +{ + ScDocShellRef xShell = loadDoc("formula-reference.", FORMAT_XLS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLS); + xShell->DoClose(); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(3,1,0), "$A$2+$B$2+$C$2", "Wrong formula in D2"); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(3,2,0), "A3+B3+C3", "Wrong formula in D3"); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(3,5,0), "SUM($A$6:$C$6)", "Wrong formula in D6"); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(3,6,0), "SUM(A7:C7)", "Wrong formula in D7"); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(3,9,0), "$Two.$A$2+$Two.$B$2+$Two.$C$2", "Wrong formula in D10"); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(3,10,0), "$Two.A3+$Two.B3+$Two.C3", "Wrong formula in D11"); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(3,13,0), "MIN($Two.$A$2:$C$2)", "Wrong formula in D14"); + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(3,14,0), "MAX($Two.A3:C3)", "Wrong formula in D15"); + + xDocSh->DoClose(); +} + +void ScExportTest::testSheetProtectionXLSX() +{ + ScDocShellRef xShell = loadDoc("ProtecteSheet1234Pass.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + const ScTableProtection* pTabProtect = rDoc.GetTabProtection(0); + CPPUNIT_ASSERT(pTabProtect); + Sequence<sal_Int8> aHash = pTabProtect->getPasswordHash(PASSHASH_XL); + // check has + if (aHash.getLength() >= 2) + { + CPPUNIT_ASSERT_EQUAL(sal_uInt8(204), static_cast<sal_uInt8>(aHash[0])); + CPPUNIT_ASSERT_EQUAL(sal_uInt8(61), static_cast<sal_uInt8>(aHash[1])); + } + // we could flesh out this check I guess + CPPUNIT_ASSERT ( !pTabProtect->isOptionEnabled( ScTableProtection::OBJECTS ) ); + CPPUNIT_ASSERT ( !pTabProtect->isOptionEnabled( ScTableProtection::SCENARIOS ) ); + xDocSh->DoClose(); +} + +void ScExportTest::testSheetProtectionXLSB() +{ + ScDocShellRef xShell = loadDoc("tdf108017_calcProtection.", FORMAT_XLSB); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + const ScTableProtection* pTabProtect = rDoc.GetTabProtection(0); + CPPUNIT_ASSERT(pTabProtect); + CPPUNIT_ASSERT(pTabProtect->isOptionEnabled( ScTableProtection::SELECT_UNLOCKED_CELLS )); + CPPUNIT_ASSERT(!pTabProtect->isOptionEnabled( ScTableProtection::SELECT_LOCKED_CELLS )); + xDocSh->DoClose(); +} + +namespace { + +const char* toBorderName( SvxBorderLineStyle eStyle ) +{ + switch (eStyle) + { + case SvxBorderLineStyle::SOLID: return "SOLID"; + case SvxBorderLineStyle::DOTTED: return "DOTTED"; + case SvxBorderLineStyle::DASHED: return "DASHED"; + case SvxBorderLineStyle::DASH_DOT: return "DASH_DOT"; + case SvxBorderLineStyle::DASH_DOT_DOT: return "DASH_DOT_DOT"; + case SvxBorderLineStyle::DOUBLE_THIN: return "DOUBLE_THIN"; + case SvxBorderLineStyle::FINE_DASHED: return "FINE_DASHED"; + default: + ; + } + + return ""; +} + +} + +void ScExportTest::testExcelCellBorders( sal_uLong nFormatType ) +{ + static const struct + { + SCROW mnRow; + SvxBorderLineStyle mnStyle; + long mnWidth; + } aChecks[] = { + { 1, SvxBorderLineStyle::SOLID, 1 }, // hair + { 3, SvxBorderLineStyle::DOTTED, 15 }, // dotted + { 5, SvxBorderLineStyle::DASH_DOT_DOT, 15 }, // dash dot dot + { 7, SvxBorderLineStyle::DASH_DOT, 15 }, // dash dot + { 9, SvxBorderLineStyle::FINE_DASHED, 15 }, // dashed + { 11, SvxBorderLineStyle::SOLID, 15 }, // thin + { 13, SvxBorderLineStyle::DASH_DOT_DOT, 35 }, // medium dash dot dot + { 17, SvxBorderLineStyle::DASH_DOT, 35 }, // medium dash dot + { 19, SvxBorderLineStyle::DASHED, 35 }, // medium dashed + { 21, SvxBorderLineStyle::SOLID, 35 }, // medium + { 23, SvxBorderLineStyle::SOLID, 50 }, // thick + { 25, SvxBorderLineStyle::DOUBLE_THIN, -1 }, // double (don't check width) + }; + + ScDocShellRef xDocSh = loadDoc("cell-borders.", nFormatType); + CPPUNIT_ASSERT_MESSAGE("Failed to load file", xDocSh.is()); + { + ScDocument& rDoc = xDocSh->GetDocument(); + + for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i) + { + const editeng::SvxBorderLine* pLine = nullptr; + rDoc.GetBorderLines(2, aChecks[i].mnRow, 0, nullptr, &pLine, nullptr, nullptr); + CPPUNIT_ASSERT(pLine); + CPPUNIT_ASSERT_EQUAL(toBorderName(aChecks[i].mnStyle), toBorderName(pLine->GetBorderLineStyle())); + if (aChecks[i].mnWidth >= 0) + CPPUNIT_ASSERT_EQUAL(aChecks[i].mnWidth, pLine->GetWidth()); + } + } + + ScDocShellRef xNewDocSh = saveAndReload(xDocSh.get(), nFormatType); + xDocSh->DoClose(); + ScDocument& rDoc = xNewDocSh->GetDocument(); + for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i) + { + const editeng::SvxBorderLine* pLine = nullptr; + rDoc.GetBorderLines(2, aChecks[i].mnRow, 0, nullptr, &pLine, nullptr, nullptr); + CPPUNIT_ASSERT(pLine); + CPPUNIT_ASSERT_EQUAL(toBorderName(aChecks[i].mnStyle), toBorderName(pLine->GetBorderLineStyle())); + if (aChecks[i].mnWidth >= 0) + CPPUNIT_ASSERT_EQUAL(aChecks[i].mnWidth, pLine->GetWidth()); + } + + xNewDocSh->DoClose(); +} + +void ScExportTest::testCellBordersXLS() +{ + testExcelCellBorders(FORMAT_XLS); +} + +void ScExportTest::testCellBordersXLSX() +{ + testExcelCellBorders(FORMAT_XLSX); +} + +void ScExportTest::testBordersExchangeXLSX() +{ + // Document: sc/qa/unit/data/README.cellborders + + // short name for the table + const SvxBorderLineStyle None = SvxBorderLineStyle::NONE; + const SvxBorderLineStyle Solid = SvxBorderLineStyle::SOLID; + const SvxBorderLineStyle Dotted = SvxBorderLineStyle::DOTTED; + const SvxBorderLineStyle Dashed = SvxBorderLineStyle::DASHED; + const SvxBorderLineStyle FineDash = SvxBorderLineStyle::FINE_DASHED; + const SvxBorderLineStyle DashDot = SvxBorderLineStyle::DASH_DOT; + const SvxBorderLineStyle DashDoDo = SvxBorderLineStyle::DASH_DOT_DOT; + const SvxBorderLineStyle DoubThin = SvxBorderLineStyle::DOUBLE_THIN; + + const size_t nMaxCol = 18; + const size_t nMaxRow = 7; + + static struct + { + SvxBorderLineStyle BorderStyleTop, BorderStyleBottom; + long WidthTop, WidthBottom; + } aCheckBorderWidth[nMaxCol][nMaxRow] = + { +/* Line 1 2 3 4 5 6 7 + SOLID DOTTED DASHED FINE_DASHED DASH_DOT DASH_DOT_DOT DOUBLE_THIN */ +/*Width */ +/* 0,05 */ {{Solid , Solid , 1, 1}, {Dotted , Dotted , 15, 15}, {Dotted , Dotted , 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {None , None , 0, 0}}, +/* 0,25 */ {{Solid , Solid , 1, 1}, {Dotted , Dotted , 15, 15}, {Dotted , Dotted , 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {None , None , 0, 0}}, +/* 0,50 */ {{Solid , Solid , 1, 1}, {Dotted , Dotted , 15, 15}, {Dotted , Dotted , 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {None , None , 0, 0}}, +/* 0,75 */ {{Solid , Solid , 15, 15}, {Dotted , Dotted , 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {DashDot , DashDot , 15, 15}, {DashDoDo, DashDoDo, 15, 15}, {DoubThin, DoubThin, 35, 35}}, +/* 1,00 */ {{Solid , Solid , 15, 15}, {Dotted , Dotted , 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {DashDot , DashDot , 15, 15}, {DashDoDo, DashDoDo, 15, 15}, {DoubThin, DoubThin, 35, 35}}, +/* 1,25 */ {{Solid , Solid , 15, 15}, {Dotted , Dotted , 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {DashDot , DashDot , 15, 15}, {DashDoDo, DashDoDo, 15, 15}, {DoubThin, DoubThin, 35, 35}}, +/* 1,50 */ {{Solid , Solid , 15, 15}, {Dotted , Dotted , 15, 15}, {FineDash, FineDash, 15, 15}, {FineDash, FineDash, 15, 15}, {DashDot , DashDot , 15, 15}, {DashDoDo, DashDoDo, 15, 15}, {DoubThin, DoubThin, 35, 35}}, + +/* 1,75 */ {{Solid , Solid , 35, 35}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 2,00 */ {{Solid , Solid , 35, 35}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 2,25 */ {{Solid , Solid , 35, 35}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, + +/* 2,50 */ {{Solid , Solid , 50, 50}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 2,75 */ {{Solid , Solid , 50, 50}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 3,00 */ {{Solid , Solid , 50, 50}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 3,50 */ {{Solid , Solid , 50, 50}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 4,00 */ {{Solid , Solid , 50, 50}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 5,00 */ {{Solid , Solid , 50, 50}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 7,00 */ {{Solid , Solid , 50, 50}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}}, +/* 9,00 */ {{Solid , Solid , 50, 50}, {FineDash, FineDash, 35, 35}, {Dashed , Dashed , 35, 35}, {FineDash, FineDash, 35, 35}, {DashDot , DashDot , 35, 35}, {DashDoDo, DashDoDo, 35, 35}, {DoubThin, DoubThin, 35, 35}} + }; + + ScDocShellRef xShell = loadDoc("test_borders_export.", FORMAT_ODS); // load the ods with our Borders + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); // save the ods to xlsx and load xlsx + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument& rDoc = xDocSh->GetDocument(); + + for (size_t nCol = 0; nCol < nMaxCol; ++nCol) + { + for (size_t nRow = 0; nRow < nMaxRow; ++nRow) + { + const editeng::SvxBorderLine* pLineTop = nullptr; + const editeng::SvxBorderLine* pLineBottom = nullptr; + rDoc.GetBorderLines(nCol + 2, (nRow * 2) + 8, 0, nullptr, &pLineTop, nullptr, &pLineBottom); + if((nCol < 3) && (nRow == 6)) + { // in this range no lines since minimum size to create a double is 0.5 + CPPUNIT_ASSERT(!pLineTop); + CPPUNIT_ASSERT(!pLineBottom); + continue; + } + else + { + CPPUNIT_ASSERT(pLineTop); + CPPUNIT_ASSERT(pLineBottom); + } + + CPPUNIT_ASSERT_EQUAL_MESSAGE("Top Border-Line-Style wrong", aCheckBorderWidth[nCol][nRow].BorderStyleTop, + pLineTop->GetBorderLineStyle()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Bottom Border-Line-Style wrong", aCheckBorderWidth[nCol][nRow].BorderStyleBottom, + pLineBottom->GetBorderLineStyle()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Top Width-Line wrong", aCheckBorderWidth[nCol][nRow].WidthTop, + pLineTop->GetWidth()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Bottom Width-Line wrong", aCheckBorderWidth[nCol][nRow].WidthBottom, + pLineBottom->GetWidth()); + } + } + + xDocSh->DoClose(); +} + +static OUString toString( const ScBigRange& rRange ) +{ + OUStringBuffer aBuf; + aBuf.append("(columns:"); + aBuf.append(rRange.aStart.Col()); + aBuf.append('-'); + aBuf.append(rRange.aEnd.Col()); + aBuf.append(";rows:"); + aBuf.append(rRange.aStart.Row()); + aBuf.append('-'); + aBuf.append(rRange.aEnd.Row()); + aBuf.append(";sheets:"); + aBuf.append(rRange.aStart.Tab()); + aBuf.append('-'); + aBuf.append(rRange.aEnd.Tab()); + aBuf.append(')'); + + return aBuf.makeStringAndClear(); +} + +void ScExportTest::testTrackChangesSimpleXLSX() +{ + struct CheckItem + { + sal_uLong mnActionId; + ScChangeActionType meType; + + sal_Int32 mnStartCol; + sal_Int32 mnStartRow; + sal_Int32 mnStartTab; + sal_Int32 mnEndCol; + sal_Int32 mnEndRow; + sal_Int32 mnEndTab; + + bool mbRowInsertedAtBottom; + }; + + struct + { + bool checkRange( ScChangeActionType eType, const ScBigRange& rExpected, const ScBigRange& rActual ) + { + ScBigRange aExpected(rExpected), aActual(rActual); + + switch (eType) + { + case SC_CAT_INSERT_ROWS: + { + // Ignore columns. + aExpected.aStart.SetCol(0); + aExpected.aEnd.SetCol(0); + aActual.aStart.SetCol(0); + aActual.aEnd.SetCol(0); + } + break; + default: + ; + } + + return aExpected == aActual; + } + + bool check( const ScDocument& rDoc ) + { + static const CheckItem aChecks[] = + { + { 1, SC_CAT_CONTENT , 1, 1, 0, 1, 1, 0, false }, + { 2, SC_CAT_INSERT_ROWS , 0, 2, 0, 0, 2, 0, true }, + { 3, SC_CAT_CONTENT , 1, 2, 0, 1, 2, 0, false }, + { 4, SC_CAT_INSERT_ROWS , 0, 3, 0, 0, 3, 0, true }, + { 5, SC_CAT_CONTENT , 1, 3, 0, 1, 3, 0, false }, + { 6, SC_CAT_INSERT_ROWS , 0, 4, 0, 0, 4, 0, true }, + { 7, SC_CAT_CONTENT , 1, 4, 0, 1, 4, 0, false }, + { 8, SC_CAT_INSERT_ROWS , 0, 5, 0, 0, 5, 0, true }, + { 9, SC_CAT_CONTENT , 1, 5, 0, 1, 5, 0, false }, + { 10, SC_CAT_INSERT_ROWS , 0, 6, 0, 0, 6, 0, true }, + { 11, SC_CAT_CONTENT , 1, 6, 0, 1, 6, 0, false }, + { 12, SC_CAT_INSERT_ROWS , 0, 7, 0, 0, 7, 0, true }, + { 13, SC_CAT_CONTENT , 1, 7, 0, 1, 7, 0, false }, + }; + + ScChangeTrack* pCT = rDoc.GetChangeTrack(); + if (!pCT) + { + cerr << "Change track instance doesn't exist." << endl; + return false; + } + + sal_uLong nActionMax = pCT->GetActionMax(); + if (nActionMax != 13) + { + cerr << "Unexpected highest action ID value." << endl; + return false; + } + + for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i) + { + sal_uInt16 nActId = aChecks[i].mnActionId; + const ScChangeAction* pAction = pCT->GetAction(nActId); + if (!pAction) + { + cerr << "No action for action number " << nActId << " found." << endl; + return false; + } + + if (pAction->GetType() != aChecks[i].meType) + { + cerr << "Unexpected action type for action number " << nActId << "." << endl; + return false; + } + + const ScBigRange& rRange = pAction->GetBigRange(); + ScBigRange aCheck(aChecks[i].mnStartCol, aChecks[i].mnStartRow, aChecks[i].mnStartTab, + aChecks[i].mnEndCol, aChecks[i].mnEndRow, aChecks[i].mnEndTab); + + if (!checkRange(pAction->GetType(), aCheck, rRange)) + { + cerr << "Unexpected range for action number " << nActId + << ": expected=" << toString(aCheck) << " actual=" << toString(rRange) << endl; + return false; + } + + switch (pAction->GetType()) + { + case SC_CAT_INSERT_ROWS: + { + const ScChangeActionIns* p = static_cast<const ScChangeActionIns*>(pAction); + if (p->IsEndOfList() != aChecks[i].mbRowInsertedAtBottom) + { + cerr << "Unexpected end-of-list flag for action number " << nActId << "." << endl; + return false; + } + } + break; + default: + ; + } + } + + return true; + } + + bool checkRevisionUserAndTime( ScDocument& rDoc, const OUString& rOwnerName ) + { + ScChangeTrack* pCT = rDoc.GetChangeTrack(); + if (!pCT) + { + cerr << "Change track instance doesn't exist." << endl; + return false; + } + + ScChangeAction* pAction = pCT->GetLast(); + if (pAction->GetUser() != "Kohei Yoshida") + { + cerr << "Wrong user name." << endl; + return false; + } + + DateTime aDT = pAction->GetDateTime(); + if (aDT.GetYear() != 2014 || aDT.GetMonth() != 7 || aDT.GetDay() != 11) + { + cerr << "Wrong time stamp." << endl; + return false; + } + + // Insert a new record to make sure the user and date-time are correct. + rDoc.SetString(ScAddress(1,8,0), "New String"); + ScCellValue aEmpty; + pCT->AppendContent(ScAddress(1,8,0), aEmpty); + pAction = pCT->GetLast(); + if (!pAction) + { + cerr << "Failed to retrieve last revision." << endl; + return false; + } + + if (rOwnerName != pAction->GetUser()) + { + cerr << "Wrong user name." << endl; + return false; + } + + DateTime aDTNew = pAction->GetDateTime(); + if (aDTNew <= aDT) + { + cerr << "Time stamp of the new revision should be more recent than that of the last revision." << endl; + return false; + } + + return true; + } + + } aTest; + + SvtUserOptions& rUserOpt = SC_MOD()->GetUserOptions(); + rUserOpt.SetToken(UserOptToken::FirstName, "Export"); + rUserOpt.SetToken(UserOptToken::LastName, "Test"); + + OUString aOwnerName = rUserOpt.GetFirstName() + " " + rUserOpt.GetLastName(); + + // First, test the xls variant. + + ScDocShellRef xDocSh = loadDoc("track-changes/simple-cell-changes.", FORMAT_XLS); + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument* pDoc = &xDocSh->GetDocument(); + bool bGood = aTest.check(*pDoc); + CPPUNIT_ASSERT_MESSAGE("Initial check failed (xls).", bGood); + + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLS); + xDocSh->DoClose(); + pDoc = &xDocSh2->GetDocument(); + bGood = aTest.check(*pDoc); + CPPUNIT_ASSERT_MESSAGE("Check after reload failed (xls).", bGood); + + // fdo#81445 : Check the blank value string to make sure it's "<empty>". + ScChangeTrack* pCT = pDoc->GetChangeTrack(); + CPPUNIT_ASSERT(pCT); + ScChangeAction* pAction = pCT->GetAction(1); + CPPUNIT_ASSERT(pAction); + OUString aDesc; + pAction->GetDescription(aDesc, pDoc); + CPPUNIT_ASSERT_EQUAL(OUString("Cell B2 changed from '<empty>' to '1'"), aDesc); + + bGood = aTest.checkRevisionUserAndTime(*pDoc, aOwnerName); + CPPUNIT_ASSERT_MESSAGE("Check revision and time failed after reload (xls).", bGood); + + xDocSh2->DoClose(); + + // Now, test the xlsx variant the same way. + + xDocSh = loadDoc("track-changes/simple-cell-changes.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + pDoc = &xDocSh->GetDocument(); + aTest.check(*pDoc); + CPPUNIT_ASSERT_MESSAGE("Initial check failed (xlsx).", bGood); + + xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLSX); + xDocSh->DoClose(); + pDoc = &xDocSh2->GetDocument(); + bGood = aTest.check(*pDoc); + CPPUNIT_ASSERT_MESSAGE("Check after reload failed (xlsx).", bGood); + + bGood = aTest.checkRevisionUserAndTime(*pDoc, aOwnerName); + CPPUNIT_ASSERT_MESSAGE("Check revision and time failed after reload (xlsx).", bGood); + + xDocSh2->DoClose(); +} + +void ScExportTest::testSheetTabColorsXLSX() +{ + struct + { + bool checkContent( const ScDocument& rDoc ) + { + + std::vector<OUString> aTabNames = rDoc.GetAllTableNames(); + + // green, red, blue, yellow (from left to right). + if (aTabNames.size() != 4) + { + cerr << "There should be exactly 4 sheets." << endl; + return false; + } + + const char* pNames[] = { "Green", "Red", "Blue", "Yellow" }; + for (size_t i = 0; i < SAL_N_ELEMENTS(pNames); ++i) + { + OUString aExpected = OUString::createFromAscii(pNames[i]); + if (aExpected != aTabNames[i]) + { + cerr << "incorrect sheet name: expected='" << aExpected <<"', actual='" << aTabNames[i] << "'" << endl; + return false; + } + } + + static const Color aXclColors[] = + { + 0x0000B050, // green + 0x00FF0000, // red + 0x000070C0, // blue + 0x00FFFF00, // yellow + }; + + for (size_t i = 0; i < SAL_N_ELEMENTS(aXclColors); ++i) + { + if (aXclColors[i] != rDoc.GetTabBgColor(i)) + { + cerr << "wrong sheet color for sheet " << i << endl; + return false; + } + } + + return true; + } + + } aTest; + + ScDocShellRef xDocSh = loadDoc("sheet-tab-color.", FORMAT_XLSX); + { + CPPUNIT_ASSERT_MESSAGE("Failed to load file.", xDocSh.is()); + ScDocument& rDoc = xDocSh->GetDocument(); + bool bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Failed on the initial content check.", bRes); + } + + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to reload file.", xDocSh2.is()); + xDocSh->DoClose(); + ScDocument& rDoc = xDocSh2->GetDocument(); + bool bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Failed on the content check after reload.", bRes); + + xDocSh2->DoClose(); +} + +void ScExportTest::testSharedFormulaExportXLS() +{ + struct + { + bool checkContent( ScDocument& rDoc ) + { + formula::FormulaGrammar::Grammar eGram = formula::FormulaGrammar::GRAM_ENGLISH_XL_R1C1; + rDoc.SetGrammar(eGram); + sc::TokenStringContext aCxt(&rDoc, eGram); + + // Check the title row. + + OUString aActual = rDoc.GetString(0,1,0); + OUString aExpected = "Response"; + if (aActual != aExpected) + { + cerr << "Wrong content in A2: expected='" << aExpected << "', actual='" << aActual << "'" << endl; + return false; + } + + aActual = rDoc.GetString(1,1,0); + aExpected = "Response"; + if (aActual != aExpected) + { + cerr << "Wrong content in B2: expected='" << aExpected << "', actual='" << aActual << "'" << endl; + return false; + } + + // A3:A12 and B3:B12 are numbers from 1 to 10. + for (SCROW i = 0; i <= 9; ++i) + { + double fExpected = i + 1.0; + ScAddress aPos(0,i+2,0); + double fActual = rDoc.GetValue(aPos); + if (fExpected != fActual) + { + cerr << "Wrong value in A" << (i+2) << ": expected=" << fExpected << ", actual=" << fActual << endl; + return false; + } + + aPos.IncCol(); + ScFormulaCell* pFC = rDoc.GetFormulaCell(aPos); + if (!pFC) + { + cerr << "B" << (i+2) << " should be a formula cell." << endl; + return false; + } + + OUString aFormula = pFC->GetCode()->CreateString(aCxt, aPos); + aExpected = "Coefficients!RC[-1]"; + if (aFormula != aExpected) + { + cerr << "Wrong formula in B" << (i+2) << ": expected='" << aExpected << "', actual='" << aFormula << "'" << endl; + return false; + } + + fActual = rDoc.GetValue(aPos); + if (fExpected != fActual) + { + cerr << "Wrong value in B" << (i+2) << ": expected=" << fExpected << ", actual=" << fActual << endl; + return false; + } + } + + return true; + } + + } aTest; + + ScDocShellRef xDocSh = loadDoc("shared-formula/3d-reference.", FORMAT_ODS); + { + CPPUNIT_ASSERT_MESSAGE("Failed to load file.", xDocSh.is()); + ScDocument& rDoc = xDocSh->GetDocument(); + + // Check the content of the original. + bool bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Content check on the original document failed.", bRes); + } + + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLS); + xDocSh->DoClose(); + CPPUNIT_ASSERT_MESSAGE("Failed to reload file.", xDocSh2.is()); + + ScDocument& rDoc = xDocSh2->GetDocument(); + + // Check the content of the reloaded. This should be identical. + bool bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Content check on the reloaded document failed.", bRes); + + xDocSh2->DoClose(); +} + +void ScExportTest::testSharedFormulaExportXLSX() +{ + struct + { + bool checkContent( const ScDocument& rDoc ) + { + SCTAB nTabCount = rDoc.GetTableCount(); + if (nTabCount != 2) + { + cerr << "Document should have exactly 2 sheets. " << nTabCount << " found." << endl; + return false; + } + + // Make sure the sheet tab colors are not set. + for (SCROW i = 0; i <= 1; ++i) + { + Color aTabBgColor = rDoc.GetTabBgColor(i); + if (aTabBgColor != COL_AUTO) + { + cerr << "The tab color of Sheet " << (i+1) << " should not be explicitly set." << endl; + return false; + } + } + + // B2:B7 should show 1,2,3,4,5,6. + double fExpected = 1.0; + for (SCROW i = 1; i <= 6; ++i, ++fExpected) + { + ScAddress aPos(1,i,0); + double fVal = rDoc.GetValue(aPos); + if (fVal != fExpected) + { + cerr << "Wrong value in B" << (i+1) << ": expected=" << fExpected << ", actual=" << fVal << endl; + return false; + } + } + + // C2:C7 should show 10,20,...,60. + fExpected = 10.0; + for (SCROW i = 1; i <= 6; ++i, fExpected+=10.0) + { + ScAddress aPos(2,i,0); + double fVal = rDoc.GetValue(aPos); + if (fVal != fExpected) + { + cerr << "Wrong value in C" << (i+1) << ": expected=" << fExpected << ", actual=" << fVal << endl; + return false; + } + } + + // D2:D7 should show 1,2,...,6. + fExpected = 1.0; + for (SCROW i = 1; i <= 6; ++i, ++fExpected) + { + ScAddress aPos(3,i,0); + double fVal = rDoc.GetValue(aPos); + if (fVal != fExpected) + { + cerr << "Wrong value in D" << (i+1) << ": expected=" << fExpected << ", actual=" << fVal << endl; + return false; + } + } + + return true; + } + + } aTest; + + ScDocShellRef xDocSh = loadDoc("shared-formula/3d-reference.", FORMAT_XLSX); + { + CPPUNIT_ASSERT_MESSAGE("Failed to load file.", xDocSh.is()); + ScDocument& rDoc = xDocSh->GetDocument(); + + bool bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Content check on the initial document failed.", bRes); + + rDoc.CalcAll(); // Recalculate to flush all cached results. + bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Content check on the initial recalculated document failed.", bRes); + } + + // Save and reload, and check the content again. + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLSX); + xDocSh->DoClose(); + + CPPUNIT_ASSERT_MESSAGE("Failed to load file.", xDocSh2.is()); + ScDocument& rDoc = xDocSh2->GetDocument(); + rDoc.CalcAll(); // Recalculate to flush all cached results. + + bool bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Content check on the reloaded document failed.", bRes); + + xDocSh2->DoClose(); +} + +void ScExportTest::testSharedFormulaStringResultExportXLSX() +{ + struct + { + bool checkContent( const ScDocument& rDoc ) + { + { + // B2:B7 should show A,B,...,F. + const char* const expected[] = { "A", "B", "C", "D", "E", "F" }; + for (SCROW i = 0; i <= 5; ++i) + { + ScAddress aPos(1,i+1,0); + OUString aStr = rDoc.GetString(aPos); + OUString aExpected = OUString::createFromAscii(expected[i]); + if (aStr != aExpected) + { + cerr << "Wrong value in B" << (i+2) << ": expected='" << aExpected << "', actual='" << aStr << "'" << endl; + return false; + } + } + } + + { + // C2:C7 should show AA,BB,...,FF. + const char* const expected[] = { "AA", "BB", "CC", "DD", "EE", "FF" }; + for (SCROW i = 0; i <= 5; ++i) + { + ScAddress aPos(2,i+1,0); + OUString aStr = rDoc.GetString(aPos); + OUString aExpected = OUString::createFromAscii(expected[i]); + if (aStr != aExpected) + { + cerr << "Wrong value in C" << (i+2) << ": expected='" << aExpected << "', actual='" << aStr << "'" << endl; + return false; + } + } + } + + return true; + } + + } aTest; + + ScDocShellRef xDocSh = loadDoc("shared-formula/text-results.", FORMAT_XLSX); + { + CPPUNIT_ASSERT_MESSAGE("Failed to load file.", xDocSh.is()); + ScDocument& rDoc = xDocSh->GetDocument(); + + // Check content without re-calculation, to test cached formula results. + bool bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Content check on the initial document failed.", bRes); + + // Now, re-calculate and check the results. + rDoc.CalcAll(); + bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Content check on the initial recalculated document failed.", bRes); + } + // Reload and check again. + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLSX); + xDocSh->DoClose(); + CPPUNIT_ASSERT_MESSAGE("Failed to re-load file.", xDocSh2.is()); + ScDocument& rDoc = xDocSh2->GetDocument(); + + bool bRes = aTest.checkContent(rDoc); + CPPUNIT_ASSERT_MESSAGE("Content check on the reloaded document failed.", bRes); + + xDocSh2->DoClose(); +} + +void ScExportTest::testFunctionsExcel2010( sal_uLong nFormatType ) +{ + ScDocShellRef xShell = loadDoc("functions-excel-2010.", FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to load the document.", xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), nFormatType); + ScDocument& rDoc = xDocSh->GetDocument(); + rDoc.CalcAll(); // perform hard re-calculation. + + testFunctionsExcel2010_Impl(rDoc); + + xDocSh->DoClose(); +} + +void ScExportTest::testFunctionsExcel2010XLSX() +{ + testFunctionsExcel2010(FORMAT_XLSX); +} + +void ScExportTest::testFunctionsExcel2010XLS() +{ + testFunctionsExcel2010(FORMAT_XLS); +} + +void ScExportTest::testCeilingFloor( sal_uLong nFormatType ) +{ + ScDocShellRef xShell = loadDoc("ceiling-floor.", FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to load the document.", xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), nFormatType); + ScDocument& rDoc = xDocSh->GetDocument(); + rDoc.CalcAll(); // perform hard re-calculation. + + testCeilingFloor_Impl(rDoc); + + xDocSh->DoClose(); +} + +void ScExportTest::testCeilingFloorXLSX() +{ + testCeilingFloor(FORMAT_XLSX); +} + +void ScExportTest::testCeilingFloorODSToXLSX() +{ + // tdf#100011 - Cannot open sheet containing FLOOR/CEILING functions by MS Excel, after export to .xlsx + ScDocShellRef xShell = loadDoc("ceiling-floor.", FORMAT_ODS); + CPPUNIT_ASSERT_MESSAGE("Failed to load the document.", xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/workbook.xml"); + CPPUNIT_ASSERT(pSheet); + + // there shouldn't be any defined names during export of FLOOR and CEILING functions to .xlsx + assertXPath(pSheet, "/x:workbook/x:definedNames", 0); + + xShell->DoClose(); +} + +void ScExportTest::testCeilingFloorXLS() +{ + testCeilingFloor(FORMAT_XLS); +} + +void ScExportTest::testCeilingFloorODS() +{ + testCeilingFloor(FORMAT_ODS); +} + +void ScExportTest::testCustomXml() +{ + // Load document and export it to a temporary file + ScDocShellRef xShell = loadDoc("customxml.", FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to load the document.", xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xmlDocUniquePtr pXmlDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "customXml/item1.xml"); + CPPUNIT_ASSERT(pXmlDoc); + xmlDocUniquePtr pRelsDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "customXml/_rels/item1.xml.rels"); + CPPUNIT_ASSERT(pRelsDoc); + + // Check there is a relation to itemProps1.xml. + assertXPath(pRelsDoc, "/r:Relationships/r:Relationship", 1); + assertXPath(pRelsDoc, "/r:Relationships/r:Relationship[@Id='rId1']", "Target", "itemProps1.xml"); + + std::unique_ptr<SvStream> pStream = XPathHelper::parseExportStream(pXPathFile, m_xSFactory, "ddp/ddpfile.xen"); + CPPUNIT_ASSERT(pStream); + + xShell->DoClose(); +} + +#ifdef _WIN32 +static sal_Unicode lcl_getWindowsDrive(const OUString& aURL) +{ + static const sal_Int32 nMinLen = strlen("file:///X:/"); + if (aURL.getLength() <= nMinLen) + return 0; + const OUString aUrlStart = aURL.copy(0, nMinLen); + return (aUrlStart.startsWith("file:///") && aUrlStart.endsWith(":/")) ? aUrlStart[8] : 0; +} +#endif + +void ScExportTest::testRelativePathsODS() +{ + ScDocShellRef xDocSh = loadDoc("fdo79305.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + std::shared_ptr<utl::TempFile> pTempFile = exportTo(xDocSh.get(), FORMAT_ODS); + xmlDocUniquePtr pDoc = XPathHelper::parseExport(pTempFile, m_xSFactory, "content.xml"); + CPPUNIT_ASSERT(pDoc); + OUString aURL = getXPath(pDoc, + "/office:document-content/office:body/office:spreadsheet/table:table/table:table-row[2]/table:table-cell[2]/text:p/text:a", "href"); +#ifdef _WIN32 + // if the exported document is not on the same drive then the linked document, + // there is no way to get a relative URL for the link, because ../X:/ is undefined. + if (!aURL.startsWith("..")) + { + sal_Unicode aDocDrive = lcl_getWindowsDrive(pTempFile->GetURL()); + sal_Unicode aLinkDrive = lcl_getWindowsDrive(aURL); + CPPUNIT_ASSERT_MESSAGE("document on the same drive but no relative link!", + aDocDrive != 0 && aLinkDrive != 0 && aDocDrive != aLinkDrive); + return; + } +#endif + // make sure that the URL is relative + CPPUNIT_ASSERT(aURL.startsWith("..")); + + xDocSh->DoClose(); +} + +namespace { + +void testSheetProtection_Impl(const ScDocument& rDoc) +{ + CPPUNIT_ASSERT(rDoc.IsTabProtected(0)); + ScTableProtection* pTabProtection = rDoc.GetTabProtection(0); + CPPUNIT_ASSERT(pTabProtection); + CPPUNIT_ASSERT(pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS)); + CPPUNIT_ASSERT(!pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS)); +} + +} + +void ScExportTest::testSheetProtectionODS() +{ + ScDocShellRef xDocSh = loadDoc("sheet-protection.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + { + ScDocument& rDoc = xDocSh->GetDocument(); + testSheetProtection_Impl(rDoc); + } + + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_ODS); + { + ScDocument& rDoc = xDocSh2->GetDocument(); + testSheetProtection_Impl(rDoc); + } + + xDocSh2->DoClose(); +} + +void ScExportTest::testFunctionsExcel2010ODS() +{ + //testFunctionsExcel2010(FORMAT_ODS); +} + +void ScExportTest::testSwappedOutImageExport() +{ + const char* aFilterNames[] = { + "calc8", + "MS Excel 97", + "Calc Office Open XML", + "generic_HTML", + }; + + // Set cache size to a very small value to make sure one of the images is swapped out + std::shared_ptr< comphelper::ConfigurationChanges > xBatch(comphelper::ConfigurationChanges::create()); + officecfg::Office::Common::Cache::GraphicManager::TotalCacheSize::set(sal_Int32(1), xBatch); + xBatch->commit(); + + for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter ) + { + // Check whether the export code swaps in the image which was swapped out before. + ScDocShellRef xDocSh = loadDoc("document_with_two_images.", FORMAT_ODS); + + const OString sFailedMessage = OStringLiteral("Failed on filter: ") + aFilterNames[nFilter]; + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xDocSh.is()); + + // Export the document and import again for a check + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), nFilter); + xDocSh->DoClose(); + + // Check whether graphic exported well after it was swapped out + uno::Reference< frame::XModel > xModel = xDocSh2->GetModel(); + uno::Reference< sheet::XSpreadsheetDocument > xDoc(xModel, UNO_QUERY_THROW); + uno::Reference< container::XIndexAccess > xIA(xDoc->getSheets(), UNO_QUERY_THROW); + uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( xIA->getByIndex(0), UNO_QUERY_THROW); + uno::Reference< container::XIndexAccess > xDraws(xDrawPageSupplier->getDrawPage(), UNO_QUERY_THROW); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(2), xDraws->getCount()); + + uno::Reference<drawing::XShape> xImage(xDraws->getByIndex(0), uno::UNO_QUERY); + uno::Reference< beans::XPropertySet > XPropSet( xImage, uno::UNO_QUERY_THROW ); + + // Check Graphic, Size + { + uno::Reference<graphic::XGraphic> xGraphic; + XPropSet->getPropertyValue("Graphic") >>= xGraphic; + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xGraphic.is()); + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xGraphic->getType() != graphic::GraphicType::EMPTY); + uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY); + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xBitmap.is()); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(610), xBitmap->getSize().Width ); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(381), xBitmap->getSize().Height ); + } + // Second Image + xImage.set(xDraws->getByIndex(1), uno::UNO_QUERY); + XPropSet.set( xImage, uno::UNO_QUERY_THROW ); + + // Check Graphic, Size + { + uno::Reference<graphic::XGraphic> xGraphic; + XPropSet->getPropertyValue("Graphic") >>= xGraphic; + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xGraphic.is()); + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xGraphic->getType() != graphic::GraphicType::EMPTY); + uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY); + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xBitmap.is()); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(900), xBitmap->getSize().Width ); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(600), xBitmap->getSize().Height ); + } + xDocSh2->DoClose(); + } +} + +ScExportTest::ScExportTest() + : ScBootstrapFixture("sc/qa/unit/data") +{ +} + +void ScExportTest::setUp() +{ + test::BootstrapFixture::setUp(); + + // This is a bit of a fudge, we do this to ensure that ScGlobals::ensure, + // which is a private symbol to us, gets called + m_xCalcComponent = + getMultiServiceFactory()->createInstance("com.sun.star.comp.Calc.SpreadsheetDocument"); + CPPUNIT_ASSERT_MESSAGE("no calc component!", m_xCalcComponent.is()); +} + +void ScExportTest::tearDown() +{ + uno::Reference< lang::XComponent >( m_xCalcComponent, UNO_QUERY_THROW )->dispose(); + test::BootstrapFixture::tearDown(); +} + +void ScExportTest::testSupBookVirtualPathXLS() +{ + ScDocShellRef xShell = loadDoc("external-ref.", FORMAT_XLS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLS); + xShell->DoClose(); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + ScAddress aPos(0,0,0); + ScTokenArray* pCode = getTokens(rDoc, aPos); + if (!pCode) + CppUnit::Asserter::fail("empty token array", CPPUNIT_SOURCELINE()); + + OUString aFormula = toString(rDoc, aPos, *pCode, rDoc.GetGrammar()); +#ifdef _WIN32 + aFormula = aFormula.copy(0, 9) + aFormula.copy(12); // strip drive letter, e.g. 'C:/' +#endif + OUString aExpectedFormula = OUStringLiteral("'file:///home/timar/Documents/external.xls'#$Sheet1.A1"); + if (aFormula != aExpectedFormula) + { + CppUnit::Asserter::failNotEqual(to_std_string(aExpectedFormula), + to_std_string(aFormula), CPPUNIT_SOURCELINE(), CppUnit::AdditionalMessage("Wrong SupBook VirtualPath URL")); + } + + xDocSh->DoClose(); +} + +void ScExportTest::testLinkedGraphicRT() +{ + // Problem was with linked images + const char* aFilterNames[] = { + "calc8", + "MS Excel 97", + "Calc Office Open XML", + "generic_HTML", + }; + + for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter ) + { + // Load the original file with one image + ScDocShellRef xDocSh = loadDoc("document_with_linked_graphic.", FORMAT_ODS); + const OString sFailedMessage = OStringLiteral("Failed on filter: ") + aFilterNames[nFilter]; + + // Export the document and import again for a check + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), nFilter); + xDocSh->DoClose(); + + // Check whether graphic imported well after export + ScDocument& rDoc = xDocSh->GetDocument(); + ScDrawLayer* pDrawLayer = rDoc.GetDrawLayer(); + CPPUNIT_ASSERT_MESSAGE( sFailedMessage.getStr(), pDrawLayer != nullptr ); + const SdrPage *pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE( sFailedMessage.getStr(), pPage != nullptr ); + SdrGrafObj* pObject = dynamic_cast<SdrGrafObj*>(pPage->GetObj(0)); + CPPUNIT_ASSERT_MESSAGE( sFailedMessage.getStr(), pObject != nullptr ); + CPPUNIT_ASSERT_MESSAGE( sFailedMessage.getStr(), pObject->IsLinkedGraphic() ); + + const GraphicObject& rGraphicObj = pObject->GetGraphicObject(true); + CPPUNIT_ASSERT_EQUAL_MESSAGE( sFailedMessage.getStr(), int(GraphicType::Bitmap), int(rGraphicObj.GetGraphic().GetType())); + CPPUNIT_ASSERT_EQUAL_MESSAGE( sFailedMessage.getStr(), sal_uLong(864900), rGraphicObj.GetGraphic().GetSizeBytes()); + + xDocSh2->DoClose(); + } +} + +void ScExportTest::testImageWithSpecialID() +{ + const char* aFilterNames[] = { + "calc8", + "MS Excel 97", + "Calc Office Open XML", + "generic_HTML", + }; + + // Trigger swap out mechanism to test swapped state factor too. + std::shared_ptr< comphelper::ConfigurationChanges > batch(comphelper::ConfigurationChanges::create()); + officecfg::Office::Common::Cache::GraphicManager::TotalCacheSize::set(sal_Int32(1), batch); + batch->commit(); + + for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter ) + { + ScDocShellRef xDocSh = loadDoc("images_with_special_IDs.", FORMAT_ODS); + + const OString sFailedMessage = OStringLiteral("Failed on filter: ") + aFilterNames[nFilter]; + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xDocSh.is()); + + // Export the document and import again for a check + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), nFilter); + xDocSh->DoClose(); + + // Check whether graphic was exported well + uno::Reference< frame::XModel > xModel = xDocSh2->GetModel(); + uno::Reference< sheet::XSpreadsheetDocument > xDoc(xModel, UNO_QUERY_THROW); + uno::Reference< container::XIndexAccess > xIA(xDoc->getSheets(), UNO_QUERY_THROW); + uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier( xIA->getByIndex(0), UNO_QUERY_THROW); + uno::Reference< container::XIndexAccess > xDraws(xDrawPageSupplier->getDrawPage(), UNO_QUERY_THROW); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(2), xDraws->getCount()); + + uno::Reference<drawing::XShape> xImage(xDraws->getByIndex(0), uno::UNO_QUERY); + uno::Reference< beans::XPropertySet > XPropSet( xImage, uno::UNO_QUERY_THROW ); + + // Check Graphic, Size + { + uno::Reference<graphic::XGraphic> xGraphic; + XPropSet->getPropertyValue("Graphic") >>= xGraphic; + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xGraphic.is()); + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xGraphic->getType() != graphic::GraphicType::EMPTY); + uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY); + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xBitmap.is()); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(610), xBitmap->getSize().Width ); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(381), xBitmap->getSize().Height ); + } + // Second Image + xImage.set(xDraws->getByIndex(1), uno::UNO_QUERY); + XPropSet.set( xImage, uno::UNO_QUERY_THROW ); + + // Check Graphic, Size + { + uno::Reference<graphic::XGraphic> xGraphic; + XPropSet->getPropertyValue("Graphic") >>= xGraphic; + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xGraphic.is()); + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xGraphic->getType() != graphic::GraphicType::EMPTY); + uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY); + CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xBitmap.is()); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(900), xBitmap->getSize().Width ); + CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(600), xBitmap->getSize().Height ); + } + xDocSh2->DoClose(); + } +} + +void ScExportTest::testAbsNamedRangeHTML() +{ + ScDocShellRef xDocSh = loadDoc("numberformat.", FORMAT_HTML); + xDocSh->DoHardRecalc(); + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_ODS); + xDocSh->DoClose(); + xDocSh2->DoHardRecalc(); + + ScDocument& rDoc = xDocSh2->GetDocument(); + ScRangeData* pRangeData = rDoc.GetRangeName()->findByUpperName(OUString("HTML_1")); + ScSingleRefData* pRef = pRangeData->GetCode()->FirstToken()->GetSingleRef(); + // see tdf#119141 for the reason why this isn't Sheet1.HTML_1 + CPPUNIT_ASSERT_MESSAGE("HTML_1 is an absolute reference",!pRef->IsTabRel()); + + xDocSh2->DoClose(); +} + +void ScExportTest::testSheetLocalRangeNameXLS() +{ + ScDocShellRef xDocSh = loadDoc("named-ranges-local.", FORMAT_XLS); + xDocSh->DoHardRecalc(); + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLS); + xDocSh->DoClose(); + xDocSh2->DoHardRecalc(); + + ScDocument& rDoc = xDocSh2->GetDocument(); + ScRangeName* pRangeName = rDoc.GetRangeName(0); + CPPUNIT_ASSERT(pRangeName); + CPPUNIT_ASSERT_EQUAL(size_t(2), pRangeName->size()); + + OUString aFormula; + rDoc.GetFormula(3, 11, 0, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("=SUM(local_name2)"), aFormula); + ASSERT_DOUBLES_EQUAL(14.0, rDoc.GetValue(3, 11, 0)); + + rDoc.GetFormula(6, 4, 0, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("=local_name1"), aFormula); + + xDocSh2->DoClose(); +} + +void ScExportTest::testRelativeNamedExpressionsXLS() +{ + ScDocShellRef xDocSh = loadDoc("tdf113991_relativeNamedRanges.", FORMAT_ODS); + xDocSh->DoHardRecalc(); + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLS); + xDocSh->DoClose(); + xDocSh2->DoHardRecalc(); + ScDocument& rDoc = xDocSh2->GetDocument(); + + // Sheet1:G3 + ScAddress aPos(6,2,0); + CPPUNIT_ASSERT_EQUAL(1.0, rDoc.GetValue(aPos)); + ASSERT_FORMULA_EQUAL(rDoc, aPos, "single_cell_A3", nullptr); + // Sheet2:F6 + aPos = ScAddress(5,5,1); + CPPUNIT_ASSERT_EQUAL(18.0, rDoc.GetValue(aPos)); + ASSERT_FORMULA_EQUAL(rDoc, aPos, "SUM(test_conflict)", nullptr); + // Sheet2:H3 + aPos = ScAddress(7,2,1); + CPPUNIT_ASSERT_EQUAL(10.0, rDoc.GetValue(aPos)); + ASSERT_FORMULA_EQUAL(rDoc, aPos, "single_global_A3", nullptr); + // Sheet2:H6 + aPos = ScAddress(7,5,1); + CPPUNIT_ASSERT_EQUAL(75.0, rDoc.GetValue(aPos)); + ASSERT_FORMULA_EQUAL(rDoc, aPos, "SUM(A6:F6)", nullptr); + xDocSh2->DoClose(); +} + +void ScExportTest::testSheetTextBoxHyperlinkXLSX() +{ + ScDocShellRef xShell = loadDoc("textbox-hyperlink.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/drawing1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "/xdr:wsDr[1]/xdr:twoCellAnchor[1]/xdr:sp[1]/xdr:nvSpPr[1]/xdr:cNvPr[1]/a:hlinkClick[1]", 1); + + xDocSh->DoClose(); +} + +void ScExportTest::testFontSizeXLSX() +{ + ScDocShellRef xDocSh = loadDoc("fontSize.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/drawing1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + OUString fontSize = getXPath(pDoc, + "/xdr:wsDr/xdr:twoCellAnchor/xdr:sp[1]/xdr:txBody/a:p[1]/a:r[1]/a:rPr", "sz"); + // make sure that the font size is 18 + CPPUNIT_ASSERT_EQUAL(OUString("1800"), fontSize); + + xDocSh->DoClose(); +} + +void ScExportTest::testSheetCharacterKerningSpaceXLSX() +{ + ScDocShellRef xShell = loadDoc("textbox-CharKerningSpace.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/drawing1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + OUString CharKerningSpace = getXPath(pDoc, + "/xdr:wsDr[1]/xdr:twoCellAnchor[1]/xdr:sp[1]/xdr:txBody[1]/a:p[1]/a:r[1]/a:rPr[1]","spc"); + + // make sure that the CharKerning is 1997. + CPPUNIT_ASSERT_EQUAL(OUString("1997"), CharKerningSpace); + + xDocSh->DoClose(); +} + +void ScExportTest::testSheetCondensedCharacterSpaceXLSX() +{ + ScDocShellRef xShell = loadDoc("textbox-CondensedCharacterSpace.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/drawing1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + OUString CondensedCharSpace = getXPath(pDoc, + "/xdr:wsDr[1]/xdr:twoCellAnchor[1]/xdr:sp[1]/xdr:txBody[1]/a:p[1]/a:r[1]/a:rPr[1]","spc"); + + // make sure that the CondensedCharSpace is -1002. + CPPUNIT_ASSERT_EQUAL(OUString("-1002"), CondensedCharSpace); + + xDocSh->DoClose(); +} + +void ScExportTest::testTextUnderlineColorXLSX() +{ + ScDocShellRef xDocSh = loadDoc("underlineColor.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/drawing1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + // Make sure the underline type is double line + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[1]/xdr:sp[1]/xdr:txBody/a:p[1]/a:r[1]/a:rPr", "u", "dbl"); + + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[1]/xdr:sp[1]/xdr:txBody/a:p[1]/a:r[1]/a:rPr", "b", "1"); + // Make sure that the underline color is RED + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[1]/xdr:sp[1]/xdr:txBody/a:p[1]/a:r[1]/a:rPr/a:uFill/a:solidFill/a:srgbClr", "val", "ff0000"); + + // Make sure the underline type is drawn with heavy line + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[2]/xdr:sp[1]/xdr:txBody/a:p[1]/a:r[1]/a:rPr", "u", "heavy"); + // tdf#104219 Make sure that uFill is not existing and uFillTx is set. + // It mean that color is automatic, should be the same color as the text. + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[2]/xdr:sp[1]/xdr:txBody/a:p[1]/a:r[1]/a:rPr/a:uFill", 0); + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[2]/xdr:sp[1]/xdr:txBody/a:p[1]/a:r[1]/a:rPr/a:uFillTx", 1); + + xDocSh->DoClose(); +} + +void ScExportTest::testSheetRunParagraphPropertyXLSX() +{ + ScDocShellRef xShell = loadDoc("TextColor.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/sharedStrings.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + OUString aColor = getXPath(pDoc, "/x:sst/x:si/x:r[1]/x:rPr[1]/x:color", "rgb"); + CPPUNIT_ASSERT_EQUAL(OUString("FFFF0000"), aColor); + + xDocSh->DoClose(); +} + +void ScExportTest::testPreserveTextWhitespaceXLSX() +{ + ScDocShellRef xShell = loadDoc("preserve-whitespace.", FORMAT_XLSX); + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/sharedStrings.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/x:sst/x:si/x:t", "space", "preserve"); + xDocSh->DoClose(); +} + +void ScExportTest::testPreserveTextWhitespace2XLSX() +{ + ScDocShellRef xShell = loadDoc("preserve_space.", FORMAT_XLSX); + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/sharedStrings.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/x:sst/x:si[1]/x:t", "space", "preserve"); + assertXPath(pDoc, "/x:sst/x:si[2]/x:r[1]/x:t", "space", "preserve"); + assertXPath(pDoc, "/x:sst/x:si[2]/x:r[2]/x:t", "space", "preserve"); + xDocSh->DoClose(); +} + +void ScExportTest::testHiddenShapeXLS() +{ + ScDocShellRef xDocSh = loadDoc("hiddenShape.", FORMAT_XLS); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + CPPUNIT_ASSERT(rDoc.GetTableCount() > 0); + ScDrawLayer* pDrawLayer = rDoc.GetDrawLayer(); + SdrPage* pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT(pPage); + SdrObject* pObj = pPage->GetObj(0); + CPPUNIT_ASSERT(pObj); + CPPUNIT_ASSERT_MESSAGE("Drawing object should not be visible.", !pObj->IsVisible()); + CPPUNIT_ASSERT_MESSAGE("Drawing object should not be printable.", !pObj->IsPrintable()); + xDocSh->DoClose(); +} + +void ScExportTest::testHiddenShapeXLSX() +{ + ScDocShellRef xDocSh = loadDoc("hiddenShape.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + CPPUNIT_ASSERT(rDoc.GetTableCount() > 0); + ScDrawLayer* pDrawLayer = rDoc.GetDrawLayer(); + SdrPage* pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT(pPage); + SdrObject* pObj = pPage->GetObj(0); + CPPUNIT_ASSERT(pObj); + CPPUNIT_ASSERT_MESSAGE("Drawing object should not be visible.", !pObj->IsVisible()); + CPPUNIT_ASSERT_MESSAGE("Drawing object should not be printable.", !pObj->IsPrintable()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/drawing1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor/xdr:sp[1]/xdr:nvSpPr/xdr:cNvPr", "hidden", "1"); + xDocSh->DoClose(); +} + +void ScExportTest::testShapeAutofitXLSX() +{ + ScDocShellRef xDocSh = loadDoc("testShapeAutofit.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/drawing1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + // TextAutoGrowHeight --> "Fit height to text" / "Resize shape to fit text" --> true + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[1]/xdr:sp/xdr:txBody/a:bodyPr/a:spAutoFit", 1); + // TextAutoGrowHeight --> "Fit height to text" / "Resize shape to fit text" --> false + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[2]/xdr:sp/xdr:txBody/a:bodyPr/a:noAutofit", 1); + + xDocSh->DoClose(); +} + +void ScExportTest::testHyperlinkXLSX() +{ + ScDocShellRef xDocSh = loadDoc("hyperlink.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/_rels/drawing1.xml.rels", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/r:Relationships/r:Relationship", "Target", "#Sheet2!A1"); + + xDocSh->DoClose(); +} + +void ScExportTest::testMoveCellAnchoredShapesODS() +{ + ScDocShellRef xDocSh = loadDoc("move-cell-anchored-shapes.", FORMAT_ODS); + CPPUNIT_ASSERT_MESSAGE("Failed to load move-cell-anchored-shapes.ods", xDocSh.is()); + + // There are two cell-anchored objects on the first sheet. + ScDocument& rDoc = xDocSh->GetDocument(); + + CPPUNIT_ASSERT_MESSAGE("There should be at least one sheet.", rDoc.GetTableCount() > 0); + + ScDrawLayer* pDrawLayer = rDoc.GetDrawLayer(); + SdrPage* pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("draw page for sheet 1 should exist.", pPage); + SdrObject* pObj = pPage->GetObj(0); + CPPUNIT_ASSERT_MESSAGE("Failed to get drawing object.", pObj); + + // Check cell anchor state + ScAnchorType oldType = ScDrawLayer::GetAnchorType(*pObj); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "Failed to get anchor type", SCA_CELL_RESIZE, oldType); + + // Get anchor data + ScDrawObjData* pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pData->getShapeRect().IsEmpty()); + + ScAddress aDataStart = pData->maStart; + ScAddress aDataEnd = pData->maEnd; + + // Get non rotated anchor data + ScDrawObjData* pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pNData->getShapeRect().IsEmpty()); + + ScAddress aNDataStart = pNData->maStart; + ScAddress aNDataEnd = pNData->maEnd; + CPPUNIT_ASSERT_EQUAL(aDataStart, aNDataStart); + CPPUNIT_ASSERT_EQUAL(aDataEnd , aNDataEnd); + + // Insert 2 rows. + rDoc.InsertRow(ScRange( 0, aDataStart.Row() - 1, 0, MAXCOL, aDataStart.Row(), 0)); + + // Get anchor data + pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pData->getShapeRect().IsEmpty()); + + // Get non rotated anchor data + pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pNData->getShapeRect().IsEmpty()); + + // Check if data has moved to new rows + CPPUNIT_ASSERT_EQUAL( pData->maStart.Row(), aDataStart.Row() + 2 ); + CPPUNIT_ASSERT_EQUAL( pData->maEnd.Row(), aDataEnd.Row() + 2 ); + + CPPUNIT_ASSERT_EQUAL( pNData->maStart.Row(), aNDataStart.Row() + 2 ); + CPPUNIT_ASSERT_EQUAL( pNData->maEnd.Row(), aNDataEnd.Row() + 2 ); + + // Save the anchor data + aDataStart = pData->maStart; + aDataEnd = pData->maEnd; + aNDataStart = pNData->maStart; + aNDataEnd = pNData->maEnd; + + // Save the document and load again to check anchor persist + ScDocShellRef xDocSh1 = saveAndReload(&(*xDocSh), FORMAT_ODS); + + // There are two cell-anchored objects on the first sheet. + ScDocument& rDoc1 = xDocSh1->GetDocument(); + + CPPUNIT_ASSERT_MESSAGE("There should be at least one sheet.", rDoc1.GetTableCount() > 0); + + pDrawLayer = rDoc1.GetDrawLayer(); + pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("draw page for sheet 1 should exist.", pPage); + pObj = pPage->GetObj(0); + CPPUNIT_ASSERT_MESSAGE("Failed to get drawing object.", pObj); + + // Check cell anchor state + oldType = ScDrawLayer::GetAnchorType(*pObj); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "Failed to get anchor type", SCA_CELL_RESIZE, oldType); + + // Get anchor data + pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pData->getShapeRect().IsEmpty()); + + // Get non rotated anchor data + pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pNData->getShapeRect().IsEmpty()); + + // Check if data after save it + CPPUNIT_ASSERT_EQUAL(pData->maStart, aDataStart); + CPPUNIT_ASSERT_EQUAL(pData->maEnd , aDataEnd); + + CPPUNIT_ASSERT_EQUAL(pNData->maStart, aNDataStart); + CPPUNIT_ASSERT_EQUAL(pNData->maEnd , aNDataEnd); + + // Insert a column. + rDoc1.InsertCol(ScRange( aDataStart.Col(), 0 , 0 , aDataStart.Col(), MAXROW, 0 )); + + // Get anchor data + pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pData->getShapeRect().IsEmpty()); + + // Get non rotated anchor data + pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pNData->getShapeRect().IsEmpty()); + + // Check if data has moved to new rows + CPPUNIT_ASSERT_EQUAL(pData->maStart.Col(), SCCOL(aDataStart.Col() + 1)); + CPPUNIT_ASSERT_EQUAL(pData->maEnd.Col() , SCCOL(aDataEnd.Col() + 1)); + + CPPUNIT_ASSERT_EQUAL(pNData->maStart.Col(), SCCOL(aNDataStart.Col() + 1)); + CPPUNIT_ASSERT_EQUAL(pNData->maEnd.Col() , SCCOL(aNDataEnd.Col() + 1)); + + // Save the anchor data + aDataStart = pData->maStart; + aDataEnd = pData->maEnd; + aNDataStart = pNData->maStart; + aNDataEnd = pNData->maEnd; + + // Save the document and load again to check anchor persist + ScDocShellRef xDocSh2 = saveAndReload(&(*xDocSh1), FORMAT_ODS); + + // There are two cell-anchored objects on the first sheet. + ScDocument& rDoc2 = xDocSh2->GetDocument(); + + CPPUNIT_ASSERT_MESSAGE("There should be at least one sheet.", rDoc2.GetTableCount() > 0); + + pDrawLayer = rDoc2.GetDrawLayer(); + pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("draw page for sheet 1 should exist.", pPage); + pObj = pPage->GetObj(0); + CPPUNIT_ASSERT_MESSAGE("Failed to get drawing object.", pObj); + + // Check cell anchor state + oldType = ScDrawLayer::GetAnchorType(*pObj); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "Failed to get anchor type", SCA_CELL_RESIZE, oldType); + + // Get anchor data + pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pData->getShapeRect().IsEmpty()); + + // Get non rotated anchor data + pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + CPPUNIT_ASSERT_MESSAGE("Bounding rectangle should have been calculated upon import.", !pNData->getShapeRect().IsEmpty()); + + // Check if data after save it + CPPUNIT_ASSERT_EQUAL(pData->maStart, aDataStart); + CPPUNIT_ASSERT_EQUAL(pData->maEnd , aDataEnd); + + CPPUNIT_ASSERT_EQUAL(pNData->maStart, aNDataStart); + CPPUNIT_ASSERT_EQUAL(pNData->maEnd , aNDataEnd); + + xDocSh2->DoClose(); +} + +void ScExportTest::testMatrixMultiplicationXLSX() +{ + ScDocShellRef xShell = loadDoc("matrix-multiplication.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + OUString CellFormulaRange = getXPath(pDoc, + "/x:worksheet/x:sheetData/x:row[4]/x:c/x:f","ref"); + + // make sure that the CellFormulaRange is G5:G6. + CPPUNIT_ASSERT_EQUAL(OUString("G5:G6"), CellFormulaRange); + + OUString CellFormulaType = getXPath(pDoc, + "/x:worksheet/x:sheetData/x:row[4]/x:c/x:f","t"); + + // make sure that the CellFormulaType is array. + CPPUNIT_ASSERT_EQUAL(OUString("array"), CellFormulaType); + + xDocSh->DoClose(); +} + +void ScExportTest::testRefStringXLSX() +{ + ScDocShellRef xDocSh = loadDoc("ref_string.", FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to open doc", xDocSh.is()); + + //make sure ref syntax gets saved for MSO-produced docs + xDocSh = saveAndReload( &(*xDocSh), FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to reload doc", xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + ScCalcConfig aCalcConfig = rDoc.GetCalcConfig(); + CPPUNIT_ASSERT_EQUAL(formula::FormulaGrammar::CONV_XL_A1, aCalcConfig.meStringRefAddressSyntax); + + xDocSh->DoClose(); +} + +void ScExportTest::testRefStringConfigXLSX() +{ + // this doc is configured with CalcA1 ref syntax + ScDocShellRef xDocSh = loadDoc("empty.", FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to open doc", xDocSh.is()); + + xDocSh = saveAndReload( &(*xDocSh), FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to reload doc", xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + ScCalcConfig aConfig = rDoc.GetCalcConfig(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("String ref syntax doesn't match", formula::FormulaGrammar::CONV_OOO, + aConfig.meStringRefAddressSyntax); + + xDocSh->DoClose(); + + // this doc has no entry for ref syntax + xDocSh = loadDoc("empty-noconf.", FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to open 2nd doc", xDocSh.is()); + + ScDocument& rDoc2 = xDocSh->GetDocument(); + aConfig = rDoc2.GetCalcConfig(); + // therefore after import, ref syntax should be set to CalcA1 | ExcelA1 + CPPUNIT_ASSERT_EQUAL_MESSAGE("String ref syntax doesn't match", formula::FormulaGrammar::CONV_A1_XL_A1, + aConfig.meStringRefAddressSyntax); + + //set ref syntax to something else than ExcelA1 (native to xlsx format) ... + aConfig.meStringRefAddressSyntax = formula::FormulaGrammar::CONV_XL_R1C1; + rDoc2.SetCalcConfig( aConfig ); + + ScDocShellRef xNewDocSh = saveAndReload( &(*xDocSh), FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to reload 2nd doc", xNewDocSh.is()); + + // ... and make sure it got saved + ScDocument& rDoc3 = xNewDocSh->GetDocument(); + aConfig = rDoc3.GetCalcConfig(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("String ref syntax doesn't match", formula::FormulaGrammar::CONV_XL_R1C1, + aConfig.meStringRefAddressSyntax); + + xDocSh->DoClose(); + xNewDocSh->DoClose(); +} + +void ScExportTest::testRefStringUnspecified() +{ + ScDocShell* pShell = new ScDocShell( + SfxModelFlags::EMBEDDED_OBJECT | + SfxModelFlags::DISABLE_EMBEDDED_SCRIPTS | + SfxModelFlags::DISABLE_DOCUMENT_RECOVERY); + pShell->DoInitNew(); + + ScDocument& rDoc = pShell->GetDocument(); + ScCalcConfig aConfig = rDoc.GetCalcConfig(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Default string ref syntax value doesn't match", formula::FormulaGrammar::CONV_UNSPECIFIED, + aConfig.meStringRefAddressSyntax); + + // change formula syntax (i.e. not string ref syntax) to ExcelA1 + rDoc.SetGrammar( formula::FormulaGrammar::GRAM_NATIVE_XL_A1 ); + + ScDocShellRef xDocSh = saveAndReload(pShell, FORMAT_ODS); + CPPUNIT_ASSERT_MESSAGE("Failed to reload doc", xDocSh.is()); + + // with string ref syntax at its default value, we should've saved ExcelA1 + ScDocument& rDoc2 = xDocSh->GetDocument(); + aConfig = rDoc2.GetCalcConfig(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("String ref syntax doesn't match", formula::FormulaGrammar::CONV_XL_A1, + aConfig.meStringRefAddressSyntax); + + xDocSh->DoClose(); +} + +void ScExportTest::testHeaderImageODS() +{ + // Graphic as header background was lost on export. + ScDocShellRef xShell = loadDoc("header-image.", FORMAT_ODS); + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_ODS); + uno::Reference<style::XStyleFamiliesSupplier> xStyleFamiliesSupplier(xDocSh->GetModel(), uno::UNO_QUERY); + uno::Reference<container::XNameAccess> xStyleFamilies = xStyleFamiliesSupplier->getStyleFamilies(); + uno::Reference<container::XNameAccess> xPageStyles(xStyleFamilies->getByName("PageStyles"), uno::UNO_QUERY); + uno::Reference<beans::XPropertySet> xStyle(xPageStyles->getByName("Default"), uno::UNO_QUERY); + + uno::Reference<graphic::XGraphic> xGraphic; + xStyle->getPropertyValue("HeaderBackGraphic") >>= xGraphic; + CPPUNIT_ASSERT(xGraphic.is()); + xDocSh->DoClose(); +} + +void ScExportTest::testTextDirectionXLSX() +{ + ScDocShellRef xDocSh = loadDoc("writingMode.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "/x:styleSheet/x:cellXfs/x:xf[2]/x:alignment", "readingOrder", "1");//LTR + assertXPath(pDoc, "/x:styleSheet/x:cellXfs/x:xf[3]/x:alignment", "readingOrder", "2");//RTL + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf66668() +{ + // Would hang on exporting without the fix in place + ScDocShellRef xDocSh = loadDoc("tdf66668.", FORMAT_XLSX); + CPPUNIT_ASSERT_MESSAGE("Failed to open doc", xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + xDocSh->DoClose(); +} + +void ScExportTest::testTdf130108() +{ + ScDocShellRef xDocSh = loadDoc("tdf130108.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "/x:styleSheet/x:dxfs/x:dxf/x:font/x:b", "val", "1"); + assertXPath(pDoc, "/x:styleSheet/x:dxfs/x:dxf/x:font/x:i", "val", "0"); + assertXPath(pDoc, "/x:styleSheet/x:dxfs/x:dxf/x:font/x:color", "rgb", "FFFFFFFF"); + assertXPath(pDoc, "/x:styleSheet/x:dxfs/x:dxf/x:font/x:sz", "val", "10"); + assertXPath(pDoc, "/x:styleSheet/x:dxfs/x:dxf/x:fill/x:patternFill/x:bgColor", "rgb", "FFCC0000"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf76949() +{ + ScDocShellRef xDocSh = loadDoc("tdf76949.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pSheet = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pSheet); + + assertXPathContent(pSheet, "/x:worksheet/x:sheetData/x:row/x:c/x:f", "_xlfn.CHISQ.DIST(1,1,1)"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf55417() +{ + ScDocShellRef xDocSh = loadDoc("tdf55417.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/x:styleSheet/x:cellXfs/x:xf[1]/x:alignment", 1); + assertXPath(pDoc, "/x:styleSheet/x:cellXfs/x:xf[2]/x:alignment", 1); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf129985() +{ + ScDocShellRef xDocSh = loadDoc("tdf129985.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[2]", "formatCode", "m/d/yyyy"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf73063() +{ + ScDocShellRef xDocSh = loadDoc("tdf73063.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[2]", "formatCode", "[$-1C1A]dddd\", \"d\". \"mmmm\\ yyyy;@"); + + xDocSh->DoClose(); +} + +xmlDocUniquePtr ScExportTest::testTdf95640(const OUString& rFileName, sal_Int32 nSourceFormat, + sal_Int32 nDestFormat) +{ + ScDocShellRef xShell = loadDoc(rFileName, nSourceFormat); + CPPUNIT_ASSERT(xShell); + + auto pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), nDestFormat); + xShell->DoClose(); + + return XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); +} + +void ScExportTest::testTdf95640_ods_to_xlsx() +{ + // Roundtripping sort options with user defined list to XLSX + xmlDocUniquePtr pDoc = testTdf95640("tdf95640.", FORMAT_ODS, FORMAT_XLSX); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter", "ref", "A1:B4"); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter/x:sortState/x:sortCondition", "ref", "A2:A4"); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter/x:sortState/x:sortCondition", "customList", + "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"); +} + +void ScExportTest::testTdf95640_ods_to_xlsx_with_standard_list() +{ + // Roundtripping sort options with user defined list to XLSX + xmlDocUniquePtr pDoc = testTdf95640("tdf95640_standard_list.", FORMAT_ODS, FORMAT_XLSX); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter", "ref", "A1:B4"); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter/x:sortState/x:sortCondition", "ref", "A2:A4"); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter/x:sortState/x:sortCondition", "customList", + "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday"); +} + +void ScExportTest::testTdf95640_xlsx_to_xlsx() +{ + // XLSX Roundtripping sort options with custom sort list - note + // that compared to ODS source documents above, here we _actually_ + // can use custom lists (beyond the global user defines), like + // low, medium, high + xmlDocUniquePtr pDoc = testTdf95640("tdf95640.", FORMAT_XLSX, FORMAT_XLSX); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter", "ref", "A1:B4"); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter/x:sortState/x:sortCondition", "ref", "A2:A4"); + + assertXPath(pDoc, "//x:worksheet/x:autoFilter/x:sortState/x:sortCondition", "customList", + "Low,Medium,High"); +} + +void ScExportTest::testTdf88657ODS() +{ + ScDocShellRef xDocSh = loadDoc("tdf88657.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "styles.xml", FORMAT_ODS); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "//number:fraction", "min-denominator-digits", "3"); + + xDocSh->DoClose(); +} + +void ScExportTest::testConditionalFormatRangeListXLSX() +{ + ScDocShellRef xDocSh = loadDoc("conditionalformat_rangelist.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "//x:conditionalFormatting", "sqref", "F4 F10"); + + xDocSh->DoClose(); +} + +void ScExportTest::testConditionalFormatContainsTextXLSX() +{ + ScDocShellRef xDocSh = loadDoc("conditionalformat_containstext.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPathContent(pDoc, "//x:conditionalFormatting/x:cfRule/x:formula", "NOT(ISERROR(SEARCH(\"test\",A1)))"); + + xDocSh->DoClose(); +} + +void ScExportTest::testConditionalFormatPriorityCheckXLSX() +{ + ScDocShellRef xDocSh = loadDoc("conditional_fmt_checkpriority.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + constexpr bool bHighPriorityExtensionA1 = true; // Should A1's extension cfRule has higher priority than normal cfRule ? + constexpr bool bHighPriorityExtensionA3 = false; // Should A3's extension cfRule has higher priority than normal cfRule ? + + size_t nA1NormalPriority = 0; + size_t nA1ExtPriority = 0; + size_t nA3NormalPriority = 0; + size_t nA3ExtPriority = 0; + + for (size_t nIdx = 1; nIdx <= 2; ++nIdx) + { + OString aIdx = OString::number(nIdx); + OUString aCellAddr = getXPath(pDoc, "//x:conditionalFormatting[" + aIdx + "]", "sqref"); + OUString aPriority = getXPath(pDoc, "//x:conditionalFormatting[" + aIdx + "]/x:cfRule", "priority"); + + CPPUNIT_ASSERT_MESSAGE("conditionalFormatting sqref must be either A1 or A3", aCellAddr == "A1" || aCellAddr == "A3"); + + if (aCellAddr == "A1") + nA1NormalPriority = aPriority.toUInt32(); + else + nA3NormalPriority = aPriority.toUInt32(); + + aCellAddr = getXPathContent(pDoc, "//x:extLst/x:ext[1]/x14:conditionalFormattings/x14:conditionalFormatting[" + aIdx + "]/xm:sqref"); + aPriority = getXPath(pDoc, "//x:extLst/x:ext[1]/x14:conditionalFormattings/x14:conditionalFormatting[" + aIdx + "]/x14:cfRule", "priority"); + + CPPUNIT_ASSERT_MESSAGE("x14:conditionalFormatting sqref must be either A1 or A3", aCellAddr == "A1" || aCellAddr == "A3"); + + if (aCellAddr == "A1") + nA1ExtPriority = aPriority.toUInt32(); + else + nA3ExtPriority = aPriority.toUInt32(); + } + + CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong priorities for A1", bHighPriorityExtensionA1, nA1ExtPriority < nA1NormalPriority); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong priorities for A3", bHighPriorityExtensionA3, nA3ExtPriority < nA3NormalPriority); + + xDocSh->DoClose(); +} + +void ScExportTest::testConditionalFormatOriginXLSX() +{ + ScDocShellRef xDocSh = loadDoc("conditional_fmt_origin.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + // tdf#124953 : The range-list is B3:C6 F1:G2, origin address in the formula should be B1, not B3. + OUString aFormula = getXPathContent(pDoc, "//x:conditionalFormatting/x:cfRule/x:formula"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong origin address in formula", OUString("NOT(ISERROR(SEARCH(\"BAC\",B1)))"), aFormula); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf41722() +{ + ScDocShellRef xDocSh = loadDoc("tdf41722.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "//x:conditionalFormatting/x:cfRule[1]", "operator", "containsText"); + assertXPath(pDoc, "//x:conditionalFormatting/x:cfRule[2]", "operator", "containsText"); + assertXPath(pDoc, "//x:conditionalFormatting/x:cfRule[3]", "operator", "containsText"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf113621() +{ + ScDocShellRef xDocSh = loadDoc("tdf113621.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "//x:conditionalFormatting", "sqref", "A1:A1048576"); + + xDocSh->DoClose(); +} + +void ScExportTest::testEscapeCharInNumberFormatXLSX() +{ + ScDocShellRef xDocSh = loadDoc("tdf81939.", FORMAT_XLSX); + CPPUNIT_ASSERT( xDocSh.is() ); + xDocSh = saveAndReload( &(*xDocSh), FORMAT_XLSX); + CPPUNIT_ASSERT( xDocSh.is() ); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + const sal_Unicode cEuro (8364); // € symbol + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[2]", "formatCode", "00\\ 00\\ 00\\ 00\\ 00"); + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[3]", "formatCode", "00\\.00\\.00\\.000\\.0"); // tdf#81939 + // "_-* #,##0\ _€_-;\-* #,##0\ _€_-;_-* "- "_€_-;_-@_-" // tdf#81222 + OUString rFormatStrExpected ( "_-* #,##0\\ _" + OUStringChar(cEuro) + "_-;\\-* #,##0\\ _" + + OUStringChar(cEuro) + "_-;_-* \"- \"_" + OUStringChar(cEuro) + "_-;_-@_-" ); + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[4]", "formatCode", rFormatStrExpected ); + // "_-* #,##0" €"_-;\-* #,##0" €"_-;_-* "- €"_-;_-@_-"); + rFormatStrExpected = "_-* #,##0\" " + OUStringChar(cEuro) + "\"_-;\\-* #,##0\" " + + OUStringChar(cEuro) + "\"_-;_-* \"- " + OUStringChar(cEuro) + "\"_-;_-@_-"; + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[5]", "formatCode", rFormatStrExpected ); + // remove escape char in fraction + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[6]", "formatCode", "# ?/?;[RED]\\-# #/#####"); + + xDocSh->DoClose(); +} + +void ScExportTest::testNatNumInNumberFormatXLSX() +{ + ScDocShellRef xDocSh = loadDoc("tdf79398_NatNum5.", FORMAT_ODS); + CPPUNIT_ASSERT( xDocSh.is() ); + xDocSh = saveAndReload( &(*xDocSh), FORMAT_XLSX); // Convert [NatNum5] to [DBNum2] in Chinese + CPPUNIT_ASSERT( xDocSh.is() ); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[3]", "formatCode", "[DBNum2][$-804]General;[RED][DBNum2][$-804]General"); + + xDocSh->DoClose(); +} + +void ScExportTest::testExponentWithoutSignFormatXLSX() +{ + ScDocShellRef xDocSh = loadDoc("tdf102370_ExponentWithoutSign.", FORMAT_ODS); + CPPUNIT_ASSERT( xDocSh.is() ); + xDocSh = saveAndReload( &(*xDocSh), FORMAT_XLSX); + CPPUNIT_ASSERT( xDocSh.is() ); + + xDocSh = saveAndReload( &(*xDocSh), FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + sal_uInt32 nNumberFormat; + rDoc.GetNumberFormat(0, 0, 0, nNumberFormat); + const SvNumberformat* pNumberFormat = rDoc.GetFormatTable()->GetEntry(nNumberFormat); + const OUString& rFormatStr = pNumberFormat->GetFormatstring(); + const OUString aExpectedFormatStr = "0.00E0"; + + CPPUNIT_ASSERT_EQUAL_MESSAGE("Number format lost exponent without sign during Excel export", aExpectedFormatStr, rFormatStr); + + xDocSh->DoClose(); +} + +void ScExportTest::testExtendedLCIDXLSX() +{ + ScDocShellRef xDocSh = loadDoc("tdf36038_ExtendedLCID.", FORMAT_ODS); + CPPUNIT_ASSERT( xDocSh.is() ); + xDocSh = saveAndReload( &(*xDocSh), FORMAT_XLSX); + CPPUNIT_ASSERT( xDocSh.is() ); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/styles.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + // Check export + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[2]", "formatCode", "[$-107041E]dd\\-mm\\-yyyy"); + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[3]", "formatCode", "[$-D07041E]dd\\-mm\\-yyyy"); + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[4]", "formatCode", "[$-1030411]dd\\-mm\\-ee"); + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[5]", "formatCode", "[$-1B030411]dd\\-mm\\-ee"); + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[6]", "formatCode", "[$-108040D]dd\\-mm\\-yyyy"); + //assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[7]", "formatCode", "[$-108040D]dd\\-mm\\-yyyy"); + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[7]", "formatCode", "[$-1060401]dd\\-mm\\-yyyy"); + assertXPath(pDoc, "/x:styleSheet/x:numFmts/x:numFmt[8]", "formatCode", "[$-2060401]dd\\-mm\\-yyyy"); + + // Check import + ScDocument& rDoc = xDocSh->GetDocument(); + SvNumberFormatter* pNumFormatter = rDoc.GetFormatTable(); + sal_uInt32 nNumberFormat; + const OUString aLang[5] = { "[$-41E]", "[$-411]", "[$-40D]", "[$-401]", "[$-500]" }; + const OUString aCalendar[5] = { "[~buddhist]DD-MM-YYYY", "[~gengou]DD-MM-EE", "[~jewish]DD-MM-YYYY", "[~hijri]DD-MM-YYYY", "[~dangi]YYYY/MM/DD" }; + for ( sal_Int16 nCol = 1; nCol <= 2; nCol++ ) + { + for ( sal_Int16 nRow = 1; nRow <= 4; nRow++ ) + { + rDoc.GetNumberFormat(nCol, nRow, 0, nNumberFormat); + const SvNumberformat* pNumberFormat = pNumFormatter->GetEntry(nNumberFormat); + const OUString& rFormatStr = pNumberFormat->GetFormatstring(); + const OUString aExpectedFormatStr = aLang[nRow-1] + ( (nCol==2 && nRow!=3) ? OUString("[NatNum1]") : OUString() ) + aCalendar[nRow-1]; + + CPPUNIT_ASSERT_EQUAL_MESSAGE("Number format lost extended LCID during Excel export", aExpectedFormatStr, rFormatStr); + } + } + + xDocSh->DoClose(); +} + +void ScExportTest::testHiddenRepeatedRowsODS() +{ + ScDocShellRef xDocSh = loadDoc("empty.", FORMAT_ODS); + CPPUNIT_ASSERT( xDocSh.is() ); + + { + ScDocument& rDoc = xDocSh->GetDocument(); + rDoc.SetRowHidden(0, 20, 0, true); + } + + xDocSh = saveAndReload( &(*xDocSh), FORMAT_ODS); + ScDocument& rDoc = xDocSh->GetDocument(); + SCROW nFirstRow = 0; + SCROW nLastRow = 0; + bool bHidden = rDoc.RowHidden(0, 0, &nFirstRow, &nLastRow); + CPPUNIT_ASSERT(bHidden); + CPPUNIT_ASSERT_EQUAL(SCROW(0), nFirstRow); + CPPUNIT_ASSERT_EQUAL(SCROW(20), nLastRow); + xDocSh->DoClose(); +} + +void ScExportTest::testHyperlinkTargetFrameODS() +{ + ScDocShellRef xDocSh = loadDoc("hyperlink_frame.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + const EditTextObject* pEditText = rDoc.GetEditText(ScAddress(2, 5, 0)); + CPPUNIT_ASSERT(pEditText); + + const SvxFieldData* pData = pEditText->GetFieldData(0, 0, text::textfield::Type::URL); + CPPUNIT_ASSERT_MESSAGE("Failed to get the URL data.", pData && pData->GetClassId() == text::textfield::Type::URL); + + const SvxURLField* pURLData = static_cast<const SvxURLField*>(pData); + OUString aTargetFrame = pURLData->GetTargetFrame(); + CPPUNIT_ASSERT_EQUAL(OUString("_blank"), aTargetFrame); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "content.xml", FORMAT_ODS); + CPPUNIT_ASSERT(pDoc); + OUString aTargetFrameExport = getXPath(pDoc, + "/office:document-content/office:body/office:spreadsheet/table:table/table:table-row[2]/table:table-cell[2]/text:p/text:a", "target-frame-name"); + CPPUNIT_ASSERT_EQUAL(OUString("_blank"), aTargetFrameExport); + + xDocSh->DoClose(); +} + +void ScExportTest::testOpenDocumentAsReadOnly() +{ + ScDocShellRef xDocSh = loadDoc("open-as-read-only.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh->IsSecurityOptOpenReadOnly()); + ScDocShellRef xDocSh2 = saveAndReload(xDocSh.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh2->IsSecurityOptOpenReadOnly()); + xDocSh->DoClose(); + xDocSh2->DoClose(); +} + +void ScExportTest::testKeepSettingsOfBlankRows() +{ + ScDocShellRef xDocSh = loadDoc("tdf41425.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xDocSh), FORMAT_XLSX); + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + // saved blank row with not default setting in A2 + assertXPath(pSheet, "/x:worksheet/x:sheetData/x:row", 2); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf105272() +{ + ScDocShellRef xDocSh = loadDoc("tdf105272.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + xDocSh = saveAndReload(xDocSh.get(), FORMAT_XLSX); + ScDocument& rDoc = xDocSh->GetDocument(); + //without the fix in place,it would fail + //Expected: Table1[[#This Row],[Total]]/Table1[[#This Row],['# Athletes]] + //Actual : table1[[#this row],[total]]/table1[[#this row],['# athletes]] + + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(7, 3, 0), + "Table1[[#This Row],[Total]]/Table1[[#This Row],['# Athletes]]", + "Wrong formula"); +} + +void ScExportTest::testTdf118990() +{ + ScDocShellRef xDocSh = loadDoc("tdf118990.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + xDocSh = saveAndReload(xDocSh.get(), FORMAT_XLSX); + ScDocument& rDoc = xDocSh->GetDocument(); + + // TODO: also test A1, which contains a UNC reference to \\localhost\share\lookupsource.xlsx, + // but currently looses "localhost" part when normalized in INetURLObject, becoming + // file:///share/lookupsource.xlsx - which is incorrect, since it points to local filesystem + // and not to Windows network share. + + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(0, 1, 0), + "VLOOKUP(B1,'file://192.168.1.1/share/lookupsource.xlsx'#$Sheet1.A1:B5,2)", + "Wrong Windows share (using host IP) URL in A2"); + + ASSERT_FORMULA_EQUAL(rDoc, ScAddress(0, 2, 0), + "VLOOKUP(B1,'file://NETWORKHOST/share/lookupsource.xlsx'#$Sheet1.A1:B5,2)", + "Wrong Windows share (using hostname) URL in A3"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf121612() +{ + ScDocShellRef xDocSh = loadDoc("tdf121612.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + xDocSh = saveAndReload(xDocSh.get(), FORMAT_XLSX); + + ScDocument& rDoc = xDocSh->GetDocument(); + + // There should be a pivot table + CPPUNIT_ASSERT(rDoc.HasPivotTable()); + + // DP collection is not lost after export and has one entry + ScDPCollection* pDPColl = rDoc.GetDPCollection(); + CPPUNIT_ASSERT(pDPColl); + CPPUNIT_ASSERT_EQUAL(size_t(1), pDPColl->GetCount()); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf112936() +{ + ScDocShellRef xDocSh = loadDoc("tdf112936.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/pivotCache/pivotCacheDefinition1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPath(pDoc, "//x:pivotCacheDefinition", "recordCount", "4"); + assertXPath(pDoc, "//x:pivotCacheDefinition", "createdVersion", "3"); + + xDocSh->DoClose(); +} + +void ScExportTest::testXltxExport() +{ + // Create new document + ScDocShell* pShell = new ScDocShell( + SfxModelFlags::EMBEDDED_OBJECT | + SfxModelFlags::DISABLE_EMBEDDED_SCRIPTS | + SfxModelFlags::DISABLE_DOCUMENT_RECOVERY); + pShell->DoInitNew(); + + // Export as template and check content type + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *pShell, m_xSFactory, "[Content_Types].xml", FORMAT_XLTX); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/ContentType:Types/ContentType:Override[@PartName='/xl/workbook.xml']", + "ContentType", "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml"); +} + +void ScExportTest::testPivotCacheAfterExportXLSX() +{ + ScDocShellRef xDocSh = loadDoc("numgroup_example.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + // export only + std::shared_ptr<utl::TempFile> pTemp = saveAs(xDocSh.get(), FORMAT_XLSX); + + ScDocument& rDoc = xDocSh->GetDocument(); + CPPUNIT_ASSERT(rDoc.HasPivotTable()); + + // Two pivot tables + ScDPCollection* pDPColl = rDoc.GetDPCollection(); + CPPUNIT_ASSERT(pDPColl); + CPPUNIT_ASSERT_EQUAL(size_t(2), pDPColl->GetCount()); + + // One cache + ScDPCollection::SheetCaches& rSheetCaches = pDPColl->GetSheetCaches(); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), rSheetCaches.size()); + const ScDPCache* pCache = rSheetCaches.getExistingCache(ScRange(0, 0, 0, 3, 30, 0)); + CPPUNIT_ASSERT_MESSAGE("Pivot cache is expected for A1:D31 on the first sheet.", pCache); + + // See if XLSX export didn't damage group info of the 1st pivot table + const ScDPNumGroupInfo* pInfo = pCache->GetNumGroupInfo(1); + CPPUNIT_ASSERT_MESSAGE("No number group info :(", pInfo); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf114969XLSX() +{ + ScDocShellRef xDocSh = loadDoc("sheet_name_with_dots.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/x:worksheet/x:hyperlinks/x:hyperlink[1]", "location", "'1.1.1.1'!C1"); + assertXPath(pDoc, "/x:worksheet/x:hyperlinks/x:hyperlink[2]", "location", "'1.1.1.1'!C2"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf115192XLSX() +{ + ScDocShellRef xDocSh = loadDoc("test_115192.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/drawings/_rels/drawing1.xml.rels", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/r:Relationships/r:Relationship[@Id='rId1']", "TargetMode", "External"); + assertXPathNoAttribute(pDoc, "/r:Relationships/r:Relationship[@Id='rId2']", "TargetMode"); + assertXPath(pDoc, "/r:Relationships/r:Relationship[@Id='rId3']", "TargetMode", "External"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf91634XLSX() +{ + ScDocShellRef xDocSh = loadDoc("image_hyperlink.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xDocSh), FORMAT_XLSX); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/drawing1.xml"); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor/xdr:pic/xdr:nvPicPr/xdr:cNvPr/a:hlinkClick", 1); + + xmlDocUniquePtr pXmlRels = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/_rels/drawing1.xml.rels"); + CPPUNIT_ASSERT(pXmlRels); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId1']", "Target", "https://www.google.com/"); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId1']", "TargetMode", "External"); + + xDocSh->DoClose(); +} + +void ScExportTest::testValidationCopyPaste() +{ + ScDocShellRef xDocSh = loadDoc("validation-copypaste.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + ScDocument& rSrcDoc = xDocSh->GetDocument(); + + // Copy B1 from src doc to clip + ScDocument aClipDoc(SCDOCMODE_CLIP); + ScRange aSrcRange(1, 0, 1); + ScClipParam aClipParam(aSrcRange, false); + ScMarkData aMark(rSrcDoc.GetSheetLimits().mnMaxRow, rSrcDoc.GetSheetLimits().mnMaxCol); + aMark.SetMarkArea(aSrcRange); + rSrcDoc.CopyToClip(aClipParam, &aClipDoc, &aMark, false, false); + + // Create second document, paste B1 from clip + ScDocShell* pShell2 + = new ScDocShell(SfxModelFlags::EMBEDDED_OBJECT | SfxModelFlags::DISABLE_EMBEDDED_SCRIPTS + | SfxModelFlags::DISABLE_DOCUMENT_RECOVERY); + pShell2->DoInitNew(); + ScDocument& rDestDoc = pShell2->GetDocument(); + ScRange aDstRange(1, 0, 0); + ScMarkData aMark2(rDestDoc.GetSheetLimits().mnMaxRow, rDestDoc.GetSheetLimits().mnMaxCol); + aMark2.SetMarkArea(aDstRange); + rDestDoc.CopyFromClip(aDstRange, aMark2, InsertDeleteFlags::ALL, nullptr, &aClipDoc); + + // save as XLSX + std::shared_ptr<utl::TempFile> pXPathFile + = ScBootstrapFixture::exportTo(&(*pShell2), FORMAT_XLSX); + + // check validation + xmlDocUniquePtr pDoc + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pDoc); + assertXPathContent(pDoc, "/x:worksheet/x:dataValidations/x:dataValidation/x:formula1", "#REF!"); +} + +void ScExportTest::testTdf115159() +{ + ScDocShellRef xShell = loadDoc("tdf115159.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + xShell->DoClose(); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/workbook.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + //assert the existing OOXML built-in name is not duplicated + assertXPath(pDoc, "/x:workbook/x:definedNames/x:definedName", 1); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf112567() +{ + // Set the system locale to Hungarian (a language with different range separator) + SvtSysLocaleOptions aOptions; + OUString sLocaleConfigString = aOptions.GetLanguageTag().getBcp47(); + aOptions.SetLocaleConfigString("hu-HU"); + aOptions.Commit(); + comphelper::ScopeGuard g([&aOptions, &sLocaleConfigString] { + aOptions.SetLocaleConfigString(sLocaleConfigString); + aOptions.Commit(); + }); + + ScDocShellRef xShell = loadDoc("tdf112567.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + xShell->DoClose(); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/workbook.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + //assert the existing OOXML built-in name is not duplicated + assertXPath(pDoc, "/x:workbook/x:definedNames/x:definedName", 1); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf112567b() +{ + // Set the system locale to Hungarian (a language with different range separator) + SvtSysLocaleOptions aOptions; + OUString sLocaleConfigString = aOptions.GetLanguageTag().getBcp47(); + aOptions.SetLocaleConfigString("hu-HU"); + aOptions.Commit(); + comphelper::ScopeGuard g([&aOptions, &sLocaleConfigString] { + aOptions.SetLocaleConfigString(sLocaleConfigString); + aOptions.Commit(); + }); + + ScDocShellRef xShell = loadDoc("tdf112567.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + xShell->DoClose(); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/workbook.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + //assert the existing OOXML built-in name is not duplicated + assertXPath(pDoc, "/x:workbook/x:definedNames/x:definedName", 1); + + //and it contains "," instead of ";" + assertXPathContent(pDoc, "/x:workbook/x:definedNames/x:definedName[1]", "Sheet1!$A:$A,Sheet1!$1:$1"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf123645XLSX() +{ + ScDocShellRef xDocSh = loadDoc("chart_hyperlink.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xDocSh), FORMAT_XLSX); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/drawing1.xml"); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[1]/xdr:graphicFrame/xdr:nvGraphicFramePr/xdr:cNvPr/a:hlinkClick", 1); + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[2]/xdr:graphicFrame/xdr:nvGraphicFramePr/xdr:cNvPr/a:hlinkClick", 1); + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor[3]/xdr:graphicFrame/xdr:nvGraphicFramePr/xdr:cNvPr/a:hlinkClick", 1); + + xmlDocUniquePtr pXmlRels = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/_rels/drawing1.xml.rels"); + CPPUNIT_ASSERT(pXmlRels); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId1']", "TargetMode", "External"); + assertXPathNoAttribute(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId3']", "TargetMode"); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId5']", "TargetMode", "External"); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId1']", "Target", "file:///C:/TEMP/test.xlsx"); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId3']", "Target", "#Sheet2!A1"); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId5']", "Target", "https://bugs.documentfoundation.org/show_bug.cgi?id=123645"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf125173XLSX() +{ + ScDocShellRef xDocSh = loadDoc("text_box_hyperlink.", FORMAT_ODS); + CPPUNIT_ASSERT(xDocSh.is()); + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xDocSh), FORMAT_XLSX); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/drawing1.xml"); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/xdr:wsDr/xdr:twoCellAnchor/xdr:sp/xdr:nvSpPr/xdr:cNvPr/a:hlinkClick", 1); + + xmlDocUniquePtr pXmlRels = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/_rels/drawing1.xml.rels"); + CPPUNIT_ASSERT(pXmlRels); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId1']", "Target", "http://www.google.com/"); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship[@Id='rId1']", "TargetMode", "External"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf79972XLSX() +{ + ScDocShellRef xDocSh = loadDoc("tdf79972.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xDocSh), FORMAT_XLSX); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/x:worksheet/x:hyperlinks/x:hyperlink", "ref", "A1"); + + xmlDocUniquePtr pXmlRels = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/_rels/sheet1.xml.rels"); + CPPUNIT_ASSERT(pXmlRels); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship", "Target", "https://bugs.documentfoundation.org/show_bug.cgi?id=79972"); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship", "TargetMode", "External"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf126024XLSX() +{ + ScDocShellRef xDocSh = loadDoc("hyperlink_formula.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xDocSh), FORMAT_XLSX); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/x:worksheet/x:hyperlinks/x:hyperlink", "ref", "A2"); + + xmlDocUniquePtr pXmlRels = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/_rels/sheet1.xml.rels"); + CPPUNIT_ASSERT(pXmlRels); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship", "Target", "https://bugs.documentfoundation.org/"); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship", "TargetMode", "External"); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf126177XLSX() +{ + ScDocShellRef xDocSh = loadDoc("hyperlink_export.", FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + std::shared_ptr<utl::TempFile> pXPathFile = ScBootstrapFixture::exportTo(&(*xDocSh), FORMAT_XLSX); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pDoc); + assertXPath(pDoc, "/x:worksheet/x:hyperlinks/x:hyperlink", "location", "Munka1!A5"); + + xmlDocUniquePtr pXmlRels = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/_rels/sheet1.xml.rels"); + CPPUNIT_ASSERT(pXmlRels); + OUString aTarget = getXPath(pXmlRels, "/r:Relationships/r:Relationship", "Target"); + CPPUNIT_ASSERT(aTarget.endsWith("test.xlsx")); + assertXPath(pXmlRels, "/r:Relationships/r:Relationship", "TargetMode", "External"); + + xDocSh->DoClose(); +} + +void ScExportTest::testCommentTextVAlignment() +{ + // Testing comment text alignments. + ScDocShellRef xShell = loadDoc("CommentTextVAlign.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile + = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + + xmlDocUniquePtr pVmlDrawing + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/vmlDrawing1.vml"); + CPPUNIT_ASSERT(pVmlDrawing); + + assertXPathContent(pVmlDrawing, "/xml/v:shape/xx:ClientData/xx:TextVAlign", "Center"); + + xShell->DoClose(); +} + +void ScExportTest::testCommentTextHAlignment() +{ + // Testing comment text alignments. + ScDocShellRef xShell = loadDoc("CommentTextHAlign.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell.is()); + + std::shared_ptr<utl::TempFile> pXPathFile + = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + + xmlDocUniquePtr pVmlDrawing + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/drawings/vmlDrawing1.vml"); + CPPUNIT_ASSERT(pVmlDrawing); + + assertXPathContent(pVmlDrawing, "/xml/v:shape/xx:ClientData/xx:TextHAlign", "Center"); + + xShell->DoClose(); +} + +void ScExportTest::testRotatedImageODS() +{ + // Error was, that the length values in shapes were not + // written in the given unit into the file. + css::uno::Reference<css::sheet::XGlobalSheetSettings> xGlobalSheetSettings + = css::sheet::GlobalSheetSettings::create(comphelper::getProcessComponentContext()); + xGlobalSheetSettings->setMetric(static_cast<sal_Int16>(FieldUnit::MM)); + + ScDocShellRef xDocSh = loadDoc("tdf103092_RotatedImage.", FORMAT_ODS, true); + CPPUNIT_ASSERT(xDocSh.is()); + + std::shared_ptr<utl::TempFile> pTemp = saveAs(xDocSh.get(), FORMAT_ODS); + CPPUNIT_ASSERT(pTemp); + xmlDocUniquePtr pXmlDoc = XPathHelper::parseExport(pTemp, m_xSFactory, "content.xml"); + CPPUNIT_ASSERT(pXmlDoc); + + const OString sPathStart = "/office:document-content/office:body/office:spreadsheet/" + "table:table/table:shapes/draw:frame"; + const OUString sTransform = getXPath(pXmlDoc, sPathStart, "transform"); + // Attribute transform has the structure skew (...) rotate (...) translate (x y) + // parts are separated by blank + OUString sTranslate(sTransform.copy(sTransform.lastIndexOf('('))); + sTranslate = sTranslate.copy(1, sTranslate.getLength()-2); // remove '(' and ')' + const OUString sX(sTranslate.getToken(0, ' ')); + const OUString sY(sTranslate.getToken(1, ' ')); + CPPUNIT_ASSERT(sX.endsWith("mm") && sY.endsWith("mm")); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf128976() +{ + ScDocShellRef xShell = loadDoc("tdf128976.", FORMAT_XLS); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(xShell.get(), FORMAT_XLS); + xShell->DoClose(); + CPPUNIT_ASSERT(xDocSh.is()); + + ScDocument& rDoc = xDocSh->GetDocument(); + + // Trying to save very small fractional default column width to XLS (where only integer values + // between 0 and 255 are allowed as default) resulted in negative (-1) value after correction, + // and was written as 65535 (invalid default width). As the result, all columns had large width + // when reopened: 28415 (and Excel warned about invalid format). + const sal_uInt16 nColumn0Width = rDoc.GetColWidth(SCCOL(0), SCTAB(0), false); + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(45), nColumn0Width); + + xDocSh->DoClose(); +} + +void ScExportTest::testTdf120502() +{ + // Create an empty worksheet; resize last column on its first sheet; export to XLSX, and check + // that the last exported column number is correct + css::uno::Reference<css::frame::XDesktop2> xDesktop + = css::frame::Desktop::create(comphelper::getProcessComponentContext()); + CPPUNIT_ASSERT(xDesktop); + + css::uno::Sequence<css::beans::PropertyValue> args(1); + args[0].Name = "Hidden"; + args[0].Value <<= true; + + css::uno::Reference<css::lang::XComponent> xComponent + = xDesktop->loadComponentFromURL("private:factory/scalc", "_blank", 0, args); + CPPUNIT_ASSERT(xComponent); + + // Get the document model + SfxObjectShell* pFoundShell = SfxObjectShell::GetShellFromComponent(xComponent); + CPPUNIT_ASSERT_MESSAGE("Failed to access document shell", pFoundShell); + + ScDocShellRef xShell = dynamic_cast<ScDocShell*>(pFoundShell); + CPPUNIT_ASSERT(xShell); + + ScDocument& rDoc = xShell->GetDocument(); + const SCCOL nMaxCol = rDoc.MaxCol(); // 0-based + + const auto nOldWidth = rDoc.GetColWidth(nMaxCol, 0); + rDoc.SetColWidth(nMaxCol, 0, nOldWidth + 100); + + std::shared_ptr<utl::TempFile> pXPathFile + = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + xShell->DoClose(); + xmlDocUniquePtr pSheet1 + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet1); + + // This was 1025 when nMaxCol+1 was 1024 + assertXPath(pSheet1, "/x:worksheet/x:cols/x:col", "max", OUString::number(nMaxCol + 1)); +} + +void ScExportTest::testTdf131372() +{ + ScDocShellRef xShell = loadDoc("tdf131372.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell); + + auto pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + assertXPathContent(pSheet, "/x:worksheet/x:sheetData/x:row/x:c[1]/x:f", "NA()"); + assertXPathContent(pSheet, "/x:worksheet/x:sheetData/x:row/x:c[2]/x:f", "#N/A"); + + xShell->DoClose(); +} + +void ScExportTest::testTdf122331() +{ + ScDocShellRef xShell = loadDoc("tdf122331.", FORMAT_ODS); + CPPUNIT_ASSERT(xShell); + + auto pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + + xmlDocUniquePtr pSheet = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pSheet); + + assertXPath(pSheet, "/x:worksheet/x:sheetPr", "filterMode", "true"); + assertXPath(pSheet, "/x:worksheet/x:autoFilter", "ref", "A1:B761"); + assertXPath(pSheet, "/x:worksheet/x:autoFilter/x:filterColumn", "colId", "1"); + + xShell->DoClose(); +} + +void ScExportTest::testTdf83779() +{ + // Roundtripping TRUE/FALSE constants (not functions) must convert them to functions + ScDocShellRef xShell = loadDoc("tdf83779.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell); + + auto pXPathFile = ScBootstrapFixture::exportTo(&(*xShell), FORMAT_XLSX); + + xmlDocUniquePtr pVmlDrawing + = XPathHelper::parseExport(pXPathFile, m_xSFactory, "xl/worksheets/sheet1.xml"); + CPPUNIT_ASSERT(pVmlDrawing); + + assertXPathContent(pVmlDrawing, "/x:worksheet/x:sheetData/x:row[1]/x:c/x:f", "FALSE()"); + assertXPathContent(pVmlDrawing, "/x:worksheet/x:sheetData/x:row[2]/x:c/x:f", "TRUE()"); + + xShell->DoClose(); +} + +void ScExportTest::testTdf134817_HeaderFooterTextWith2SectionXLSX() +{ + // Header/footer text with multiple selection should be exported, and imported properly + ScDocShellRef xShell = loadDoc("tdf134817_HeaderFooterTextWith2Section.", FORMAT_XLSX); + CPPUNIT_ASSERT(xShell.is()); + + ScDocShellRef xDocSh = saveAndReload(&(*xShell), FORMAT_XLSX); + CPPUNIT_ASSERT(xDocSh.is()); + + xmlDocUniquePtr pDoc = XPathHelper::parseExport2(*this, *xDocSh, m_xSFactory, "xl/worksheets/sheet1.xml", FORMAT_XLSX); + CPPUNIT_ASSERT(pDoc); + + assertXPathContent(pDoc, "/x:worksheet/x:headerFooter/x:oddHeader", "&L&\"Abadi,Regular\"&11aaa&\"Bembo,Regular\"&20bbb"); + assertXPathContent(pDoc, "/x:worksheet/x:headerFooter/x:oddFooter", "&R&\"Cambria,Regular\"&14camb&\"Dante,Regular\"&18dant"); + + xDocSh->DoClose(); +} + +CPPUNIT_TEST_SUITE_REGISTRATION(ScExportTest); + +CPPUNIT_PLUGIN_IMPLEMENT(); + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |