LCOV - code coverage report
Current view: top level - sw/qa/extras/ooxmlimport - ooxmlimport.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 1560 1562 99.9 %
Date: 2015-06-13 12:38:46 Functions: 1981 2163 91.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  */
       9             : 
      10             : #include "config_test.h"
      11             : 
      12             : #ifdef MACOSX
      13             : #define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
      14             : #include <premac.h>
      15             : #include <AppKit/AppKit.h>
      16             : #include <postmac.h>
      17             : #endif
      18             : 
      19             : #include <swmodeltestbase.hxx>
      20             : 
      21             : #if !defined(WNT)
      22             : 
      23             : #include <basegfx/polygon/b2dpolypolygontools.hxx>
      24             : #include <com/sun/star/awt/XBitmap.hpp>
      25             : #include <com/sun/star/awt/FontUnderline.hpp>
      26             : #include <com/sun/star/awt/FontWeight.hpp>
      27             : #include <com/sun/star/beans/XPropertySet.hpp>
      28             : #include <com/sun/star/document/XEmbeddedObjectSupplier2.hpp>
      29             : #include <com/sun/star/drawing/XControlShape.hpp>
      30             : #include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
      31             : #include <com/sun/star/drawing/PointSequenceSequence.hpp>
      32             : #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
      33             : #include <com/sun/star/lang/XServiceInfo.hpp>
      34             : #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
      35             : #include <com/sun/star/text/HoriOrientation.hpp>
      36             : #include <com/sun/star/text/RelOrientation.hpp>
      37             : #include <com/sun/star/text/SetVariableType.hpp>
      38             : #include <com/sun/star/text/TableColumnSeparator.hpp>
      39             : #include <com/sun/star/text/TextContentAnchorType.hpp>
      40             : #include <com/sun/star/text/VertOrientation.hpp>
      41             : #include <com/sun/star/text/WrapTextMode.hpp>
      42             : #include <com/sun/star/text/WritingMode2.hpp>
      43             : #include <com/sun/star/text/XBookmarksSupplier.hpp>
      44             : #include <com/sun/star/text/XDependentTextField.hpp>
      45             : #include <com/sun/star/text/XFormField.hpp>
      46             : #include <com/sun/star/text/XPageCursor.hpp>
      47             : #include <com/sun/star/text/XTextColumns.hpp>
      48             : #include <com/sun/star/text/XTextFieldsSupplier.hpp>
      49             : #include <com/sun/star/text/XTextFrame.hpp>
      50             : #include <com/sun/star/text/XTextFramesSupplier.hpp>
      51             : #include <com/sun/star/text/XTextEmbeddedObjectsSupplier.hpp>
      52             : #include <com/sun/star/text/XTextViewCursorSupplier.hpp>
      53             : #include <com/sun/star/style/BreakType.hpp>
      54             : #include <com/sun/star/style/ParagraphAdjust.hpp>
      55             : #include <com/sun/star/style/LineSpacing.hpp>
      56             : #include <com/sun/star/style/LineSpacingMode.hpp>
      57             : #include <com/sun/star/table/ShadowFormat.hpp>
      58             : #include <com/sun/star/view/XSelectionSupplier.hpp>
      59             : #include <com/sun/star/view/XFormLayerAccess.hpp>
      60             : #include <com/sun/star/table/BorderLine2.hpp>
      61             : #include <com/sun/star/table/TableBorder2.hpp>
      62             : #include <com/sun/star/text/SizeType.hpp>
      63             : #include <com/sun/star/xml/dom/XDocument.hpp>
      64             : #include <com/sun/star/text/XDocumentIndex.hpp>
      65             : #include <com/sun/star/style/CaseMap.hpp>
      66             : #include <com/sun/star/style/PageStyleLayout.hpp>
      67             : #include <com/sun/star/style/ParagraphAdjust.hpp>
      68             : #include <com/sun/star/util/DateTime.hpp>
      69             : #include <vcl/bmpacc.hxx>
      70             : #include <vcl/svapp.hxx>
      71             : #include <unotest/assertion_traits.hxx>
      72             : #include <unotools/fltrcfg.hxx>
      73             : #include <comphelper/sequenceashashmap.hxx>
      74             : #include <com/sun/star/text/GraphicCrop.hpp>
      75             : #include <swtypes.hxx>
      76             : #include <tools/datetimeutils.hxx>
      77             : #include <oox/drawingml/drawingmltypes.hxx>
      78             : 
      79             : #include <bordertest.hxx>
      80             : 
      81         179 : class Test : public SwModelTestBase
      82             : {
      83             : public:
      84         179 :     Test() : SwModelTestBase("/sw/qa/extras/ooxmlimport/data/", "Office Open XML Text")
      85             :     {
      86         179 :     }
      87             : 
      88         179 :     virtual void preTest(const char* filename) SAL_OVERRIDE
      89             :     {
      90         179 :         if (OString(filename) == "smartart.docx" || OString(filename) == "strict-smartart.docx" || OString(filename) == "fdo87488.docx")
      91           3 :             SvtFilterOptions::Get().SetSmartArt2Shape(true);
      92         179 :     }
      93             : 
      94         179 :     virtual void postTest(const char* filename) SAL_OVERRIDE
      95             :     {
      96         179 :         if (OString(filename) == "smartart.docx" || OString(filename) == "strict-smartart.docx" || OString(filename) == "fdo87488.docx")
      97           3 :             SvtFilterOptions::Get().SetSmartArt2Shape(false);
      98         179 :     }
      99             : };
     100             : 
     101           2 : class FailTest : public Test
     102             : {
     103             : public:
     104             :     // UGLY: hacky manual override of MacrosTest::loadFromDesktop
     105           1 :     void executeImportTest(const char* filename)
     106             :     {
     107           1 :         header();
     108           1 :         preTest(filename);
     109             :         {
     110           1 :             if (mxComponent.is())
     111           0 :                 mxComponent->dispose();
     112           1 :             std::cout << filename << ",";
     113           1 :             mnStartTime = osl_getGlobalTimer();
     114             :             {
     115           1 :                 OUString aURL(getURLFromSrc(mpTestDocumentPath) + OUString::createFromAscii(filename));
     116           1 :                 CPPUNIT_ASSERT_MESSAGE("no desktop", mxDesktop.is());
     117           2 :                 uno::Reference<frame::XComponentLoader> xLoader = uno::Reference<frame::XComponentLoader>(mxDesktop, uno::UNO_QUERY);
     118           1 :                 CPPUNIT_ASSERT_MESSAGE("no loader", xLoader.is());
     119           2 :                 uno::Sequence<beans::PropertyValue> args(1);
     120           1 :                 args[0].Name = "DocumentService";
     121           1 :                 args[0].Handle = -1;
     122           1 :                 args[0].Value <<= OUString("com.sun.star.text.TextDocument");
     123           1 :                 args[0].State = beans::PropertyState_DIRECT_VALUE;
     124             : 
     125           2 :                 uno::Reference<lang::XComponent> xComponent = xLoader->loadComponentFromURL(aURL, OUString("_default"), 0, args);
     126           2 :                 OUString sMessage = "loading succeeded: " + aURL;
     127           2 :                 CPPUNIT_ASSERT_MESSAGE(OUStringToOString(sMessage, RTL_TEXTENCODING_UTF8).getStr(), !xComponent.is());
     128             :             }
     129             :         }
     130           1 :         postTest(filename);
     131           1 :         verify();
     132           1 :         finish();
     133           1 :     }
     134             : };
     135             : 
     136          12 : DECLARE_SW_IMPORT_TEST(testMathMalformedXml, "math-malformed_xml.docx", FailTest)
     137             : {
     138           1 :     CPPUNIT_ASSERT(!mxComponent.is());
     139           1 : }
     140             : 
     141          12 : DECLARE_OOXMLIMPORT_TEST(testN751054, "n751054.docx")
     142             : {
     143           1 :     text::TextContentAnchorType eValue = getProperty<text::TextContentAnchorType>(getShape(1), "AnchorType");
     144           1 :     CPPUNIT_ASSERT(eValue != text::TextContentAnchorType_AS_CHARACTER);
     145           1 : }
     146             : 
     147          12 : DECLARE_OOXMLIMPORT_TEST(testN751117, "n751117.docx")
     148             : {
     149             :     // First shape: the end should be an arrow, should be rotated and should be flipped.
     150           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
     151           2 :     OUString aValue;
     152           1 :     xPropertySet->getPropertyValue("LineEndName") >>= aValue;
     153           1 :     CPPUNIT_ASSERT(aValue.indexOf("Arrow") != -1);
     154             : 
     155             :     // Rotating & Flipping will cause the angle to change from 90 degrees to 270 degrees
     156           1 :     sal_Int32 nValue = 0;
     157           1 :     xPropertySet->getPropertyValue("RotateAngle") >>= nValue;
     158           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(270 * 100), nValue);
     159             : 
     160           2 :     uno::Reference<drawing::XShape> xShape(xPropertySet, uno::UNO_QUERY);
     161           1 :     awt::Size aActualSize(xShape->getSize());
     162           1 :     CPPUNIT_ASSERT(aActualSize.Width > 0);
     163             : 
     164             :     // The second shape should be a line
     165           2 :     uno::Reference<lang::XServiceInfo> xServiceInfo(getShape(2), uno::UNO_QUERY);
     166           2 :     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.drawing.LineShape"));
     167           1 : }
     168             : 
     169          12 : DECLARE_OOXMLIMPORT_TEST(testN751017, "n751017.docx")
     170             : {
     171           1 :     uno::Reference<text::XTextFieldsSupplier> xTextFieldsSupplier(mxComponent, uno::UNO_QUERY);
     172           2 :     uno::Reference<container::XNameAccess> xMasters(xTextFieldsSupplier->getTextFieldMasters());
     173             :     // Make sure we have a variable named foo.
     174           1 :     CPPUNIT_ASSERT(xMasters->hasByName("com.sun.star.text.FieldMaster.SetExpression.foo"));
     175             : 
     176           2 :     uno::Reference<container::XEnumerationAccess> xFieldsAccess(xTextFieldsSupplier->getTextFields());
     177           2 :     uno::Reference<container::XEnumeration> xFields(xFieldsAccess->createEnumeration());
     178           1 :     bool bFoundSet(false), bFoundGet(false);
     179           4 :     while (xFields->hasMoreElements())
     180             :     {
     181           2 :         uno::Reference<lang::XServiceInfo> xServiceInfo(xFields->nextElement(), uno::UNO_QUERY);
     182           4 :         uno::Reference<beans::XPropertySet> xPropertySet(xServiceInfo, uno::UNO_QUERY);
     183           2 :         sal_Int16 nValue = 0;
     184           4 :         OUString aValue;
     185           2 :         if (xServiceInfo->supportsService("com.sun.star.text.TextField.SetExpression"))
     186             :         {
     187           1 :             bFoundSet = true;
     188           1 :             uno::Reference<text::XDependentTextField> xDependentTextField(xServiceInfo, uno::UNO_QUERY);
     189           2 :             uno::Reference<beans::XPropertySet> xMasterProps(xDependentTextField->getTextFieldMaster());
     190             : 
     191             :             // First step: did we set foo to "bar"?
     192           1 :             xMasterProps->getPropertyValue("Name") >>= aValue;
     193           1 :             CPPUNIT_ASSERT_EQUAL(OUString("foo"), aValue);
     194           1 :             xPropertySet->getPropertyValue("SubType") >>= nValue;
     195           1 :             CPPUNIT_ASSERT_EQUAL(text::SetVariableType::STRING, nValue);
     196           1 :             xPropertySet->getPropertyValue("Content") >>= aValue;
     197           2 :             CPPUNIT_ASSERT_EQUAL(OUString("bar"), aValue);
     198             :         }
     199           1 :         else if (xServiceInfo->supportsService("com.sun.star.text.TextField.GetExpression"))
     200             :         {
     201             :             // Second step: check the value of foo.
     202           1 :             bFoundGet = true;
     203           1 :             xPropertySet->getPropertyValue("Content") >>= aValue;
     204           1 :             CPPUNIT_ASSERT_EQUAL(OUString("foo"), aValue);
     205           1 :             xPropertySet->getPropertyValue("SubType") >>= nValue;
     206           1 :             CPPUNIT_ASSERT_EQUAL(text::SetVariableType::STRING, nValue);
     207           1 :             xPropertySet->getPropertyValue("CurrentPresentation") >>= aValue;
     208           1 :             CPPUNIT_ASSERT_EQUAL(OUString("bar"), aValue);
     209             :         }
     210           2 :     }
     211           1 :     CPPUNIT_ASSERT(bFoundSet);
     212           2 :     CPPUNIT_ASSERT(bFoundGet);
     213           1 : }
     214             : 
     215          12 : DECLARE_OOXMLIMPORT_TEST(testN750935, "n750935.docx")
     216             : {
     217           1 :     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
     218           2 :     uno::Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(), uno::UNO_QUERY);
     219           2 :     uno::Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), uno::UNO_QUERY);
     220           1 :     xCursor->jumpToLastPage();
     221             :     // Some page break types were ignores, resulting in less pages.
     222           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(5), xCursor->getPage());
     223             : 
     224             :     /*
     225             :      * The problem was that the header and footer was not shared.
     226             :      *
     227             :      * xray ThisComponent.StyleFamilies.PageStyles.Default.FooterIsShared
     228             :      */
     229           2 :     uno::Reference<beans::XPropertySet> xPropertySet(getStyles("PageStyles")->getByName(DEFAULT_STYLE), uno::UNO_QUERY);
     230           1 :     bool bValue = false;
     231           1 :     xPropertySet->getPropertyValue("HeaderIsShared") >>= bValue;
     232           1 :     CPPUNIT_ASSERT_EQUAL(true, bValue);
     233           1 :     xPropertySet->getPropertyValue("FooterIsShared") >>= bValue;
     234           2 :     CPPUNIT_ASSERT_EQUAL(true, bValue);
     235           1 : }
     236             : 
     237          12 : DECLARE_OOXMLIMPORT_TEST(testN757890, "n757890.docx")
     238             : {
     239             :     // The w:pStyle token affected the text outside the textbox.
     240           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
     241           2 :     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xTextDocument->getText(), uno::UNO_QUERY);
     242           2 :     uno::Reference<container::XEnumeration> xParaEnum = xParaEnumAccess->createEnumeration();
     243           2 :     uno::Reference<beans::XPropertySet> xPara(xParaEnum->nextElement(), uno::UNO_QUERY);
     244           2 :     OUString aValue;
     245           1 :     xPara->getPropertyValue("ParaStyleName") >>= aValue;
     246           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Heading 1"), aValue);
     247             : 
     248             :     // This wan't centered
     249           2 :     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(mxComponent, uno::UNO_QUERY);
     250           2 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextFramesSupplier->getTextFrames(), uno::UNO_QUERY);
     251           2 :     uno::Reference<beans::XPropertySet> xFrame(xIndexAccess->getByIndex(0), uno::UNO_QUERY);
     252             :     sal_Int16 nValue;
     253           1 :     xFrame->getPropertyValue("HoriOrient") >>= nValue;
     254           2 :     CPPUNIT_ASSERT_EQUAL(text::HoriOrientation::CENTER, nValue);
     255           1 : }
     256             : 
     257          12 : DECLARE_OOXMLIMPORT_TEST(testRhbz988516, "rhbz988516.docx")
     258             : {
     259             :     // The problem was that the list properties of the footer leaked into body
     260           2 :     CPPUNIT_ASSERT_EQUAL(OUString(),
     261           1 :             getProperty<OUString>(getParagraph(1), "NumberingStyleName"));
     262           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Enclosure 3"), getParagraph(2)->getString());
     263           2 :     CPPUNIT_ASSERT_EQUAL(OUString(),
     264           1 :             getProperty<OUString>(getParagraph(2), "NumberingStyleName"));
     265           2 :     CPPUNIT_ASSERT_EQUAL(OUString(),
     266           1 :             getProperty<OUString>(getParagraph(3), "NumberingStyleName"));
     267           1 : }
     268             : 
     269          12 : DECLARE_OOXMLIMPORT_TEST(testFdo49940, "fdo49940.docx")
     270             : {
     271           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
     272           2 :     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xTextDocument->getText(), uno::UNO_QUERY);
     273           2 :     uno::Reference<container::XEnumeration> xParaEnum = xParaEnumAccess->createEnumeration();
     274           2 :     uno::Reference<beans::XPropertySet> xPara(xParaEnum->nextElement(), uno::UNO_QUERY);
     275           2 :     OUString aValue;
     276           1 :     xPara->getPropertyValue("PageStyleName") >>= aValue;
     277           2 :     CPPUNIT_ASSERT_EQUAL(OUString("First Page"), aValue);
     278           1 : }
     279             : 
     280          12 : DECLARE_OOXMLIMPORT_TEST(testFdo74745, "fdo74745.docx")
     281             : {
     282           1 :     uno::Reference<text::XTextRange > paragraph = getParagraph(3);
     283           2 :     uno::Reference<text::XTextRange> text(paragraph, uno::UNO_QUERY);
     284           2 :     CPPUNIT_ASSERT_EQUAL(text->getString(),OUString("09/02/14"));
     285           1 : }
     286             : 
     287          12 : DECLARE_OOXMLIMPORT_TEST(testFdo81486, "fdo81486.docx")
     288             : {
     289           1 :     uno::Reference<text::XTextRange > paragraph = getParagraph(1);
     290           2 :     uno::Reference<text::XTextRange> text(paragraph, uno::UNO_QUERY);
     291           2 :     CPPUNIT_ASSERT_EQUAL(text->getString(),OUString("CustomTitle"));
     292           1 : }
     293             : 
     294          12 : DECLARE_OOXMLIMPORT_TEST(testFdo79738, "fdo79738.docx")
     295             : {
     296           1 :     uno::Reference< style::XStyleFamiliesSupplier > xStylesSupplier( mxComponent, uno::UNO_QUERY_THROW );
     297           2 :     uno::Reference< container::XNameAccess > xStyleFamilies = xStylesSupplier->getStyleFamilies();
     298           2 :     uno::Reference<container::XNameContainer> xStyles;
     299           1 :     xStyleFamilies->getByName("ParagraphStyles") >>= xStyles;
     300           2 :     uno::Reference<beans::XPropertySet> xPropertySetHeader( xStyles->getByName("Header"), uno::UNO_QUERY );
     301           1 :     CPPUNIT_ASSERT_EQUAL(false, xPropertySetHeader->getPropertyValue("ParaLineNumberCount").get<bool>());
     302           2 :     uno::Reference<beans::XPropertySet> xPropertySetFooter( xStyles->getByName("Footer"), uno::UNO_QUERY );
     303           2 :     CPPUNIT_ASSERT_EQUAL(false, xPropertySetFooter->getPropertyValue("ParaLineNumberCount").get<bool>());
     304           1 : }
     305             : 
     306          12 : DECLARE_OOXMLIMPORT_TEST(testN751077, "n751077.docx")
     307             : {
     308             : /*
     309             : xray ThisComponent.DrawPage(1).getByIndex(0).String
     310             : xray ThisComponent.DrawPage(1).getByIndex(0).Anchor.PageStyleName
     311             : */
     312           1 :     uno::Reference<drawing::XShapes> xShapes(getShape(2), uno::UNO_QUERY);
     313           2 :     uno::Reference<text::XTextRange> xShape(xShapes->getByIndex(0), uno::UNO_QUERY);
     314           1 :     CPPUNIT_ASSERT_EQUAL(OUString("TEXT1\n"), xShape->getString());
     315             :     // we want to test the textbox is on the first page (it was put onto another page without the fix),
     316             :     // use a small trick and instead of checking the page layout, check the page style
     317           2 :     uno::Reference<text::XTextContent> xTextContent(xShape, uno::UNO_QUERY);
     318           2 :     CPPUNIT_ASSERT_EQUAL(OUString("First Page"), getProperty<OUString>(xTextContent->getAnchor(), "PageStyleName"));
     319           1 : }
     320             : 
     321          12 : DECLARE_OOXMLIMPORT_TEST(testN705956_1, "n705956-1.docx")
     322             : {
     323             : /*
     324             : Get the first image in the document and check it's the one image in the document.
     325             : It should be also anchored inline (as character) and be inside a groupshape.
     326             : image = ThisComponent.DrawPage.getByIndex(0)
     327             : graphic = image(0).Graphic
     328             : xray graphic.Size
     329             : xray image.AnchorType
     330             : */
     331           1 :     uno::Reference<text::XTextDocument> textDocument(mxComponent, uno::UNO_QUERY);
     332           2 :     uno::Reference<drawing::XDrawPageSupplier> drawPageSupplier(textDocument, uno::UNO_QUERY);
     333           2 :     uno::Reference<drawing::XDrawPage> drawPage = drawPageSupplier->getDrawPage();
     334           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 1 ), drawPage->getCount());
     335           2 :     uno::Reference<drawing::XShapes> shapes(getShape(1), uno::UNO_QUERY);
     336           2 :     uno::Reference<drawing::XShape> image;
     337           1 :     shapes->getByIndex(0) >>= image;
     338           2 :     uno::Reference<beans::XPropertySet> imageProperties(image, uno::UNO_QUERY);
     339           2 :     uno::Reference<graphic::XGraphic> graphic;
     340           1 :     imageProperties->getPropertyValue( "Graphic" ) >>= graphic;
     341           2 :     uno::Reference<awt::XBitmap> bitmap(graphic, uno::UNO_QUERY);
     342           1 :     CPPUNIT_ASSERT_EQUAL( static_cast<sal_Int32>(120), bitmap->getSize().Width );
     343           1 :     CPPUNIT_ASSERT_EQUAL( static_cast<sal_Int32>(106), bitmap->getSize().Height );
     344             :     text::TextContentAnchorType anchorType;
     345           1 :     imageProperties->getPropertyValue( "AnchorType" ) >>= anchorType;
     346           2 :     CPPUNIT_ASSERT_EQUAL( text::TextContentAnchorType_AS_CHARACTER, anchorType );
     347           1 : }
     348             : 
     349          12 : DECLARE_OOXMLIMPORT_TEST(testN705956_2, "n705956-2.docx")
     350             : {
     351             : /*
     352             : <v:shapetype> must be global, reachable even from <v:shape> inside another <w:pict>
     353             : image = ThisComponent.DrawPage.getByIndex(0)
     354             : xray image.FillColor
     355             : */
     356           1 :     uno::Reference<drawing::XShape> image = getShape(1);
     357           2 :     uno::Reference<beans::XPropertySet> imageProperties(image, uno::UNO_QUERY);
     358             :     sal_Int32 fillColor;
     359           1 :     imageProperties->getPropertyValue( "FillColor" ) >>= fillColor;
     360           2 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 0xc0504d ), fillColor );
     361           1 : }
     362             : 
     363          12 : DECLARE_OOXMLIMPORT_TEST(testfdo90720, "testfdo90720.docx")
     364             : {
     365           1 :     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(mxComponent, uno::UNO_QUERY);
     366           2 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextFramesSupplier->getTextFrames(), uno::UNO_QUERY);
     367           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xIndexAccess->getCount());
     368           2 :     uno::Reference<text::XTextFrame> textbox(xIndexAccess->getByIndex(0), uno::UNO_QUERY);
     369           2 :     uno::Reference<beans::XPropertySet> properties(textbox, uno::UNO_QUERY);
     370             :     sal_Int32 fill_transperence;
     371           1 :     properties->getPropertyValue( "FillTransparence" ) >>= fill_transperence;
     372           2 :     CPPUNIT_ASSERT_EQUAL( sal_Int32(100), fill_transperence );
     373           1 : }
     374             : 
     375          12 : DECLARE_OOXMLIMPORT_TEST(testN747461, "n747461.docx")
     376             : {
     377             : /*
     378             : The document contains 3 images (Red, Black, Green, in this order), with explicit
     379             : w:relativeHeight (300, 0, 225763766). Check that they are in the right ZOrder
     380             : after they are loaded.
     381             : */
     382           2 :     uno::Reference<drawing::XShape> image1 = getShape(1), image2 = getShape(2), image3 = getShape(3);
     383             :     sal_Int32 zOrder1, zOrder2, zOrder3;
     384           2 :     OUString descr1, descr2, descr3;
     385           2 :     uno::Reference<beans::XPropertySet> imageProperties1(image1, uno::UNO_QUERY);
     386           1 :     imageProperties1->getPropertyValue( "ZOrder" ) >>= zOrder1;
     387           1 :     imageProperties1->getPropertyValue( "Description" ) >>= descr1;
     388           2 :     uno::Reference<beans::XPropertySet> imageProperties2(image2, uno::UNO_QUERY);
     389           1 :     imageProperties2->getPropertyValue( "ZOrder" ) >>= zOrder2;
     390           1 :     imageProperties2->getPropertyValue( "Description" ) >>= descr2;
     391           2 :     uno::Reference<beans::XPropertySet> imageProperties3(image3, uno::UNO_QUERY);
     392           1 :     imageProperties3->getPropertyValue( "ZOrder" ) >>= zOrder3;
     393           1 :     imageProperties3->getPropertyValue( "Description" ) >>= descr3;
     394           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 0 ), zOrder1 );
     395           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 1 ), zOrder2 );
     396           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 2 ), zOrder3 );
     397           1 :     CPPUNIT_ASSERT_EQUAL( OUString( "Black" ), descr1 );
     398           1 :     CPPUNIT_ASSERT_EQUAL( OUString( "Red" ), descr2 );
     399           2 :     CPPUNIT_ASSERT_EQUAL( OUString( "Green" ), descr3 );
     400           1 : }
     401             : 
     402          12 : DECLARE_OOXMLIMPORT_TEST(testN750255, "n750255.docx")
     403             : {
     404             : 
     405             : /*
     406             : Column break without columns on the page is a page break, so check those paragraphs
     407             : are on page 2 (page style 'Converted1') and page 3 (page style 'Converted2')
     408             : enum = ThisComponent.Text.createEnumeration
     409             : enum.nextElement
     410             : para1 = enum.nextElement
     411             : xray para1.String
     412             : xray para1.PageStyleName
     413             : para2 = enum.nextElement
     414             : xray para2.String
     415             : xray para2.PageStyleName
     416             : */
     417             :     // get the 2nd and 3rd paragraph
     418           1 :     uno::Reference<uno::XInterface> paragraph1(getParagraph( 2, "one" ));
     419           2 :     uno::Reference<uno::XInterface> paragraph2(getParagraph( 3, "two" ));
     420           2 :     OUString pageStyle1 = getProperty< OUString >( paragraph1, "PageStyleName" );
     421           2 :     OUString pageStyle2 = getProperty< OUString >( paragraph2, "PageStyleName" );
     422           1 :     CPPUNIT_ASSERT_EQUAL( OUString( "Converted1" ), pageStyle1 );
     423           2 :     CPPUNIT_ASSERT_EQUAL( OUString( "Converted2" ), pageStyle2 );
     424             : 
     425           1 : }
     426             : 
     427          12 : DECLARE_OOXMLIMPORT_TEST(testN652364, "n652364.docx")
     428             : {
     429             : /*
     430             : Related to 750255 above, column break with columns on the page however should be a column break.
     431             : enum = ThisComponent.Text.createEnumeration
     432             : enum.nextElement
     433             : para1 = enum.nextElement
     434             : xray para1.String
     435             : xray para1.PageStyleName
     436             : enum.nextElement
     437             : para2 = enum.nextElement
     438             : xray para2.String
     439             : xray para2.PageStyleName
     440             : */
     441             :     // get the 2nd and 4th paragraph
     442           1 :     uno::Reference<uno::XInterface> paragraph1(getParagraph( 2, "text1" ));
     443           2 :     uno::Reference<uno::XInterface> paragraph2(getParagraph( 4, "text2" ));
     444           2 :     OUString pageStyle1 = getProperty< OUString >( paragraph1, "PageStyleName" );
     445           2 :     OUString pageStyle2 = getProperty< OUString >( paragraph2, "PageStyleName" );
     446             :     // "Standard" is the style for the first page (2nd is "Converted1").
     447           1 :     CPPUNIT_ASSERT_EQUAL( OUString( "Standard" ), pageStyle1 );
     448           2 :     CPPUNIT_ASSERT_EQUAL( OUString( "Standard" ), pageStyle2 );
     449           1 : }
     450             : 
     451          12 : DECLARE_OOXMLIMPORT_TEST(testN760764, "n760764.docx")
     452             : {
     453           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
     454           2 :     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xTextDocument->getText(), uno::UNO_QUERY);
     455           2 :     uno::Reference<container::XEnumeration> xParaEnum(xParaEnumAccess->createEnumeration());
     456           2 :     uno::Reference<container::XEnumerationAccess> xRunEnumAccess(xParaEnum->nextElement(), uno::UNO_QUERY);
     457           2 :     uno::Reference<container::XEnumeration> xRunEnum(xRunEnumAccess->createEnumeration());
     458             : 
     459             :     // Access the second run, which is a textfield
     460           1 :     xRunEnum->nextElement();
     461           2 :     uno::Reference<beans::XPropertySet> xRun(xRunEnum->nextElement(), uno::UNO_QUERY);
     462             :     float fValue;
     463           1 :     xRun->getPropertyValue("CharHeight") >>= fValue;
     464             :     // This used to be 11, as character properties were ignored.
     465           2 :     CPPUNIT_ASSERT_EQUAL(8.f, fValue);
     466           1 : }
     467             : 
     468          12 : DECLARE_OOXMLIMPORT_TEST(testN764005, "n764005.docx")
     469             : {
     470           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
     471             : 
     472             :     // The picture in the header wasn't absolutely positioned and wasn't in the background.
     473             :     text::TextContentAnchorType eValue;
     474           1 :     xPropertySet->getPropertyValue("AnchorType") >>= eValue;
     475           1 :     CPPUNIT_ASSERT(eValue != text::TextContentAnchorType_AS_CHARACTER);
     476           1 :     bool bValue = true;
     477           1 :     xPropertySet->getPropertyValue("Opaque") >>= bValue;
     478           1 :     CPPUNIT_ASSERT_EQUAL(false, bool(bValue));
     479           1 : }
     480             : 
     481          12 : DECLARE_OOXMLIMPORT_TEST(testN764745, "n764745-alignment.docx")
     482             : {
     483             : /*
     484             : shape = ThisComponent.DrawPage.getByIndex(0)
     485             : xray shape.AnchorType
     486             : xray shape.AnchorPosition.X
     487             : xray ThisComponent.StyleFamilies.PageStyles.Default.Width
     488             : */
     489           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
     490             :     // The paragraph is right-aligned and the picture does not explicitly specify position,
     491             :     // so check it's anchored as character and in the right side of the document.
     492             :     text::TextContentAnchorType anchorType;
     493           1 :     xPropertySet->getPropertyValue("AnchorType") >>= anchorType;
     494           1 :     CPPUNIT_ASSERT_EQUAL(text::TextContentAnchorType_AS_CHARACTER, anchorType);
     495           1 :     awt::Point pos;
     496           1 :     xPropertySet->getPropertyValue("AnchorPosition") >>= pos;
     497           2 :     uno::Reference<style::XStyleFamiliesSupplier> styleFamiliesSupplier(mxComponent, uno::UNO_QUERY);
     498           2 :     uno::Reference<container::XNameAccess> styleFamilies = styleFamiliesSupplier->getStyleFamilies();
     499           2 :     uno::Reference<container::XNameAccess> pageStyles;
     500           1 :     styleFamilies->getByName("PageStyles") >>= pageStyles;
     501           2 :     uno::Reference<uno::XInterface> defaultStyle;
     502           1 :     pageStyles->getByName(DEFAULT_STYLE) >>= defaultStyle;
     503           2 :     uno::Reference<beans::XPropertySet> styleProperties( defaultStyle, uno::UNO_QUERY );
     504           1 :     sal_Int32 width = 0;
     505           1 :     styleProperties->getPropertyValue( "Width" ) >>= width;
     506           2 :     CPPUNIT_ASSERT( pos.X > width / 2 );
     507           1 : }
     508             : 
     509          12 : DECLARE_OOXMLIMPORT_TEST(testN766477, "n766477.docx")
     510             : {
     511             :     /*
     512             :      * The problem was that the checkbox was not checked.
     513             :      *
     514             :      * oParas = ThisComponent.Text.createEnumeration
     515             :      * oPara = oParas.nextElement
     516             :      * oRuns = oPara.createEnumeration
     517             :      * oRun = oRuns.nextElement
     518             :      * xray oRun.Bookmark.Parameters.ElementNames(0) 'Checkbox_Checked
     519             :      */
     520           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
     521           2 :     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xTextDocument->getText(), uno::UNO_QUERY);
     522           2 :     uno::Reference<container::XEnumeration> xParaEnum(xParaEnumAccess->createEnumeration());
     523           2 :     uno::Reference<container::XEnumerationAccess> xRunEnumAccess(xParaEnum->nextElement(), uno::UNO_QUERY);
     524           2 :     uno::Reference<container::XEnumeration> xRunEnum(xRunEnumAccess->createEnumeration());
     525           2 :     uno::Reference<beans::XPropertySet> xRun(xRunEnum->nextElement(), uno::UNO_QUERY);
     526           2 :     uno::Reference<text::XFormField> xFormField(xRun->getPropertyValue("Bookmark"), uno::UNO_QUERY);
     527           2 :     uno::Reference<container::XNameContainer> xParameters(xFormField->getParameters());
     528           2 :     uno::Sequence<OUString> aElementNames(xParameters->getElementNames());
     529           2 :     CPPUNIT_ASSERT_EQUAL(OUString("Checkbox_Checked"), aElementNames[0]);
     530           1 : }
     531             : 
     532          12 : DECLARE_OOXMLIMPORT_TEST(testN758883, "n758883.docx")
     533             : {
     534             :     /*
     535             :      * The problem was that direct formatting of the paragraph was not applied
     536             :      * to the numbering. This is easier to test using a layout dump.
     537             :      */
     538           1 :     OUString aHeight = parseDump("/root/page/body/txt/Special", "nHeight");
     539           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(220), aHeight.toInt32()); // It was 280
     540             : 
     541             :     /*
     542             :      * Next problem was that the page margin contained the width of the page border as well.
     543             :      *
     544             :      * xray ThisComponent.StyleFamilies.PageStyles.Default.LeftMargin
     545             :      */
     546           2 :     uno::Reference<beans::XPropertySet> xPropertySet(getStyles("PageStyles")->getByName(DEFAULT_STYLE), uno::UNO_QUERY);
     547           1 :     sal_Int32 nValue = 0;
     548           1 :     xPropertySet->getPropertyValue("LeftMargin") >>= nValue;
     549           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(794), nValue);
     550             : 
     551             :     // No assert for the 3rd problem: see the comment in the test doc.
     552             : 
     553             :     /*
     554             :      * 4th problem: Wrap type of the textwrape was not 'through'.
     555             :      *
     556             :      * xray ThisComponent.DrawPage(0).Surround ' was 2, should be 1
     557             :      */
     558           1 :     xPropertySet.set(getShape(1), uno::UNO_QUERY);
     559             :     text::WrapTextMode eValue;
     560           1 :     xPropertySet->getPropertyValue("Surround") >>= eValue;
     561           1 :     CPPUNIT_ASSERT_EQUAL(eValue, text::WrapTextMode_THROUGHT);
     562             : 
     563             :     /*
     564             :      * 5th problem: anchor type of the second textbox was wrong.
     565             :      *
     566             :      * xray ThisComponent.DrawPage(1).AnchorType ' was 1, should be 4
     567             :      */
     568           1 :     xPropertySet.set(getShape(2), uno::UNO_QUERY);
     569             :     text::TextContentAnchorType eAnchorType;
     570           1 :     xPropertySet->getPropertyValue("AnchorType") >>= eAnchorType;
     571           1 :     CPPUNIT_ASSERT_EQUAL(text::TextContentAnchorType_AT_CHARACTER, eAnchorType);
     572             : 
     573             :     // 6th problem: xray ThisComponent.DrawPage(2).AnchorType ' was 2, should be 4
     574           1 :     xPropertySet.set(getShape(3), uno::UNO_QUERY);
     575           1 :     xPropertySet->getPropertyValue("AnchorType") >>= eAnchorType;
     576           2 :     CPPUNIT_ASSERT_EQUAL(text::TextContentAnchorType_AT_CHARACTER, eAnchorType);
     577           1 : }
     578             : 
     579          12 : DECLARE_OOXMLIMPORT_TEST(testN766481, "n766481.docx")
     580             : {
     581             :     /*
     582             :      * The problem was that we had an additional paragraph before the pagebreak.
     583             :      *
     584             :      * oParas = ThisComponent.Text.createEnumeration
     585             :      * oPara = oParas.nextElement
     586             :      * oPara = oParas.nextElement
     587             :      * xray oParas.hasMoreElements ' should be false
     588             :      */
     589           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
     590           2 :     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xTextDocument->getText(), uno::UNO_QUERY);
     591           2 :     uno::Reference<container::XEnumeration> xParaEnum(xParaEnumAccess->createEnumeration());
     592           3 :     for (int i = 0; i < 2; ++i)
     593           2 :         xParaEnum->nextElement();
     594           2 :     CPPUNIT_ASSERT_EQUAL(sal_False, xParaEnum->hasMoreElements());
     595           1 : }
     596             : 
     597          12 : DECLARE_OOXMLIMPORT_TEST(testN766487, "n766487.docx")
     598             : {
     599             :     /*
     600             :      * The problem was that 1) the font size of the first para was too large 2) numbering had no first-line-indent.
     601             :      *
     602             :      * oParas = ThisComponent.Text.createEnumeration
     603             :      * oPara = oParas.nextElement
     604             :      * oRuns = oPara.createEnumeration
     605             :      * oRun = oRuns.nextElement
     606             :      * xray oRun.CharHeight ' 12, was larger
     607             :      * oPara = oParas.nextElement
     608             :      * xray oPara.ParaFirstLineIndent ' -635, was 0
     609             :      */
     610           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
     611           2 :     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xTextDocument->getText(), uno::UNO_QUERY);
     612           2 :     uno::Reference<container::XEnumeration> xParaEnum(xParaEnumAccess->createEnumeration());
     613             : 
     614           2 :     uno::Reference<container::XEnumerationAccess> xRunEnumAccess(xParaEnum->nextElement(), uno::UNO_QUERY);
     615           2 :     uno::Reference<container::XEnumeration> xRunEnum(xRunEnumAccess->createEnumeration());
     616           2 :     uno::Reference<beans::XPropertySet> xPropertySet(xRunEnum->nextElement(), uno::UNO_QUERY);
     617           1 :     float fValue = 0;
     618           1 :     xPropertySet->getPropertyValue("CharHeight") >>= fValue;
     619           1 :     CPPUNIT_ASSERT_EQUAL(12.f, fValue);
     620             : 
     621           1 :     xPropertySet.set(xParaEnum->nextElement(), uno::UNO_QUERY);
     622           1 :     sal_Int32 nValue = 0;
     623           1 :     xPropertySet->getPropertyValue("ParaFirstLineIndent") >>= nValue;
     624           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(convertTwipToMm100(-360)), nValue);
     625           1 : }
     626             : 
     627          12 : DECLARE_OOXMLIMPORT_TEST(testN693238, "n693238.docx")
     628             : {
     629             :     /*
     630             :      * The problem was that a continuous section break at the end of the doc caused the margins to be ignored.
     631             :      *
     632             :      * xray ThisComponent.StyleFamilies.PageStyles.Default.LeftMargin ' was 2000, should be 635
     633             :      */
     634           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getStyles("PageStyles")->getByName(DEFAULT_STYLE), uno::UNO_QUERY);
     635           1 :     sal_Int32 nValue = 0;
     636           1 :     xPropertySet->getPropertyValue("LeftMargin") >>= nValue;
     637           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(635), nValue);
     638           1 : }
     639             : 
     640          12 : DECLARE_OOXMLIMPORT_TEST(testNumbering1, "numbering1.docx")
     641             : {
     642             : /* <w:numPr> in the paragraph itself was overridden by <w:numpr> introduced by the paragraph's <w:pStyle>
     643             : enum = ThisComponent.Text.createEnumeration
     644             : para = enum.NextElement
     645             : xray para.NumberingStyleName
     646             : numberingstyle = ThisComponent.NumberingRules.getByIndex(6)
     647             : xray numberingstyle.name   - should match name above
     648             : numbering = numberingstyle.getByIndex(0)
     649             : xray numbering(11)  - should be 4, arabic
     650             : note that the indexes may get off as the implementation evolves, C++ code searches in loops
     651             : */
     652           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
     653           2 :     uno::Reference< text::XTextRange > paragraph(getParagraph( 1, "Text1." ));
     654           2 :     OUString numberingStyleName = getProperty< OUString >( paragraph, "NumberingStyleName" );
     655           2 :     uno::Reference<text::XNumberingRulesSupplier> xNumberingRulesSupplier(mxComponent, uno::UNO_QUERY);
     656           2 :     uno::Reference<container::XIndexAccess> numberingRules(xNumberingRulesSupplier->getNumberingRules(), uno::UNO_QUERY);
     657           2 :     uno::Reference<container::XIndexAccess> numberingRule;
     658          16 :     for( int i = 0;
     659           8 :          i < numberingRules->getCount();
     660             :          ++i )
     661             :     {
     662           8 :         OUString name = getProperty< OUString >( numberingRules->getByIndex( i ), "Name" );
     663           8 :         if( name == numberingStyleName )
     664             :         {
     665           1 :             numberingRule.set( numberingRules->getByIndex( i ), uno::UNO_QUERY );
     666           1 :             break;
     667             :         }
     668           7 :     }
     669           1 :     CPPUNIT_ASSERT( numberingRule.is());
     670           2 :     uno::Sequence< beans::PropertyValue > numbering;
     671           1 :     numberingRule->getByIndex( 0 ) >>= numbering;
     672           1 :     sal_Int16 numberingType = style::NumberingType::NUMBER_NONE;
     673          24 :     for( int i = 0;
     674          12 :          i < numbering.getLength();
     675             :          ++i )
     676             :         {
     677          12 :         if( numbering[ i ].Name == "NumberingType" )
     678             :             {
     679           1 :             numbering[ i ].Value >>= numberingType;
     680           1 :             break;
     681             :             }
     682             :         }
     683           2 :     CPPUNIT_ASSERT_EQUAL( style::NumberingType::ARABIC, numberingType );
     684           1 : }
     685             : 
     686          12 : DECLARE_OOXMLIMPORT_TEST(testBnc773061, "bnc773061.docx")
     687             : {
     688           1 :     uno::Reference< text::XTextRange > paragraph = getParagraph( 1 );
     689           2 :     uno::Reference< text::XTextRange > normal = getRun( paragraph, 1, "Normal " );
     690           2 :     uno::Reference< text::XTextRange > raised = getRun( paragraph, 2, "Raised" );
     691           2 :     uno::Reference< text::XTextRange > lowered = getRun( paragraph, 4, "Lowered" );
     692           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 0 ), getProperty< sal_Int32 >( normal, "CharEscapement" ));
     693           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 50 ), getProperty< sal_Int32 >( raised, "CharEscapement" ));
     694           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( -25 ), getProperty< sal_Int32 >( lowered, "CharEscapement" ));
     695           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 100 ), getProperty< sal_Int32 >( normal, "CharEscapementHeight" ));
     696           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 100 ), getProperty< sal_Int32 >( raised, "CharEscapementHeight" ));
     697           2 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 100 ), getProperty< sal_Int32 >( lowered, "CharEscapementHeight" ));
     698           1 : }
     699             : 
     700          12 : DECLARE_OOXMLIMPORT_TEST(testAllGapsWord, "all_gaps_word.docx")
     701             : {
     702           1 :     BorderTest borderTest;
     703           1 :     BorderTest::testTheBorders(mxComponent, false);
     704           1 : }
     705             : 
     706          12 : DECLARE_OOXMLIMPORT_TEST(testN775906, "n775906.docx")
     707             : {
     708             :     /*
     709             :      * The problem was that right margin (via direct formatting) erased the left/first margin (inherited from numbering style).
     710             :      *
     711             :      * oParas = ThisComponent.Text.createEnumeration
     712             :      * oPara = oParas.nextElement
     713             :      * xray oPara.ParaFirstLineIndent ' was 0
     714             :      * xray oPara.ParaLeftMargin ' was 0
     715             :      */
     716           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(-635), getProperty<sal_Int32>(getParagraph(1), "ParaFirstLineIndent"));
     717           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1905), getProperty<sal_Int32>(getParagraph(1), "ParaLeftMargin"));
     718           1 : }
     719             : 
     720          12 : DECLARE_OOXMLIMPORT_TEST(testN775899, "n775899.docx")
     721             : {
     722             :     /*
     723             :      * The problem was that a floating table wasn't imported as a frame, then it contained fake paragraphs.
     724             :      *
     725             :      * ThisComponent.TextFrames.Count ' was 0
     726             :      * oParas = ThisComponent.TextFrames(0).Text.createEnumeration
     727             :      * oPara = oParas.nextElement
     728             :      * oPara.supportsService("com.sun.star.text.TextTable") 'was a fake paragraph
     729             :      * oParas.hasMoreElements 'was true
     730             :      */
     731           1 :     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(mxComponent, uno::UNO_QUERY);
     732           2 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextFramesSupplier->getTextFrames(), uno::UNO_QUERY);
     733           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
     734             : 
     735           2 :     uno::Reference<text::XTextFrame> xFrame(xIndexAccess->getByIndex(0), uno::UNO_QUERY);
     736           2 :     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xFrame->getText(), uno::UNO_QUERY);
     737           2 :     uno::Reference<container::XEnumeration> xParaEnum = xParaEnumAccess->createEnumeration();
     738           2 :     uno::Reference<lang::XServiceInfo> xServiceInfo(xParaEnum->nextElement(), uno::UNO_QUERY);
     739           1 :     CPPUNIT_ASSERT_EQUAL(sal_True, xServiceInfo->supportsService("com.sun.star.text.TextTable"));
     740             : 
     741           2 :     CPPUNIT_ASSERT_EQUAL(sal_False, xParaEnum->hasMoreElements());
     742           1 : }
     743             : 
     744          12 : DECLARE_OOXMLIMPORT_TEST(testN777345, "n777345.docx")
     745             : {
     746             : #if !defined(MACOSX)
     747             :     // The problem was that v:imagedata inside v:rect was ignored.
     748           1 :     uno::Reference<document::XEmbeddedObjectSupplier2> xSupplier(getShape(1), uno::UNO_QUERY);
     749           2 :     uno::Reference<graphic::XGraphic> xGraphic = xSupplier->getReplacementGraphic();
     750           2 :     Graphic aGraphic(xGraphic);
     751             :     // If this changes later, feel free to update it, but make sure it's not
     752             :     // the checksum of a white/transparent placeholder rectangle.
     753           2 :     CPPUNIT_ASSERT_EQUAL(sal_uLong(2529763117U), aGraphic.GetChecksum());
     754             : #endif
     755           1 : }
     756             : 
     757          12 : DECLARE_OOXMLIMPORT_TEST(testN777337, "n777337.docx")
     758             : {
     759             :     /*
     760             :      * The problem was that the top and bottom margin on the first page was only 0.1cm instead of 1.7cm.
     761             :      *
     762             :      * oFirst = ThisComponent.StyleFamilies.PageStyles.getByName("First Page")
     763             :      * xray oFirst.TopMargin
     764             :      * xray oFirst.BottomMargin
     765             :      */
     766           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getStyles("PageStyles")->getByName("First Page"), uno::UNO_QUERY);
     767           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1702), getProperty<sal_Int32>(xPropertySet, "TopMargin"));
     768           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1702), getProperty<sal_Int32>(xPropertySet, "BottomMargin"));
     769           1 : }
     770             : 
     771          12 : DECLARE_OOXMLIMPORT_TEST(testN778836, "n778836.docx")
     772             : {
     773             :     /*
     774             :      * The problem was that the paragraph inherited margins from the numbering
     775             :      * and parent paragraph styles and the result was incorrect.
     776             :      */
     777           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1270), getProperty<sal_Int32>(getParagraph(0), "ParaRightMargin"));
     778           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3810), getProperty<sal_Int32>(getParagraph(0), "ParaLeftMargin"));
     779           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(-635), getProperty<sal_Int32>(getParagraph(0), "ParaFirstLineIndent"));
     780           1 : }
     781             : 
     782          12 : DECLARE_OOXMLIMPORT_TEST(testN778140, "n778140.docx")
     783             : {
     784             :     /*
     785             :      * The problem was that the paragraph top/bottom margins were incorrect due
     786             :      * to unhandled w:doNotUseHTMLParagraphAutoSpacing.
     787             :      */
     788           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(176), getProperty<sal_Int32>(getParagraph(0), "ParaTopMargin"));
     789           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(176), getProperty<sal_Int32>(getParagraph(0), "ParaBottomMargin"));
     790           1 : }
     791             : 
     792          12 : DECLARE_OOXMLIMPORT_TEST(testN778828, "n778828.docx")
     793             : {
     794             :     /*
     795             :      * The problem was that a page break after a continuous section break caused
     796             :      * double page break on title page.
     797             :      */
     798           1 :     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
     799           2 :     uno::Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(), uno::UNO_QUERY);
     800           2 :     uno::Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), uno::UNO_QUERY);
     801           1 :     xCursor->jumpToLastPage();
     802           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(2), xCursor->getPage());
     803           1 : }
     804             : 
     805          12 : DECLARE_OOXMLIMPORT_TEST(testInk, "ink.docx")
     806             : {
     807             :     /*
     808             :      * The problem was that ~nothing was imported, except an empty CustomShape.
     809             :      *
     810             :      * xray ThisComponent.DrawPage(0).supportsService("com.sun.star.drawing.OpenBezierShape")
     811             :      */
     812           1 :     uno::Reference<lang::XServiceInfo> xServiceInfo(getShape(1), uno::UNO_QUERY);
     813           1 :     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.drawing.OpenBezierShape"));
     814           1 : }
     815             : 
     816          12 : DECLARE_OOXMLIMPORT_TEST(testN779834, "n779834.docx")
     817             : {
     818             :     // This document simply crashed the importer.
     819           1 : }
     820             : 
     821          12 : DECLARE_OOXMLIMPORT_TEST(testRHBZ1180114, "rhbz1180114.docx")
     822             : {
     823             :     // This document simply crashed the importer.
     824           1 : }
     825             : 
     826          12 : DECLARE_OOXMLIMPORT_TEST(testN779627, "n779627.docx")
     827             : {
     828             :     /*
     829             :      * The problem was that the table left position was based on the tableCellMar left value
     830             :      * even for nested tables, while it shouldn't.
     831             :      */
     832           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
     833           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
     834           2 :     uno::Reference<beans::XPropertySet> xTableProperties(xTables->getByIndex(0), uno::UNO_QUERY);
     835           2 :     uno::Any aValue = xTableProperties->getPropertyValue("LeftMargin");
     836             :     sal_Int32 nLeftMargin;
     837           1 :     aValue >>= nLeftMargin;
     838           2 :     CPPUNIT_ASSERT_EQUAL_MESSAGE( "Left margin shouldn't take tableCellMar into account in nested tables",
     839           1 :             sal_Int32(0), nLeftMargin);
     840             : 
     841             :     /*
     842             :      * Another problem tested with this document is the unnecessary loading of the shapes
     843             :      * anchored to a discarded header or footer
     844             :      */
     845           2 :     uno::Reference<text::XTextDocument> textDocument(mxComponent, uno::UNO_QUERY);
     846           2 :     uno::Reference<drawing::XDrawPageSupplier> drawPageSupplier(textDocument, uno::UNO_QUERY);
     847           2 :     uno::Reference<drawing::XDrawPage> drawPage = drawPageSupplier->getDrawPage();
     848           2 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 0 ), drawPage->getCount());
     849           1 : }
     850             : 
     851          12 : DECLARE_OOXMLIMPORT_TEST(testN779627b, "n779627b.docx")
     852             : {
     853             :     /*
     854             :      * Another problem tested with the original n779627.docx document (before removing its unnecessary
     855             :      * shape loading) is that the roundrect is centered vertically and horizontally.
     856             :      */
     857           1 :     uno::Reference<beans::XPropertySet> xShapeProperties( getShape(1), uno::UNO_QUERY );
     858           2 :     uno::Reference<drawing::XShapeDescriptor> xShapeDescriptor(xShapeProperties, uno::UNO_QUERY);
     859             :     // If this goes wrong, probably the index of the shape is changed and the test should be adjusted.
     860           1 :     CPPUNIT_ASSERT_EQUAL(OUString("com.sun.star.drawing.RectangleShape"), xShapeDescriptor->getShapeType());
     861             :     sal_Int16 nValue;
     862           1 :     xShapeProperties->getPropertyValue("HoriOrient") >>= nValue;
     863           1 :     CPPUNIT_ASSERT_EQUAL_MESSAGE("Not centered horizontally", text::HoriOrientation::CENTER, nValue);
     864           1 :     xShapeProperties->getPropertyValue("HoriOrientRelation") >>= nValue;
     865           1 :     CPPUNIT_ASSERT_EQUAL_MESSAGE("Not centered horizontally relatively to page", text::RelOrientation::PAGE_FRAME, nValue);
     866           1 :     xShapeProperties->getPropertyValue("VertOrient") >>= nValue;
     867           1 :     CPPUNIT_ASSERT_EQUAL_MESSAGE("Not centered vertically", text::VertOrientation::CENTER, nValue);
     868           1 :     xShapeProperties->getPropertyValue("VertOrientRelation") >>= nValue;
     869           2 :     CPPUNIT_ASSERT_EQUAL_MESSAGE("Not centered vertically relatively to page", text::RelOrientation::PAGE_FRAME, nValue);
     870           1 : }
     871             : 
     872          12 : DECLARE_OOXMLIMPORT_TEST(testTDF91122, "tdf91122.docx")
     873             : {
     874             :     /*
     875             :      * OLE object shape: default vertical position is top in MSO, not bottom
     876             :      */
     877           3 :     for (int i = 1; i <= 2; ++i)
     878             :     {
     879           2 :         uno::Reference<beans::XPropertySet> xShapeProperties( getShape(i), uno::UNO_QUERY );
     880           4 :         uno::Reference<drawing::XShapeDescriptor> xShapeDescriptor(xShapeProperties, uno::UNO_QUERY);
     881           2 :         CPPUNIT_ASSERT_EQUAL(OUString("FrameShape"), xShapeDescriptor->getShapeType());
     882             :         sal_Int16 nValue;
     883           2 :         xShapeProperties->getPropertyValue("VertOrient") >>= nValue;
     884           2 :         CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong vertical orientation", text::VertOrientation::TOP, nValue);
     885           2 :     }
     886           1 : }
     887             : 
     888          12 : DECLARE_OOXMLIMPORT_TEST(testTDF91260, "tdf91260.docx")
     889             : {
     890             :     /*
     891             :      * textbox can't extend beyond the page bottom
     892             :      * solution: shrinking textbox (its text frame) height, if needed
     893             :      */
     894           1 :     uno::Reference<text::XTextRange> xFrame(getShape(1), uno::UNO_QUERY);
     895           1 :     CPPUNIT_ASSERT(xFrame->getString().startsWith( "Lorem ipsum" ) );
     896           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3454), getProperty<sal_Int32>(xFrame, "Height"));
     897           1 : }
     898             : 
     899          12 : DECLARE_OOXMLIMPORT_TEST(testFdo74357, "fdo74357.docx")
     900             : {
     901             :     // Floating table wasn't converted to a textframe.
     902           1 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
     903           2 :     uno::Reference<container::XIndexAccess> xDrawPage(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
     904             :     // This was 0.
     905           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xDrawPage->getCount());
     906             : 
     907             :     // Bottom margin of the first paragraph was too large, causing a layout problem.
     908             :     // This was 494.
     909           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(86), getProperty<sal_Int32>(getParagraph(1), "ParaBottomMargin"));
     910           1 : }
     911             : 
     912          12 : DECLARE_OOXMLIMPORT_TEST(testFdo55187, "fdo55187.docx")
     913             : {
     914             :     // 0x010d was imported as a newline.
     915           1 :     getParagraph(1, OUString("lup\xc4\x8dka", 7, RTL_TEXTENCODING_UTF8));
     916           1 : }
     917             : 
     918          12 : DECLARE_OOXMLIMPORT_TEST(testN780563, "n780563.docx")
     919             : {
     920             :     /*
     921             :      * Make sure we have the table in the fly frame created
     922             :      */
     923           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
     924           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
     925           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount( ));
     926           1 : }
     927             : 
     928          12 : DECLARE_OOXMLIMPORT_TEST(testN780853, "n780853.docx")
     929             : {
     930             :     /*
     931             :      * The problem was that the table was not imported.
     932             :      *
     933             :      * xray ThisComponent.TextTables.Count 'was 0
     934             :      */
     935           1 :     uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent, uno::UNO_QUERY);
     936           2 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextTablesSupplier->getTextTables(), uno::UNO_QUERY);
     937           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
     938           1 : }
     939             : 
     940          12 : DECLARE_OOXMLIMPORT_TEST(testN780843, "n780843.docx")
     941             : {
     942             :     /*
     943             :      * The problem was that wrong footer was picked.
     944             :      *
     945             :      * oParas = ThisComponent.Text.createEnumeration
     946             :      * oPara = oParas.nextElement
     947             :      * oPara = oParas.nextElement
     948             :      * oPara = oParas.nextElement
     949             :      * sStyle = oPara.PageStyleName
     950             :      * oStyle = ThisComponent.StyleFamilies.PageStyles.getByName(sStyle)
     951             :      * xray oStyle.FooterText.String ' was "hidden footer"
     952             :      */
     953           1 :     uno::Reference< text::XTextRange > xPara = getParagraph(3);
     954           2 :     OUString aStyleName = getProperty<OUString>(xPara, "PageStyleName");
     955           2 :     uno::Reference<beans::XPropertySet> xPageStyle(getStyles("PageStyles")->getByName(aStyleName), uno::UNO_QUERY);
     956           2 :     uno::Reference<text::XTextRange> xFooter = getProperty< uno::Reference<text::XTextRange> >(xPageStyle, "FooterText");
     957           2 :     CPPUNIT_ASSERT_EQUAL(OUString("shown footer"), xFooter->getString());
     958           1 : }
     959             : 
     960          12 : DECLARE_OOXMLIMPORT_TEST(testShadow, "imgshadow.docx")
     961             : {
     962             :     /*
     963             :      * The problem was that drop shadows on inline images were not being
     964             :      * imported and applied.
     965             :      */
     966           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(2), uno::UNO_QUERY);
     967             : 
     968           1 :     bool bShadow = getProperty<bool>(xPropertySet, "Shadow");
     969           1 :     CPPUNIT_ASSERT(bShadow);
     970             : 
     971           1 :     sal_Int32 nShadowXDistance = getProperty<sal_Int32>(xPropertySet, "ShadowXDistance");
     972           1 :     CPPUNIT_ASSERT(nShadowXDistance != 0);
     973           1 : }
     974             : 
     975          12 : DECLARE_OOXMLIMPORT_TEST(testN782061, "n782061.docx")
     976             : {
     977             :     /*
     978             :      * The problem was that the character escapement in the second run was -58.
     979             :      */
     980           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(-9), getProperty<sal_Int32>(getRun(getParagraph(1), 2), "CharEscapement"));
     981           1 : }
     982             : 
     983          12 : DECLARE_OOXMLIMPORT_TEST(testN782345, "n782345.docx")
     984             : {
     985             :     /*
     986             :      * The problem was that the page break was inserted before the 3rd para, instead of before the 2nd para.
     987             :      */
     988           1 :     CPPUNIT_ASSERT_EQUAL(style::BreakType_PAGE_BEFORE, getProperty<style::BreakType>(getParagraph(2), "BreakType"));
     989           1 : }
     990             : 
     991          12 : DECLARE_OOXMLIMPORT_TEST(testN779941, "n779941.docx")
     992             : {
     993             :     /*
     994             :      * Make sure top/bottom margins of tables are set to 0 (problem was: bottom margin set to 0.35cm)
     995             :      */
     996           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
     997           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
     998           2 :     uno::Reference<beans::XPropertySet> xTableProperties(xTables->getByIndex(0), uno::UNO_QUERY);
     999             :     {
    1000           1 :         uno::Any aValue = xTableProperties->getPropertyValue("TopMargin");
    1001             :         sal_Int32 nTopMargin;
    1002           1 :         aValue >>= nTopMargin;
    1003           1 :         CPPUNIT_ASSERT_EQUAL(sal_Int32(0), nTopMargin);
    1004             :     }
    1005             :     {
    1006           1 :         uno::Any aValue = xTableProperties->getPropertyValue("BottomMargin");
    1007             :         sal_Int32 nBottomMargin;
    1008           1 :         aValue >>= nBottomMargin;
    1009           1 :         CPPUNIT_ASSERT_EQUAL(sal_Int32(0), nBottomMargin);
    1010           1 :     }
    1011           1 : }
    1012             : 
    1013          12 : DECLARE_OOXMLIMPORT_TEST(testN783638, "n783638.docx")
    1014             : {
    1015             :     // The problem was that the margins of inline images were not zero.
    1016           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
    1017           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), getProperty<sal_Int32>(xPropertySet, "LeftMargin"));
    1018           1 : }
    1019             : 
    1020          12 : DECLARE_OOXMLIMPORT_TEST(testFdo52208, "fdo52208.docx")
    1021             : {
    1022             :     // The problem was that the document had 2 pages instead of 1.
    1023           1 :     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
    1024           2 :     uno::Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(), uno::UNO_QUERY);
    1025           2 :     uno::Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), uno::UNO_QUERY);
    1026           1 :     xCursor->jumpToLastPage();
    1027           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(1), xCursor->getPage());
    1028           1 : }
    1029             : 
    1030          12 : DECLARE_OOXMLIMPORT_TEST(testN785767, "n785767.docx")
    1031             : {
    1032           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1033           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    1034           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1035           2 :     uno::Reference<table::XTableRows> xTableRows(xTextTable->getRows(), uno::UNO_QUERY);
    1036             :     // Check the A1 and B1 cells, the width of both of them was the default value (10000 / 9, as there were 9 cells in the row).
    1037           1 :     CPPUNIT_ASSERT_MESSAGE("A1 must not have default width", sal_Int16(10000 / 9) != getProperty< uno::Sequence<text::TableColumnSeparator> >(xTableRows->getByIndex(0), "TableColumnSeparators")[0].Position);
    1038           2 :     CPPUNIT_ASSERT_MESSAGE("B1 must not have default width", sal_Int16(10000 / 9) != getProperty< uno::Sequence<text::TableColumnSeparator> >(xTableRows->getByIndex(1), "TableColumnSeparators")[0].Position);
    1039           1 : }
    1040             : 
    1041          12 : DECLARE_OOXMLIMPORT_TEST(testN773061, "n773061.docx")
    1042             : {
    1043             : // xray ThisComponent.TextFrames(0).LeftBorderDistance
    1044           1 :     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(mxComponent, uno::UNO_QUERY);
    1045           2 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextFramesSupplier->getTextFrames(), uno::UNO_QUERY);
    1046           2 :     uno::Reference<beans::XPropertySet> xFrame(xIndexAccess->getByIndex(0), uno::UNO_QUERY);
    1047           1 :     CPPUNIT_ASSERT_EQUAL( getProperty< sal_Int32 >( xFrame, "LeftBorderDistance" ), sal_Int32( 0 ));
    1048           1 :     CPPUNIT_ASSERT_EQUAL( getProperty< sal_Int32 >( xFrame, "TopBorderDistance" ), sal_Int32( 0 ));
    1049           1 :     CPPUNIT_ASSERT_EQUAL( getProperty< sal_Int32 >( xFrame, "RightBorderDistance" ), sal_Int32( 0 ));
    1050           2 :     CPPUNIT_ASSERT_EQUAL( getProperty< sal_Int32 >( xFrame, "BottomBorderDistance" ), sal_Int32( 0 ));
    1051           1 : }
    1052             : 
    1053          12 : DECLARE_OOXMLIMPORT_TEST(testN780645, "n780645.docx")
    1054             : {
    1055             :     // The problem was that when the number of cells didn't match the grid, we
    1056             :     // didn't take care of direct cell widths.
    1057           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1058           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    1059           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1060           2 :     uno::Reference<table::XTableRows> xTableRows(xTextTable->getRows(), uno::UNO_QUERY);
    1061           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(2135), getProperty< uno::Sequence<text::TableColumnSeparator> >(xTableRows->getByIndex(1), "TableColumnSeparators")[0].Position); // was 1999
    1062           1 : }
    1063             : 
    1064          12 : DECLARE_OOXMLIMPORT_TEST(testFineTableDash, "tableborder-finedash.docx")
    1065             : {
    1066             :     // The problem was that finely dashed borders on tables were unsupported
    1067           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1068           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    1069           2 :     uno::Reference<beans::XPropertySet> xTableProperties(xTables->getByIndex(0), uno::UNO_QUERY);
    1070           1 :     table::TableBorder2 aBorder;
    1071           1 :     xTableProperties->getPropertyValue("TableBorder2") >>= aBorder;
    1072           2 :     CPPUNIT_ASSERT_EQUAL(aBorder.RightLine.LineStyle, table::BorderLineStyle::FINE_DASHED);
    1073           1 : }
    1074             : 
    1075          12 : DECLARE_OOXMLIMPORT_TEST(testN792778, "n792778.docx")
    1076             : {
    1077             :     /*
    1078             :      * The problem was that the importer didn't handle complex groupshapes with groupshapes, textboxes and graphics inside.
    1079             :      *
    1080             :      * xray ThisComponent.DrawPage.Count ' 1 groupshape
    1081             :      * xray ThisComponent.DrawPage(0).Count ' 2 sub-groupshapes
    1082             :      * xray ThisComponent.DrawPage(0).getByIndex(0).Count ' first sub-groupshape: 1 pic
    1083             :      * xray ThisComponent.DrawPage(0).getByIndex(1).Count ' second sub-groupshape: 1 pic
    1084             :      * xray ThisComponent.DrawPage(0).getByIndex(0).getByIndex(0).Position.Y ' 11684, the vertical position of the shapes were also wrong
    1085             :      * xray ThisComponent.DrawPage(0).getByIndex(1).getByIndex(0).Position.Y ' 11684
    1086             :      */
    1087           1 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
    1088           2 :     uno::Reference<container::XIndexAccess> xDrawPage(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
    1089           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xDrawPage->getCount());
    1090             : 
    1091           2 :     uno::Reference<drawing::XShapes> xGroupShape(xDrawPage->getByIndex(0), uno::UNO_QUERY);
    1092           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xGroupShape->getCount());
    1093             : 
    1094           2 :     uno::Reference<drawing::XShapes> xInnerGroupShape(xGroupShape->getByIndex(0), uno::UNO_QUERY);
    1095           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xInnerGroupShape->getCount());
    1096             : 
    1097           2 :     uno::Reference<drawing::XShape> xInnerShape(xInnerGroupShape->getByIndex(0), uno::UNO_QUERY);
    1098           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(11684), xInnerShape->getPosition().Y);
    1099             : 
    1100           1 :     xInnerGroupShape.set(xGroupShape->getByIndex(1), uno::UNO_QUERY);
    1101           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xInnerGroupShape->getCount());
    1102             : 
    1103           1 :     xInnerShape.set(xInnerGroupShape->getByIndex(0), uno::UNO_QUERY);
    1104           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(11684), xInnerShape->getPosition().Y);
    1105           1 : }
    1106             : 
    1107          12 : DECLARE_OOXMLIMPORT_TEST(testWordArtResizing, "WordArt.docx")
    1108             : {
    1109             :     /* The Word-Arts and watermarks were getting resized automatically, It was as if they were
    1110             :        getting glued to the fallback geometry(the sdrObj) and were getting bound to the font size.
    1111             :        The test-case esures the original height and width of the word-art is not changed while importing*/
    1112             : 
    1113           1 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
    1114           2 :     uno::Reference<container::XIndexAccess> xDrawPage(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
    1115           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xDrawPage->getCount());
    1116             : 
    1117           2 :     uno::Reference<drawing::XShape> xShape(xDrawPage->getByIndex(0), uno::UNO_QUERY);
    1118           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(10105), xShape->getSize().Width);
    1119           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(4755), xShape->getSize().Height);
    1120           1 : }
    1121             : 
    1122          12 : DECLARE_OOXMLIMPORT_TEST(testGroupshapeLine, "groupshape-line.docx")
    1123             : {
    1124             :     /*
    1125             :      * Another fallout from n#792778, this time first the lines inside a
    1126             :      * groupshape wasn't imported, then the fix broke the size/position of
    1127             :      * non-groupshape lines. Test both here.
    1128             :      *
    1129             :      * xray ThisComponent.DrawPage.Count ' 2 shapes
    1130             :      * xray ThisComponent.DrawPage(0).Position 'x: 2656, y: 339
    1131             :      * xray ThisComponent.DrawPage(0).Size ' width: 3270, height: 1392
    1132             :      * xray ThisComponent.DrawPage(1).getByIndex(0).Position 'x: 1272, y: 2286
    1133             :      * xray ThisComponent.DrawPage(1).getByIndex(0).Size 'width: 10160, height: 0
    1134             :      */
    1135           1 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
    1136           2 :     uno::Reference<container::XIndexAccess> xDrawPage(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
    1137           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xDrawPage->getCount());
    1138             : 
    1139           2 :     uno::Reference<drawing::XShape> xShape(xDrawPage->getByIndex(0), uno::UNO_QUERY);
    1140           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2656), xShape->getPosition().X);
    1141           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(339), xShape->getPosition().Y);
    1142           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3270), xShape->getSize().Width);
    1143           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1392), xShape->getSize().Height);
    1144             : 
    1145           2 :     uno::Reference<drawing::XShapes> xGroupShape(xDrawPage->getByIndex(1), uno::UNO_QUERY);
    1146           1 :     xShape.set(xGroupShape->getByIndex(0), uno::UNO_QUERY);
    1147           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1272), xShape->getPosition().X);
    1148           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2286), xShape->getPosition().Y);
    1149           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(10160), xShape->getSize().Width);
    1150           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xShape->getSize().Height);
    1151           1 : }
    1152             : 
    1153          12 : DECLARE_OOXMLIMPORT_TEST(testGroupshapeChildRotation, "groupshape-child-rotation.docx")
    1154             : {
    1155             :     // The problem was that (due to incorrect handling of rotation inside
    1156             :     // groupshapes), the first child wasn't in the top left corner of an inline
    1157             :     // groupshape.
    1158           1 :     uno::Reference<drawing::XShapes> xGroupShape(getShape(1), uno::UNO_QUERY);
    1159           2 :     uno::Reference<drawing::XShape> xShape(xGroupShape->getByIndex(0), uno::UNO_QUERY);
    1160           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xShape->getPosition().X);
    1161           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xShape->getPosition().Y);
    1162             : 
    1163             : #if ! TEST_FONTS_MISSING
    1164           1 :     xShape.set(xGroupShape->getByIndex(4), uno::UNO_QUERY);
    1165             :     // This was 887, i.e. border distances were included in the height.
    1166           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(686), xShape->getSize().Height);
    1167             : #endif
    1168             : 
    1169           2 :     uno::Reference<drawing::XShapeDescriptor> xShapeDescriptor(xGroupShape->getByIndex(5), uno::UNO_QUERY);
    1170             :     // This was com.sun.star.drawing.RectangleShape, all shape text in a single line.
    1171           2 :     CPPUNIT_ASSERT_EQUAL(OUString("com.sun.star.drawing.TextShape"), xShapeDescriptor->getShapeType());
    1172           1 : }
    1173             : 
    1174          12 : DECLARE_OOXMLIMPORT_TEST(testGroupshapeSmarttag, "groupshape-smarttag.docx")
    1175             : {
    1176           1 :     uno::Reference<drawing::XShapes> xGroupShape(getShape(1), uno::UNO_QUERY);
    1177           2 :     uno::Reference<text::XTextRange> xShape(xGroupShape->getByIndex(0), uno::UNO_QUERY);
    1178             :     // First run of shape text was missing due to the w:smartTag wrapper around it.
    1179           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Box 2"), xShape->getString());
    1180             : 
    1181             :     // Font size of the shape text was 10.
    1182           2 :     CPPUNIT_ASSERT_EQUAL(12.f, getProperty<float>(xShape->getText(), "CharHeight"));
    1183           1 : }
    1184             : 
    1185          12 : DECLARE_OOXMLIMPORT_TEST(testN793262, "n793262.docx")
    1186             : {
    1187           1 :     uno::Reference<container::XEnumerationAccess> xHeaderText = getProperty< uno::Reference<container::XEnumerationAccess> >(getStyles("PageStyles")->getByName(DEFAULT_STYLE), "HeaderText");
    1188           2 :     uno::Reference<container::XEnumeration> xHeaderParagraphs(xHeaderText->createEnumeration());
    1189           1 :     xHeaderParagraphs->nextElement();
    1190             :     // Font size of the last empty paragraph in the header was ignored, this was 11.
    1191           1 :     CPPUNIT_ASSERT_EQUAL(16.f, getProperty<float>(xHeaderParagraphs->nextElement(), "CharHeight"));
    1192             : 
    1193           2 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1194           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1195           2 :     uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1196             :     // Cell margins as direct formatting were ignored, this was 0.
    1197           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(76), getProperty<sal_Int32>(xTable->getCellByName("A1"), "TopBorderDistance"));
    1198           1 : }
    1199             : 
    1200          12 : DECLARE_OOXMLIMPORT_TEST(testN793998, "n793998.docx")
    1201             : {
    1202           1 :     sal_Int32 nTextPortion = parseDump("/root/page/body/txt/Text[1]", "nWidth").toInt32(); // Width of the first (text) portion
    1203           1 :     sal_Int32 nTabPortion = parseDump("/root/page/body/txt/Text[2]", "nWidth").toInt32(); // Width of the second (tab) portion
    1204           1 :     sal_Int32 nParagraph = parseDump("/root/page/body/txt/infos/bounds", "width").toInt32(); // Width of the paragraph
    1205           1 :     sal_Int32 nRightMargin = 3000;
    1206             :     // The problem was that the tab portion didn't ignore the right margin, so text + tab width wasn't larger than body (paragraph - right margin) width.
    1207           1 :     CPPUNIT_ASSERT(nTextPortion + nTabPortion > nParagraph - nRightMargin);
    1208           1 : }
    1209             : 
    1210          12 : DECLARE_OOXMLIMPORT_TEST(testN779642, "n779642.docx")
    1211             : {
    1212           1 :     uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent, uno::UNO_QUERY);
    1213             : 
    1214             :     // First problem: check that we have 2 tables, nesting caused the
    1215             :     // creation of outer one to fail
    1216           2 :     uno::Reference<container::XIndexAccess> xTables(xTextTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1217           1 :     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong number of imported tables", sal_Int32(2), xTables->getCount());
    1218             : 
    1219             :     // Second problem: check that the outer table is in a frame, at the bottom of the page
    1220           2 :     uno::Reference<text::XTextTable> xTextTable(xTextTablesSupplier->getTextTables()->getByName("Table2"), uno::UNO_QUERY);
    1221           2 :     uno::Reference<beans::XPropertySet> xAnchor(xTextTable->getAnchor(), uno::UNO_QUERY);
    1222           2 :     uno::Any aFrame = xAnchor->getPropertyValue("TextFrame");
    1223           2 :     uno::Reference<beans::XPropertySet> xFrame;
    1224           1 :     aFrame >>= xFrame;
    1225             :     sal_Int16 nValue;
    1226           1 :     xFrame->getPropertyValue("VertOrient") >>= nValue;
    1227           1 :     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong vertical orientation", nValue, text::VertOrientation::BOTTOM);
    1228           1 :     xFrame->getPropertyValue("VertOrientRelation") >>= nValue;
    1229           2 :     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong vertical orientation relation", nValue, text::RelOrientation::PAGE_PRINT_AREA);
    1230           1 : }
    1231             : 
    1232          12 : DECLARE_OOXMLIMPORT_TEST(testTbLrHeight, "tblr-height.docx")
    1233             : {
    1234           1 :     uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent, uno::UNO_QUERY);
    1235           2 :     uno::Reference<container::XIndexAccess> xTables(xTextTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1236           2 :     uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1237           2 :     uno::Reference<table::XTableRows> xTableRows(xTable->getRows(), uno::UNO_QUERY);
    1238             :     // btLr text direction was imported as MIN, it should be FIX to avoid incorrectly large height in case of too much content.
    1239           2 :     CPPUNIT_ASSERT_EQUAL(text::SizeType::FIX, getProperty<sal_Int16>(xTableRows->getByIndex(0), "SizeType"));
    1240           1 : }
    1241             : 
    1242          12 : DECLARE_OOXMLIMPORT_TEST(testBnc865381, "bnc865381.docx")
    1243             : {
    1244           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1245           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1246           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1247           2 :     uno::Reference<table::XTableRows> xTableRows(xTextTable->getRows(), uno::UNO_QUERY);
    1248             :     // Second row has a vertically merged cell, make sure size type is not FIX in that case (otherwise B2 is not readable).
    1249           1 :     CPPUNIT_ASSERT(text::SizeType::FIX != getProperty<sal_Int16>(xTableRows->getByIndex(1), "SizeType"));
    1250             :     // Explicit size of 41 mm100 was set, so the vertical text in A2 was not readable.
    1251           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), getProperty<sal_Int32>(xTableRows->getByIndex(1), "Height"));
    1252           1 : }
    1253             : 
    1254          12 : DECLARE_OOXMLIMPORT_TEST(testFdo53985, "fdo53985.docx")
    1255             : {
    1256             :     // Unhandled excetion prevented import of the rest of the document.
    1257             : 
    1258           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1259           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    1260           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(5), xTables->getCount()); // Only 4 tables were imported.
    1261           1 : }
    1262             : 
    1263          12 : DECLARE_OOXMLIMPORT_TEST(testFdo59638, "fdo59638.docx")
    1264             : {
    1265             :     // The problem was that w:lvlOverride inside w:num was ignores by dmapper.
    1266             : 
    1267           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getStyles("NumberingStyles")->getByName("WWNum1"), uno::UNO_QUERY);
    1268           1 :     uno::Reference<container::XIndexAccess> xLevels(xPropertySet->getPropertyValue("NumberingRules"), uno::UNO_QUERY);
    1269           1 :     uno::Sequence<beans::PropertyValue> aProps;
    1270           1 :     xLevels->getByIndex(0) >>= aProps; // 1st level
    1271             : 
    1272          14 :     for (int i = 0; i < aProps.getLength(); ++i)
    1273             :     {
    1274          14 :         const beans::PropertyValue& rProp = aProps[i];
    1275             : 
    1276          14 :         if (rProp.Name == "BulletChar")
    1277             :         {
    1278             :             // Was '*', should be 'o'.
    1279           1 :             CPPUNIT_ASSERT_EQUAL(OUString("\xEF\x82\xB7", 3, RTL_TEXTENCODING_UTF8), rProp.Value.get<OUString>());
    1280           2 :             return;
    1281             :         }
    1282             :     }
    1283           0 :     CPPUNIT_FAIL("no BulletChar property");
    1284             : }
    1285             : 
    1286          12 : DECLARE_OOXMLIMPORT_TEST(testFdo61343, "fdo61343.docx")
    1287             : {
    1288             :     // The problem was that there were a groupshape in the doc, followed by an
    1289             :     // OLE object, and this lead to a crash.
    1290           1 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
    1291           2 :     uno::Reference<container::XIndexAccess> xDraws(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
    1292           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xDraws->getCount());
    1293           1 : }
    1294             : 
    1295          12 : DECLARE_OOXMLIMPORT_TEST(testToolsLineNumbering, "tools-line-numbering.docx")
    1296             : {
    1297             :     /*
    1298             :      * Test the line numbering feature import (Tools->Line Numbering ...)
    1299             :      *
    1300             :      * xray ThisComponent.getLineNumberingProperties().IsOn == True
    1301             :      * xray ThisComponent.getLineNumberingProperties().CountEmptyLines == True
    1302             :      * xray ThisComponent.getLineNumberingProperties().NumberPosition == 0
    1303             :      * xray ThisComponent.getLineNumberingProperties().NumberingType == 4
    1304             :      * xray ThisComponent.getLineNumberingProperties().SeparatorInterval == 3
    1305             :      */
    1306             : 
    1307           1 :     bool bValue = false;
    1308           1 :     sal_Int32 nValue = -1;
    1309             : 
    1310           1 :     uno::Reference< text::XTextDocument > xtextDocument(mxComponent, uno::UNO_QUERY);
    1311           2 :     uno::Reference< text::XLineNumberingProperties > xLineProperties( xtextDocument, uno::UNO_QUERY_THROW );
    1312           2 :     uno::Reference< beans::XPropertySet > xPropertySet = xLineProperties->getLineNumberingProperties();
    1313             : 
    1314           1 :     xPropertySet->getPropertyValue("IsOn") >>= bValue;
    1315           1 :     CPPUNIT_ASSERT_EQUAL(true, bValue);
    1316             : 
    1317           1 :     xPropertySet->getPropertyValue("CountEmptyLines") >>= bValue;
    1318           1 :     CPPUNIT_ASSERT_EQUAL(true, bValue);
    1319             : 
    1320           1 :     xPropertySet->getPropertyValue("NumberPosition") >>= nValue;
    1321           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), nValue);
    1322             : 
    1323           1 :     xPropertySet->getPropertyValue("NumberingType") >>= nValue;
    1324           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(4), nValue);
    1325             : 
    1326           1 :     xPropertySet->getPropertyValue("SeparatorInterval") >>= nValue;
    1327           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3), nValue);
    1328           1 : }
    1329             : 
    1330          12 : DECLARE_OOXMLIMPORT_TEST(testfdo78904, "fdo78904.docx")
    1331             : {
    1332           1 :     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(mxComponent, uno::UNO_QUERY);
    1333           2 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextFramesSupplier->getTextFrames(), uno::UNO_QUERY);
    1334           1 :     if (xIndexAccess->getCount())
    1335             :     {
    1336           1 :         uno::Reference<beans::XPropertySet> xFrame(xIndexAccess->getByIndex(0), uno::UNO_QUERY);
    1337           1 :         CPPUNIT_ASSERT_EQUAL(sal_Int32(oox::drawingml::convertEmuToHmm(0)), getProperty<sal_Int32>(xFrame, "HoriOrientPosition"));
    1338           1 :     }
    1339           1 : }
    1340             : 
    1341          12 : DECLARE_OOXMLIMPORT_TEST(testFdo60922, "fdo60922.docx")
    1342             : {
    1343             :     // This was 0, not 100, due to wrong import of w:position w:val="0"
    1344           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(100), getProperty<sal_Int32>(getRun(getParagraph(1), 1), "CharEscapementHeight"));
    1345           1 : }
    1346             : 
    1347          12 : DECLARE_OOXMLIMPORT_TEST(testFdo59273, "fdo59273.docx")
    1348             : {
    1349           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1350           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    1351           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1352             :     // Was 115596 (i.e. 10 times wider than necessary), as w:tblW was missing and the importer didn't set it.
    1353           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(12961), getProperty<sal_Int32>(xTextTable, "Width"));
    1354             : 
    1355           2 :     uno::Reference<table::XTableRows> xTableRows(xTextTable->getRows(), uno::UNO_QUERY);
    1356             :     // Was 9997, so the 4th column had ~zero width
    1357           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(7498), getProperty< uno::Sequence<text::TableColumnSeparator> >(xTableRows->getByIndex(0), "TableColumnSeparators")[2].Position);
    1358           1 : }
    1359             : 
    1360          12 : DECLARE_OOXMLIMPORT_TEST(testTableWidth, "table_width.docx")
    1361             : {
    1362           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1363           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1364             :     // Relative width wasn't recognized during import.
    1365           1 :     CPPUNIT_ASSERT_EQUAL(true, bool(getProperty<sal_Bool>(xTables->getByIndex(0), "IsWidthRelative")));
    1366             : 
    1367           2 :     uno::Reference<text::XTextFramesSupplier> xFramesSupplier(mxComponent, uno::UNO_QUERY);
    1368           2 :     uno::Reference<container::XIndexAccess> xFrames(xFramesSupplier->getTextFrames(), uno::UNO_QUERY);
    1369           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(100), getProperty<sal_Int32>(xFrames->getByIndex(0), "FrameWidthPercent"));
    1370           1 : }
    1371             : 
    1372          12 : DECLARE_OOXMLIMPORT_TEST(testConditionalstylesTablelook, "conditionalstyles-tbllook.docx")
    1373             : {
    1374           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1375           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1376           2 :     uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1377             :     // Background was -1.
    1378           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0x7F7F7F), getProperty<sal_Int32>(xTable->getCellByName("A1"), "BackColor"));
    1379           1 : }
    1380             : 
    1381          12 : DECLARE_OOXMLIMPORT_TEST(testFdo63685, "fdo63685.docx")
    1382             : {
    1383             :     // Was 85697, i.e. original 114120 was converted to mm100 from twips, not from EMUs.
    1384           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(318), getProperty<sal_Int32>(getShape(1), "TopMargin"));
    1385           1 : }
    1386             : 
    1387          12 : DECLARE_OOXMLIMPORT_TEST(testN592908_Frame, "n592908-frame.docx")
    1388             : {
    1389           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
    1390             :     text::WrapTextMode eValue;
    1391           1 :     xPropertySet->getPropertyValue("Surround") >>= eValue;
    1392           1 :     CPPUNIT_ASSERT_EQUAL(eValue, text::WrapTextMode_PARALLEL);
    1393           1 : }
    1394             : 
    1395          12 : DECLARE_OOXMLIMPORT_TEST(testN592908_Picture, "n592908-picture.docx")
    1396             : {
    1397           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
    1398             :     text::WrapTextMode eValue;
    1399           1 :     xPropertySet->getPropertyValue("Surround") >>= eValue;
    1400           1 :     CPPUNIT_ASSERT_EQUAL(eValue, text::WrapTextMode_PARALLEL);
    1401           1 : }
    1402             : 
    1403          12 : DECLARE_OOXMLIMPORT_TEST(testN779630, "n779630.docx")
    1404             : {
    1405             :     // First shape: date picker
    1406           1 :     uno::Reference<drawing::XControlShape> xControlShape(getShape(1), uno::UNO_QUERY);
    1407           2 :     uno::Reference<beans::XPropertySet> xPropertySet(xControlShape->getControl(), uno::UNO_QUERY);
    1408           2 :     uno::Reference<lang::XServiceInfo> xServiceInfo(xPropertySet, uno::UNO_QUERY);
    1409           1 :     CPPUNIT_ASSERT_EQUAL(true, bool(xServiceInfo->supportsService("com.sun.star.form.component.DateField")));
    1410           1 :     CPPUNIT_ASSERT_EQUAL(OUString("date default text"), getProperty<OUString>(xPropertySet, "HelpText"));
    1411           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(8), getProperty<sal_Int16>(xPropertySet, "DateFormat"));
    1412           1 :     CPPUNIT_ASSERT_EQUAL(true, bool(getProperty<sal_Bool>(xPropertySet, "Dropdown")));
    1413             : 
    1414             :     // Second shape: combo box
    1415           1 :     xControlShape.set(getShape(2), uno::UNO_QUERY);
    1416           1 :     xPropertySet.set(xControlShape->getControl(), uno::UNO_QUERY);
    1417           1 :     xServiceInfo.set(xPropertySet, uno::UNO_QUERY);
    1418           1 :     CPPUNIT_ASSERT_EQUAL(true, bool(xServiceInfo->supportsService("com.sun.star.form.component.ComboBox")));
    1419           1 :     CPPUNIT_ASSERT_EQUAL(OUString("dropdown default text"), getProperty<OUString>(xPropertySet, "DefaultText"));
    1420           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), getProperty< uno::Sequence<OUString> >(xPropertySet, "StringItemList").getLength());
    1421           2 :     CPPUNIT_ASSERT_EQUAL(true, bool(getProperty<sal_Bool>(xPropertySet, "Dropdown")));
    1422           1 : }
    1423             : 
    1424          12 : DECLARE_OOXMLIMPORT_TEST(testIndentation, "indentation.docx")
    1425             : {
    1426           1 :     uno::Reference<uno::XInterface> xParaLTRTitle(getParagraph( 1, "Title aligned"));
    1427           2 :     uno::Reference<uno::XInterface> xParaLTRNormal(getParagraph( 2, ""));
    1428             : 
    1429             :     // this will test the text direction for paragraphs
    1430           1 :     CPPUNIT_ASSERT_EQUAL(text::WritingMode2::LR_TB, getProperty<sal_Int16>( xParaLTRTitle, "WritingMode" ));
    1431           2 :     CPPUNIT_ASSERT_EQUAL(text::WritingMode2::LR_TB, getProperty<sal_Int16>( xParaLTRNormal, "WritingMode" ));
    1432           1 : }
    1433             : 
    1434          12 : DECLARE_OOXMLIMPORT_TEST(testPageBorderShadow, "page-border-shadow.docx")
    1435             : {
    1436             :     // The problem was that in w:pgBorders, child elements had a w:shadow attribute, but that was ignored.
    1437           1 :     table::ShadowFormat aShadow = getProperty<table::ShadowFormat>(getStyles("PageStyles")->getByName(DEFAULT_STYLE), "ShadowFormat");
    1438           1 :     CPPUNIT_ASSERT_EQUAL(COL_BLACK, sal_uInt32(aShadow.Color));
    1439           1 :     CPPUNIT_ASSERT_EQUAL(table::ShadowLocation_BOTTOM_RIGHT, aShadow.Location);
    1440             :     // w:sz="48" is in eights of a point, 1 pt is 20 twips.
    1441           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(convertTwipToMm100(48/8*20)), aShadow.ShadowWidth);
    1442           1 : }
    1443             : 
    1444          12 : DECLARE_OOXMLIMPORT_TEST(testN816593, "n816593.docx")
    1445             : {
    1446             :     // Two consecutive <w:tbl> without any paragraph in between, but with different tblpPr. In this
    1447             :     // case we need to have 2 different tables instead of 1
    1448           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1449           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    1450           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTables->getCount());
    1451           1 : }
    1452             : 
    1453          12 : DECLARE_OOXMLIMPORT_TEST(testN820509, "n820509.docx")
    1454             : {
    1455             :     // Design mode was enabled.
    1456           1 :     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
    1457           2 :     uno::Reference<view::XFormLayerAccess> xFormLayerAccess(xModel->getCurrentController(), uno::UNO_QUERY);
    1458           1 :     CPPUNIT_ASSERT_EQUAL(false, bool(xFormLayerAccess->isFormDesignMode()));
    1459             : 
    1460             :     // M.d.yyyy date format was unhandled.
    1461           2 :     uno::Reference<drawing::XControlShape> xControlShape(getShape(1), uno::UNO_QUERY);
    1462           2 :     uno::Reference<beans::XPropertySet> xPropertySet(xControlShape->getControl(), uno::UNO_QUERY);
    1463           2 :     uno::Reference<lang::XServiceInfo> xServiceInfo(xPropertySet, uno::UNO_QUERY);
    1464           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(8), getProperty<sal_Int16>(xPropertySet, "DateFormat"));
    1465           1 : }
    1466             : 
    1467          12 : DECLARE_OOXMLIMPORT_TEST(testN820788, "n820788.docx")
    1468             : {
    1469             :     // The problem was that AutoSize was not enabled for the text frame.
    1470           1 :     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(mxComponent, uno::UNO_QUERY);
    1471           2 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextFramesSupplier->getTextFrames(), uno::UNO_QUERY);
    1472           2 :     uno::Reference<beans::XPropertySet> xFrame(xIndexAccess->getByIndex(0), uno::UNO_QUERY);
    1473             :     // This was text::SizeType::FIX.
    1474           2 :     CPPUNIT_ASSERT_EQUAL(text::SizeType::MIN, getProperty<sal_Int16>(xFrame, "SizeType"));
    1475           1 : }
    1476             : 
    1477          12 : DECLARE_OOXMLIMPORT_TEST(testN820504, "n820504.docx")
    1478             : {
    1479           1 :     uno::Reference<style::XStyleFamiliesSupplier> xFamiliesSupplier(mxComponent, uno::UNO_QUERY);
    1480           2 :     uno::Reference<container::XNameAccess> xFamiliesAccess(xFamiliesSupplier->getStyleFamilies(), uno::UNO_QUERY);
    1481           2 :     uno::Reference<container::XNameAccess> xStylesAccess(xFamiliesAccess->getByName("ParagraphStyles"), uno::UNO_QUERY);
    1482           2 :     uno::Reference<beans::XPropertySet> xStyle(xStylesAccess->getByName("Default Style"), uno::UNO_QUERY);
    1483             :     // The problem was that the CharColor was set to AUTO (-1) even if we have some default char color set
    1484           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(4040635), getProperty<sal_Int32>(xStyle, "CharColor"));
    1485             : 
    1486             :     // Also, the groupshape was anchored at-page instead of at-character
    1487             :     // (that's incorrect as Word only supports at-character and as-character).
    1488           2 :     CPPUNIT_ASSERT_EQUAL(text::TextContentAnchorType_AT_CHARACTER, getProperty<text::TextContentAnchorType>(getShape(1), "AnchorType"));
    1489           1 : }
    1490             : 
    1491          12 : DECLARE_OOXMLIMPORT_TEST(testN830205, "n830205.docx")
    1492             : {
    1493             :     // Previously import just crashed (due to infinite recursion).
    1494           1 :     getParagraph(1, "XXX");
    1495           1 : }
    1496             : 
    1497          12 : DECLARE_OOXMLIMPORT_TEST(testFdo43641, "fdo43641.docx")
    1498             : {
    1499           1 :     uno::Reference<container::XIndexAccess> xGroupShape(getShape(1), uno::UNO_QUERY);
    1500           2 :     uno::Reference<drawing::XShape> xLine(xGroupShape->getByIndex(1), uno::UNO_QUERY);
    1501             :     // This was 2200, not 2579 in mm100, i.e. the size of the line shape was incorrect.
    1502           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(oox::drawingml::convertEmuToHmm(928440)), xLine->getSize().Width);
    1503           1 : }
    1504             : 
    1505          12 : DECLARE_OOXMLIMPORT_TEST(testTableAutoColumnFixedSize, "table-auto-column-fixed-size.docx")
    1506             : {
    1507           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1508           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1509           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1510             : 
    1511             :     // Width was not recognized during import when table size was 'auto'
    1512           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(convertTwipToMm100(3996)), getProperty<sal_Int32>(xTextTable, "Width"));
    1513           1 : }
    1514             : 
    1515          12 : DECLARE_OOXMLIMPORT_TEST(testTableAutoColumnFixedSize2, "table-auto-column-fixed-size2.docx")
    1516             : {
    1517           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1518           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1519           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1520             :     // This was 17907, i.e. the sum of the width of the 3 cells (10152 twips each), which is too wide.
    1521           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(16891), getProperty<sal_Int32>(xTextTable, "Width"));
    1522           1 : }
    1523             : 
    1524          12 : DECLARE_OOXMLIMPORT_TEST(testFdo46361, "fdo46361.docx")
    1525             : {
    1526           1 :     uno::Reference<container::XIndexAccess> xGroupShape(getShape(1), uno::UNO_QUERY);
    1527           2 :     uno::Reference<drawing::XShape> xShape(xGroupShape->getByIndex(0), uno::UNO_QUERY);
    1528             :     // This was CENTER.
    1529           1 :     CPPUNIT_ASSERT_EQUAL(drawing::TextVerticalAdjust_TOP, getProperty<drawing::TextVerticalAdjust>(xShape, "TextVerticalAdjust"));
    1530           2 :     uno::Reference<text::XText> xText = uno::Reference<text::XTextRange>(xShape, uno::UNO_QUERY)->getText();
    1531           2 :     uno::Reference<text::XTextRange> xParagraph = getParagraphOfText(1, xText);
    1532             :     // This was LEFT.
    1533           1 :     CPPUNIT_ASSERT_EQUAL(style::ParagraphAdjust_CENTER, static_cast<style::ParagraphAdjust>(getProperty<sal_Int16>(xParagraph, "ParaAdjust")));
    1534             :     // This was black, not green.
    1535           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0x008000), getProperty<sal_Int32>(getRun(xParagraph, 1), "CharColor"));
    1536             :     // \n char was missing due to unhandled w:br.
    1537           1 :     CPPUNIT_ASSERT_EQUAL(OUString("text\ntext"), uno::Reference<text::XTextRange>(xGroupShape->getByIndex(1), uno::UNO_QUERY)->getString());
    1538             :     // \n chars were missing, due to unhandled multiple w:p tags.
    1539           2 :     CPPUNIT_ASSERT_EQUAL(OUString("text\ntext\n"), uno::Reference<text::XTextRange>(xGroupShape->getByIndex(2), uno::UNO_QUERY)->getString());
    1540           1 : }
    1541             : 
    1542          12 : DECLARE_OOXMLIMPORT_TEST(testFdo65632, "fdo65632.docx")
    1543             : {
    1544             :     // The problem was that the footnote text had fake redline: only the body
    1545             :     // text has redline in fact.
    1546           1 :     uno::Reference<text::XFootnotesSupplier> xFootnotesSupplier(mxComponent, uno::UNO_QUERY);
    1547           2 :     uno::Reference<container::XIndexAccess> xFootnotes(xFootnotesSupplier->getFootnotes(), uno::UNO_QUERY);
    1548           2 :     uno::Reference<text::XText> xText(xFootnotes->getByIndex(0), uno::UNO_QUERY);
    1549             :     //uno::Reference<text::XTextRange> xParagraph = getParagraphOfText(1, xText);
    1550           2 :     CPPUNIT_ASSERT_EQUAL(OUString("Text"), getProperty<OUString>(getRun(getParagraphOfText(1, xText), 1), "TextPortionType"));
    1551           1 : }
    1552             : 
    1553          12 : DECLARE_OOXMLIMPORT_TEST(testFdo66474, "fdo66474.docx")
    1554             : {
    1555             :     // The table width was too small, so the text in the second cell was unreadable: this was 1397.
    1556           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1557           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    1558           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(10492), getProperty<sal_Int32>(xTables->getByIndex(0), "Width"));
    1559           1 : }
    1560             : 
    1561          12 : DECLARE_OOXMLIMPORT_TEST(testGroupshapeRotation, "groupshape-rotation.docx")
    1562             : {
    1563             :     // Rotation on groupshapes wasn't handled at all by the VML importer.
    1564           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(315 * 100), getProperty<sal_Int32>(getShape(1), "RotateAngle"));
    1565           1 : }
    1566             : 
    1567          12 : DECLARE_OOXMLIMPORT_TEST(testBnc780044Spacing, "bnc780044_spacing.docx")
    1568             : {
    1569             :     // The document has global w:spacing in styles.xml , and local w:spacing in w:pPr, which however
    1570             :     // only applied to text runs, not to as-character pictures. So the picture made the line higher.
    1571           1 :     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
    1572           2 :     uno::Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(), uno::UNO_QUERY);
    1573           2 :     uno::Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), uno::UNO_QUERY);
    1574           1 :     xCursor->jumpToLastPage();
    1575           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(1), xCursor->getPage());
    1576           1 : }
    1577             : 
    1578          12 : DECLARE_OOXMLIMPORT_TEST(testTableAutoNested, "table-auto-nested.docx")
    1579             : {
    1580             :     // This was 176, when compat option is not enabled, the auto paragraph bottom margin value was incorrect.
    1581           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(494), getProperty<sal_Int32>(getParagraph(1), "ParaBottomMargin"));
    1582             : 
    1583           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1584           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1585             :     // This was 115596, i.e. the width of the outer table was too large.
    1586           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(23051), getProperty<sal_Int32>(xTables->getByIndex(1), "Width"));
    1587           1 : }
    1588             : 
    1589          12 : DECLARE_OOXMLIMPORT_TEST(testTableStyleParprop, "table-style-parprop.docx")
    1590             : {
    1591             :     // The problem was that w:spacing's w:after=0 (a paragraph property) wasn't imported from table style.
    1592           1 :     uno::Reference<text::XTextTable> xTable(getParagraphOrTable(1), uno::UNO_QUERY);
    1593           2 :     uno::Reference<text::XTextRange> xCell(xTable->getCellByName("A1"), uno::UNO_QUERY);
    1594             :     // This was 353, the document default, i.e. paragraph property from table style had no effect.
    1595           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), getProperty<sal_Int32>(getParagraphOfText(1, xCell->getText()), "ParaBottomMargin"));
    1596           1 : }
    1597             : 
    1598          12 : DECLARE_OOXMLIMPORT_TEST(testTablePagebreak, "table-pagebreak.docx")
    1599             : {
    1600             :     // Page break inside table: should be ignored (was style::BreakType_PAGE_BEFORE before).
    1601           1 :     CPPUNIT_ASSERT_EQUAL(style::BreakType_NONE, getProperty<style::BreakType>(getParagraphOrTable(2), "BreakType"));
    1602             : 
    1603             :     // This one is outside the table: should not be ignored.
    1604           1 :     CPPUNIT_ASSERT_EQUAL(style::BreakType_PAGE_BEFORE, getProperty<style::BreakType>(getParagraph(3), "BreakType"));
    1605           1 : }
    1606             : 
    1607          12 : DECLARE_OOXMLIMPORT_TEST(testFdo68607, "fdo68607.docx")
    1608             : {
    1609             :     // Bugdoc was 8 pages in Word, 1 in Writer due to pointlessly wrapping the
    1610             :     // table in a frame. Exact layout may depend on fonts available, etc. --
    1611             :     // but at least make sure that our table spans over multiple pages now.
    1612           1 :     CPPUNIT_ASSERT(getPages() > 1);
    1613           1 : }
    1614             : 
    1615          12 : DECLARE_OOXMLIMPORT_TEST(testVmlTextVerticalAdjust, "vml-text-vertical-adjust.docx")
    1616             : {
    1617           1 :     uno::Reference<drawing::XShapes> xOuterGroupShape(getShape(1), uno::UNO_QUERY);
    1618           2 :     uno::Reference<drawing::XShapes> xInnerGroupShape(xOuterGroupShape->getByIndex(0), uno::UNO_QUERY);
    1619           2 :     uno::Reference<drawing::XShape> xShape(xInnerGroupShape->getByIndex(0), uno::UNO_QUERY);
    1620             :     // Was CENTER.
    1621           2 :     CPPUNIT_ASSERT_EQUAL(drawing::TextVerticalAdjust_TOP, getProperty<drawing::TextVerticalAdjust>(xShape, "TextVerticalAdjust"));
    1622           1 : }
    1623             : 
    1624          12 : DECLARE_OOXMLIMPORT_TEST(testGroupshapeSdt, "groupshape-sdt.docx")
    1625             : {
    1626             :     // All problems here are due to the groupshape: we have a drawinglayer rectangle, not a writer textframe.
    1627           1 :     uno::Reference<drawing::XShapes> xOuterGroupShape(getShape(1), uno::UNO_QUERY);
    1628           2 :     uno::Reference<drawing::XShapes> xInnerGroupShape(xOuterGroupShape->getByIndex(0), uno::UNO_QUERY);
    1629           2 :     uno::Reference<text::XTextRange> xShape(xInnerGroupShape->getByIndex(0), uno::UNO_QUERY);
    1630             :     // Border distances were not implemented, this was 0.
    1631           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1905), getProperty<sal_Int32>(xShape, "TextUpperDistance"));
    1632             :     // Sdt field result wasn't imported, this was "".
    1633           1 :     CPPUNIT_ASSERT_EQUAL(OUString("placeholder text"), xShape->getString());
    1634             :     // w:spacing was ignored in oox, this was 0.
    1635           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(20), getProperty<sal_Int32>(getRun(getParagraphOfText(1, xShape->getText()), 1), "CharKerning"));
    1636           1 : }
    1637             : 
    1638          12 : DECLARE_OOXMLIMPORT_TEST(testDefaultSectBreakCols, "default-sect-break-cols.docx")
    1639             : {
    1640             :     // First problem: the first two paragraphs did not have their own text section, so the whole document had two columns.
    1641           1 :     uno::Reference<beans::XPropertySet> xTextSection = getProperty< uno::Reference<beans::XPropertySet> >(getParagraph(1, "First."), "TextSection");
    1642           1 :     CPPUNIT_ASSERT(xTextSection.is());
    1643           2 :     uno::Reference<text::XTextColumns> xTextColumns = getProperty< uno::Reference<text::XTextColumns> >(xTextSection, "TextColumns");
    1644           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(2), xTextColumns->getColumnCount());
    1645             : 
    1646             :     // Second problem: the page style had two columns, while it shouldn't have any.
    1647           2 :     uno::Reference<beans::XPropertySet> xPageStyle(getStyles("PageStyles")->getByName(DEFAULT_STYLE), uno::UNO_QUERY);
    1648           1 :     xTextColumns = getProperty< uno::Reference<text::XTextColumns> >(xPageStyle, "TextColumns");
    1649           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(0), xTextColumns->getColumnCount());
    1650             :     // Check for the Column Separator value.It should be FALSE as the document does not contain separator line.
    1651           1 :     bool bValue = getProperty< bool >(xTextColumns, "SeparatorLineIsOn");
    1652           2 :     CPPUNIT_ASSERT(!bValue) ;
    1653           1 : }
    1654             : 
    1655          12 : DECLARE_OOXMLIMPORT_TEST(testFdo69636, "fdo69636.docx")
    1656             : {
    1657             :     // The problem was that the mso-layout-flow-alt:bottom-to-top VML shape property wasn't handled for sw text frames.
    1658           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
    1659           2 :     comphelper::SequenceAsHashMap aCustomShapeGeometry(xPropertySet->getPropertyValue("CustomShapeGeometry"));
    1660           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(-270), aCustomShapeGeometry["TextPreRotateAngle"].get<sal_Int32>());
    1661           1 : }
    1662             : 
    1663          12 : DECLARE_OOXMLIMPORT_TEST(testChartProp, "chart-prop.docx")
    1664             : {
    1665             :     // The problem was that chart was not getting parsed in writer module.
    1666           1 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
    1667           2 :     uno::Reference<container::XIndexAccess> xDrawPage(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
    1668           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xDrawPage->getCount());
    1669             : 
    1670           2 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
    1671           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(15240), getProperty<sal_Int32>(xPropertySet, "Width"));
    1672           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(8890), getProperty<sal_Int32>(xPropertySet, "Height"));
    1673           1 : }
    1674             : 
    1675           2 : void lcl_countTextFrames(com::sun::star::uno::Reference< lang::XComponent >& xComponent,
    1676             :    sal_Int32 nExpected )
    1677             : {
    1678           2 :     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(xComponent, uno::UNO_QUERY);
    1679           4 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextFramesSupplier->getTextFrames(), uno::UNO_QUERY);
    1680           4 :     CPPUNIT_ASSERT_EQUAL( nExpected, xIndexAccess->getCount());
    1681           2 : }
    1682             : 
    1683          12 : DECLARE_OOXMLIMPORT_TEST(testBnc779620, "bnc779620.docx")
    1684             : {
    1685             :     // The problem was that the floating table was imported as a non-floating one.
    1686           1 :     lcl_countTextFrames( mxComponent, 1 );
    1687           1 : }
    1688             : 
    1689          12 : DECLARE_OOXMLIMPORT_TEST(testfdo76583, "fdo76583.docx")
    1690             : {
    1691             :     // The problem was that the floating table was imported as a non-floating one.
    1692             :     // floating tables are imported as text frames, therefore the document should
    1693             :     // exactly 1 text frame.
    1694           1 :     lcl_countTextFrames( mxComponent, 1 );
    1695           1 : }
    1696             : 
    1697          12 : DECLARE_OOXMLIMPORT_TEST(testFdo43093, "fdo43093.docx")
    1698             : {
    1699             :     // The problem was that the direction and alignment are not correct for RTL paragraphs.
    1700           1 :     uno::Reference<uno::XInterface> xParaRtlRight(getParagraph( 1, "Right and RTL in M$"));
    1701           1 :     sal_Int32 nRtlRight = getProperty< sal_Int32 >( xParaRtlRight, "ParaAdjust" );
    1702           1 :     sal_Int16 nRRDir  = getProperty< sal_Int32 >( xParaRtlRight, "WritingMode" );
    1703             : 
    1704           2 :     uno::Reference<uno::XInterface> xParaRtlLeft(getParagraph( 2, "Left and RTL in M$"));
    1705           1 :     sal_Int32 nRtlLeft = getProperty< sal_Int32 >( xParaRtlLeft, "ParaAdjust" );
    1706           1 :     sal_Int16 nRLDir  = getProperty< sal_Int32 >( xParaRtlLeft, "WritingMode" );
    1707             : 
    1708           2 :     uno::Reference<uno::XInterface> xParaLtrRight(getParagraph( 3, "Right and LTR in M$"));
    1709           1 :     sal_Int32 nLtrRight = getProperty< sal_Int32 >( xParaLtrRight, "ParaAdjust" );
    1710           1 :     sal_Int16 nLRDir  = getProperty< sal_Int32 >( xParaLtrRight, "WritingMode" );
    1711             : 
    1712           2 :     uno::Reference<uno::XInterface> xParaLtrLeft(getParagraph( 4, "Left and LTR in M$"));
    1713           1 :     sal_Int32 nLtrLeft = getProperty< sal_Int32 >( xParaLtrLeft, "ParaAdjust" );
    1714           1 :     sal_Int16 nLLDir  = getProperty< sal_Int32 >( xParaLtrLeft, "WritingMode" );
    1715             : 
    1716             :     // this will test the both the text direction and alignment for each paragraph
    1717           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32 (style::ParagraphAdjust_RIGHT), nRtlRight);
    1718           1 :     CPPUNIT_ASSERT_EQUAL(text::WritingMode2::RL_TB, nRRDir);
    1719             : 
    1720           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32 (style::ParagraphAdjust_LEFT), nRtlLeft);
    1721           1 :     CPPUNIT_ASSERT_EQUAL(text::WritingMode2::RL_TB, nRLDir);
    1722             : 
    1723           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32 (style::ParagraphAdjust_RIGHT), nLtrRight);
    1724           1 :     CPPUNIT_ASSERT_EQUAL(text::WritingMode2::LR_TB, nLRDir);
    1725             : 
    1726           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32 (style::ParagraphAdjust_LEFT), nLtrLeft);
    1727           2 :     CPPUNIT_ASSERT_EQUAL(text::WritingMode2::LR_TB, nLLDir);
    1728           1 : }
    1729             : 
    1730          12 : DECLARE_OOXMLIMPORT_TEST(testSmartart, "smartart.docx")
    1731             : {
    1732           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
    1733           2 :     uno::Reference<beans::XPropertySet> xTextDocumentPropertySet(xTextDocument, uno::UNO_QUERY);
    1734           2 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
    1735           2 :     uno::Reference<container::XIndexAccess> xDraws(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
    1736           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xDraws->getCount()); // One groupshape in the doc
    1737             : 
    1738           2 :     uno::Reference<container::XIndexAccess> xGroup(getShape(1), uno::UNO_QUERY);
    1739           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xGroup->getCount()); // 3 rectangles and an arrow in the group
    1740             : 
    1741           2 :     uno::Reference<beans::XPropertySet> xPropertySet(xGroup->getByIndex(1), uno::UNO_QUERY);
    1742           1 :     sal_Int32 nValue(0);
    1743           1 :     xPropertySet->getPropertyValue("FillColor") >>= nValue;
    1744           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0x4f81bd), nValue); // If fill color is right, theme import is OK
    1745             : 
    1746           2 :     uno::Reference<text::XTextRange> xTextRange(xGroup->getByIndex(1), uno::UNO_QUERY);
    1747           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Sample"), xTextRange->getString()); // Shape has text
    1748             : 
    1749           2 :     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xTextRange->getText(), uno::UNO_QUERY);
    1750           2 :     uno::Reference<container::XEnumeration> xParaEnum = xParaEnumAccess->createEnumeration();
    1751           1 :     xPropertySet.set(xParaEnum->nextElement(), uno::UNO_QUERY);
    1752           1 :     xPropertySet->getPropertyValue("ParaAdjust") >>= nValue;
    1753           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(style::ParagraphAdjust_CENTER), nValue); // Paragraph properties are imported
    1754           1 : }
    1755             : 
    1756          12 : DECLARE_OOXMLIMPORT_TEST(testMultiColumnSeparator, "multi-column-separator-with-line.docx")
    1757             : {
    1758           1 :     uno::Reference<beans::XPropertySet> xTextSection = getProperty< uno::Reference<beans::XPropertySet> >(getParagraph(1, "First data."), "TextSection");
    1759           1 :     CPPUNIT_ASSERT(xTextSection.is());
    1760           2 :     uno::Reference<text::XTextColumns> xTextColumns = getProperty< uno::Reference<text::XTextColumns> >(xTextSection, "TextColumns");
    1761           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(2), xTextColumns->getColumnCount());
    1762             :     // Check for the Column Separator value.It should be TRUE as the document contains separator line.
    1763           1 :     bool  bValue = getProperty< bool >(xTextColumns, "SeparatorLineIsOn");
    1764           2 :     CPPUNIT_ASSERT(bValue);
    1765           1 : }
    1766             : 
    1767          12 : DECLARE_OOXMLIMPORT_TEST(testFdo69548, "fdo69548.docx")
    1768             : {
    1769             :     // The problem was that the last space in target URL was removed
    1770           1 :     CPPUNIT_ASSERT_EQUAL(OUString("#this is a bookmark"), getProperty<OUString>(getRun(getParagraph(1), 1), "HyperLinkURL"));
    1771           1 : }
    1772             : 
    1773          12 : DECLARE_OOXMLIMPORT_TEST(testWpsOnly, "wps-only.docx")
    1774             : {
    1775             :     // Document has wp:anchor, not wp:inline, so handle it accordingly.
    1776           1 :     uno::Reference<drawing::XShape> xShape = getShape(1);
    1777           1 :     text::TextContentAnchorType eValue = getProperty<text::TextContentAnchorType>(xShape, "AnchorType");
    1778           1 :     CPPUNIT_ASSERT_EQUAL(text::TextContentAnchorType_AT_PARAGRAPH, eValue);
    1779             : 
    1780             :     // Check position, it was 0. This is a shape, so use getPosition(), not a property.
    1781           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(oox::drawingml::convertEmuToHmm(671830)), xShape->getPosition().X);
    1782             : 
    1783             :     // Left margin was 0, instead of 114300 EMU's.
    1784           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(318), getProperty<sal_Int32>(xShape, "LeftMargin"));
    1785             :     // Wrap type was PARALLEL.
    1786           1 :     CPPUNIT_ASSERT_EQUAL(text::WrapTextMode_THROUGHT, getProperty<text::WrapTextMode>(xShape, "Surround"));
    1787             : 
    1788             :     // This should be in front of text.
    1789           1 :     CPPUNIT_ASSERT_EQUAL(true, bool(getProperty<sal_Bool>(xShape, "Opaque")));
    1790             :     // And this should be behind the document.
    1791           1 :     CPPUNIT_ASSERT_EQUAL(false, bool(getProperty<sal_Bool>(getShape(2), "Opaque")));
    1792           1 : }
    1793             : 
    1794          12 : DECLARE_OOXMLIMPORT_TEST(lineWpsOnly, "line-wps-only.docx")
    1795             : {
    1796           1 :     uno::Reference<drawing::XShape> xShape = getShape(1);
    1797             :     // Check position, it was -7223 as it was set after the CustomShapeGeometry property.
    1798           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(210), xShape->getPosition().X);
    1799           1 : }
    1800             : 
    1801          12 : DECLARE_OOXMLIMPORT_TEST(lineRotation, "line-rotation.docx")
    1802             : {
    1803           1 :     uno::Reference<drawing::XShape> xShape = getShape(3);
    1804             :     // This was 5096: the line was shifted towards the bottom, so the end of
    1805             :     // the 3 different lines wasn't at the same point.
    1806           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(4808), xShape->getPosition().Y);
    1807           1 : }
    1808             : 
    1809          12 : DECLARE_OOXMLIMPORT_TEST(textboxWpsOnly, "textbox-wps-only.docx")
    1810             : {
    1811           1 :     uno::Reference<text::XTextRange> xFrame(getShape(1), uno::UNO_QUERY);
    1812           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Hello world!"), xFrame->getString());
    1813             :     // Position wasn't horizontally centered.
    1814           1 :     CPPUNIT_ASSERT_EQUAL(text::HoriOrientation::CENTER, getProperty<sal_Int16>(xFrame, "HoriOrient"));
    1815             : 
    1816             :     // Position was the default (hori center, vert top) for the textbox.
    1817           1 :     xFrame.set(getShape(2), uno::UNO_QUERY);
    1818           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2173), getProperty<sal_Int32>(xFrame, "HoriOrientPosition"));
    1819             : #ifdef MACOSX
    1820             :     // FIXME: The assert below fails wildly on a Retina display. So use some (horrible)
    1821             :     // heuristics. Note that for instance on the 5K Retina iMac, [NSScreen mainScreen].frame.size is
    1822             :     // 2560x1440, not the true display size 5120x2880. But whatever, I don't have much time to spend
    1823             :     // on this.
    1824             :     if ([NSScreen mainScreen].frame.size.width > 2000)
    1825             :         return;
    1826             : #endif
    1827           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2805), getProperty<sal_Int32>(xFrame, "VertOrientPosition"));
    1828           1 : }
    1829             : 
    1830          12 : DECLARE_OOXMLIMPORT_TEST(testWpgOnly, "wpg-only.docx")
    1831             : {
    1832           1 :     uno::Reference<drawing::XShape> xShape = getShape(1);
    1833             :     // Check position, it was nearly 0. This is a shape, so use getPosition(), not a property.
    1834           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(oox::drawingml::convertEmuToHmm(548005)), xShape->getPosition().X);
    1835           1 : }
    1836             : 
    1837          12 : DECLARE_OOXMLIMPORT_TEST(testWpgNested, "wpg-nested.docx")
    1838             : {
    1839           1 :     uno::Reference<drawing::XShapes> xGroup(getShape(1), uno::UNO_QUERY);
    1840           2 :     uno::Reference<drawing::XShapeDescriptor> xShapeDescriptor(xGroup->getByIndex(0), uno::UNO_QUERY);
    1841             :     // This was a com.sun.star.drawing.CustomShape, due to lack of handling of groupshapes inside groupshapes.
    1842           1 :     CPPUNIT_ASSERT_EQUAL(OUString("com.sun.star.drawing.GroupShape"), xShapeDescriptor->getShapeType());
    1843             :     // This was text::RelOrientation::PAGE_FRAME, effectively placing the group shape on the left side of the page instead of the right one.
    1844           2 :     CPPUNIT_ASSERT_EQUAL(text::RelOrientation::PAGE_RIGHT, getProperty<sal_Int16>(xGroup, "HoriOrientRelation"));
    1845           1 : }
    1846             : 
    1847          12 : DECLARE_OOXMLIMPORT_TEST(textboxWpgOnly, "textbox-wpg-only.docx")
    1848             : {
    1849           1 :     uno::Reference<drawing::XShape> xShape = getShape(1);
    1850             :     // The relativeFrom attribute was ignored for groupshapes, i.e. these were text::RelOrientation::FRAME.
    1851           1 :     CPPUNIT_ASSERT_EQUAL(text::RelOrientation::PAGE_FRAME, getProperty<sal_Int16>(xShape, "HoriOrientRelation"));
    1852           1 :     CPPUNIT_ASSERT_EQUAL(text::RelOrientation::PAGE_FRAME, getProperty<sal_Int16>(xShape, "VertOrientRelation"));
    1853             :     // Make sure the shape is not in the background, as we have behindDoc="0" in the doc.
    1854           1 :     CPPUNIT_ASSERT_EQUAL(true, bool(getProperty<sal_Bool>(xShape, "Opaque")));
    1855             : 
    1856             :     // The 3 paragraphs on the rectangles inside the groupshape ended up in the
    1857             :     // body text, make sure we don't have multiple paragraphs there anymore.
    1858           1 :     CPPUNIT_ASSERT_EQUAL(1, getParagraphs()); // was 4
    1859             : 
    1860             :     // Character escapement was enabled by default, this was 58.
    1861           2 :     uno::Reference<container::XIndexAccess> xGroup(xShape, uno::UNO_QUERY);
    1862           2 :     uno::Reference<text::XText> xText = uno::Reference<text::XTextRange>(xGroup->getByIndex(0), uno::UNO_QUERY)->getText();
    1863           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(100), getProperty<sal_Int32>(getRun(getParagraphOfText(1, xText), 1), "CharEscapementHeight"));
    1864           1 : }
    1865             : 
    1866          12 : DECLARE_OOXMLIMPORT_TEST(testMceWpg, "mce-wpg.docx")
    1867             : {
    1868             :     // Make sure that we read the primary branch, if wpg is requested as a feature.
    1869           1 :     uno::Reference<container::XIndexAccess> xGroup(getShape(1), uno::UNO_QUERY);
    1870           2 :     uno::Reference<text::XText> xText = uno::Reference<text::XTextRange>(xGroup->getByIndex(0), uno::UNO_QUERY)->getText();
    1871             :     // This was VML1.
    1872           2 :     getParagraphOfText(1, xText, "DML1");
    1873           1 : }
    1874             : 
    1875          12 : DECLARE_OOXMLIMPORT_TEST(testMceNested, "mce-nested.docx")
    1876             : {
    1877             :     // Vertical position of the shape was incorrect due to incorrect nested mce handling.
    1878           1 :     uno::Reference<beans::XPropertySet> xShape(getShape(1), uno::UNO_QUERY);
    1879             :     // positionV's posOffset from the bugdoc, was 0.
    1880           1 :     CPPUNIT_ASSERT(6985 <= getProperty<sal_Int32>(xShape, "VertOrientPosition"));
    1881             :     // This was -1 (default), make sure the background color is set.
    1882           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0x4f81bd), getProperty<sal_Int32>(xShape, "FillColor"));
    1883             : 
    1884           2 :     uno::Reference<drawing::XShapeDescriptor> xShapeDescriptor(getShape(2), uno::UNO_QUERY);
    1885             :     // This was a com.sun.star.drawing.CustomShape, due to incorrect handling of wpg elements after a wps textbox.
    1886           1 :     CPPUNIT_ASSERT_EQUAL(OUString("com.sun.star.drawing.GroupShape"), xShapeDescriptor->getShapeType());
    1887             : 
    1888             :     // Now check the top right textbox.
    1889           2 :     uno::Reference<container::XIndexAccess> xGroup(getShape(2), uno::UNO_QUERY);
    1890           2 :     uno::Reference<text::XText> xText = uno::Reference<text::XTextRange>(xGroup->getByIndex(1), uno::UNO_QUERY)->getText();
    1891           2 :     uno::Reference<text::XTextRange> xParagraph = getParagraphOfText(1, xText, "[Year]");
    1892           1 :     CPPUNIT_ASSERT_EQUAL(48.f, getProperty<float>(getRun(xParagraph, 1), "CharHeight"));
    1893           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0xffffff), getProperty<sal_Int32>(getRun(xParagraph, 1), "CharColor"));
    1894           1 :     CPPUNIT_ASSERT_EQUAL(awt::FontWeight::BOLD, getProperty<float>(getRun(xParagraph, 1), "CharWeight"));
    1895           2 :     CPPUNIT_ASSERT_EQUAL(drawing::TextVerticalAdjust_BOTTOM, getProperty<drawing::TextVerticalAdjust>(xGroup->getByIndex(1), "TextVerticalAdjust"));
    1896           1 : }
    1897             : 
    1898          12 : DECLARE_OOXMLIMPORT_TEST(testMissingPath, "missing-path.docx")
    1899             : {
    1900           1 :     comphelper::SequenceAsHashMap aCustomShapeGeometry(getProperty<beans::PropertyValues>(getShape(1), "CustomShapeGeometry"));
    1901           2 :     comphelper::SequenceAsHashMap aPath(aCustomShapeGeometry["Path"].get<beans::PropertyValues>());
    1902           2 :     uno::Sequence<drawing::EnhancedCustomShapeParameterPair> aCoordinates = aPath["Coordinates"].get< uno::Sequence<drawing::EnhancedCustomShapeParameterPair> >();
    1903             :     // This was 0, the coordinate list was empty.
    1904           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(19), aCoordinates.getLength());
    1905           1 : }
    1906             : 
    1907          12 : DECLARE_OOXMLIMPORT_TEST(testFdo70457, "fdo70457.docx")
    1908             : {
    1909             :     // The document contains a rotated bitmap
    1910             :     // It must be imported as a XShape object with the proper rotation value
    1911             : 
    1912             :     // Check: there is one shape in the doc
    1913           1 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
    1914           2 :     uno::Reference<container::XIndexAccess> xDraws(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
    1915           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xDraws->getCount());
    1916             : 
    1917             :     // Check: the angle of the shape is 45ยบ
    1918           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(4500), getProperty<sal_Int32>(getShape(1), "RotateAngle"));
    1919           1 : }
    1920             : 
    1921          12 : DECLARE_OOXMLIMPORT_TEST(testLOCrash,"file_crash.docx")
    1922             : {
    1923             :     //The problem was libreoffice crash while opening the file.
    1924           1 :     getParagraph(1,"Contents");
    1925           1 : }
    1926             : 
    1927          12 : DECLARE_OOXMLIMPORT_TEST(testFdo72560, "fdo72560.docx")
    1928             : {
    1929             :     // The problem was libreoffice confuse when there RTL default style for paragraph
    1930           1 :     uno::Reference<uno::XInterface> xParaLeftRTL(getParagraph( 1, "RTL LEFT"));
    1931           2 :     uno::Reference<uno::XInterface> xParaRightLTR(getParagraph( 2, "LTR RIGHT"));
    1932             : 
    1933             :     // this will test the text direction and alignment for paragraphs
    1934           1 :     CPPUNIT_ASSERT_EQUAL(text::WritingMode2::RL_TB, getProperty<sal_Int16>( xParaLeftRTL, "WritingMode" ));
    1935           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32 (style::ParagraphAdjust_LEFT), getProperty< sal_Int32 >( xParaLeftRTL, "ParaAdjust" ));
    1936             : 
    1937           1 :     CPPUNIT_ASSERT_EQUAL(text::WritingMode2::LR_TB, getProperty<sal_Int16>( xParaRightLTR, "WritingMode" ));
    1938           2 :     CPPUNIT_ASSERT_EQUAL( sal_Int32 (style::ParagraphAdjust_RIGHT), getProperty< sal_Int32 >( xParaRightLTR, "ParaAdjust" ));
    1939           1 : }
    1940             : 
    1941          12 : DECLARE_OOXMLIMPORT_TEST(testRPrChangeClosed, "rprchange_closed.docx")
    1942             : {
    1943             :     // Redline defined by rPrChanged wasn't removed.
    1944             :     // First paragraph has an rPrChange element, make sure it doesn't appear in the second paragraph.
    1945           1 :     CPPUNIT_ASSERT_EQUAL(false, hasProperty(getRun(getParagraph(2), 1), "RedlineType"));
    1946           1 : }
    1947             : 
    1948          12 : DECLARE_OOXMLIMPORT_TEST(testFdo65090, "fdo65090.docx")
    1949             : {
    1950           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1951           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    1952           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    1953           2 :     uno::Reference<table::XTableRows> xTableRows(xTextTable->getRows(), uno::UNO_QUERY);
    1954             :     // The first row had two cells, instead of a single horizontally merged one.
    1955           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), getProperty< uno::Sequence<text::TableColumnSeparator> >(xTableRows->getByIndex(0), "TableColumnSeparators").getLength());
    1956           1 : }
    1957             : 
    1958          12 : DECLARE_OOXMLIMPORT_TEST(testFdo69649, "fdo69649.docx")
    1959             : {
    1960             :     // The DOCX containing the Table of Contents was not imported with correct page nos
    1961           1 :     uno::Reference<text::XDocumentIndexesSupplier> xIndexSupplier(mxComponent, uno::UNO_QUERY);
    1962           2 :     uno::Reference<container::XIndexAccess> xIndexes(xIndexSupplier->getDocumentIndexes( ), uno::UNO_QUERY);
    1963           2 :     uno::Reference<text::XDocumentIndex> xTOCIndex(xIndexes->getByIndex(0), uno::UNO_QUERY);
    1964           2 :     uno::Reference<text::XTextRange> xTextRange(xTOCIndex->getAnchor(), uno::UNO_QUERY);
    1965           2 :     uno::Reference<text::XText> xText(xTextRange->getText( ), uno::UNO_QUERY);
    1966           2 :     uno::Reference<text::XTextCursor> xTextCursor(xText->createTextCursor( ), uno::UNO_QUERY);
    1967           1 :     xTextCursor->gotoRange(xTextRange->getStart(),false);
    1968           1 :     xTextCursor->gotoRange(xTextRange->getEnd(),true);
    1969           2 :     OUString xTocString(xTextCursor->getString());
    1970           1 :     xTocString = xTocString.copy(256);
    1971           2 :     CPPUNIT_ASSERT(xTocString.startsWithIgnoreAsciiCase( "Heading 15.1:\t15" ) );
    1972           1 : }
    1973             : 
    1974          12 : DECLARE_OOXMLIMPORT_TEST(testFdo73389,"fdo73389.docx")
    1975             : {
    1976           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    1977           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    1978             :     // This was 9340, i.e. the width of the inner table was too large.
    1979           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(2842), getProperty<sal_Int32>(xTables->getByIndex(0), "Width"));
    1980           1 : }
    1981             : 
    1982          12 : DECLARE_OOXMLIMPORT_TEST(testDMLGroupshapeSdt, "dml-groupshape-sdt.docx")
    1983             : {
    1984           1 :     uno::Reference<drawing::XShapes> xGroupShape(getShape(1), uno::UNO_QUERY);
    1985             :     // The text in the groupshape was missing due to the w:sdt and w:sdtContent wrapper around it.
    1986           1 :     CPPUNIT_ASSERT_EQUAL(OUString("sdt and sdtContent inside groupshape"), uno::Reference<text::XTextRange>(xGroupShape->getByIndex(1), uno::UNO_QUERY)->getString());
    1987           1 : }
    1988             : 
    1989          12 : DECLARE_OOXMLIMPORT_TEST(testDmlCharheightDefault, "dml-charheight-default.docx")
    1990             : {
    1991           1 :     uno::Reference<container::XIndexAccess> xGroup(getShape(1), uno::UNO_QUERY);
    1992           2 :     uno::Reference<text::XTextRange> xShape(xGroup->getByIndex(0), uno::UNO_QUERY);
    1993             :     // This was 16: the first run of the second para incorrectly inherited the char height of the first para.
    1994           2 :     CPPUNIT_ASSERT_EQUAL(11.f, getProperty<float>(getRun(getParagraphOfText(2, xShape->getText()), 1), "CharHeight"));
    1995           1 : }
    1996             : 
    1997          12 : DECLARE_OOXMLIMPORT_TEST(testGroupshapeRelsize, "groupshape-relsize.docx")
    1998             : {
    1999             :     // This was 43760, i.e. the height of the groupshape was larger than the page height, which is obviously incorrect.
    2000           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(oox::drawingml::convertEmuToHmm(9142730)), getShape(1)->getSize().Height);
    2001           1 : }
    2002             : 
    2003          12 : DECLARE_OOXMLIMPORT_TEST(testOleAnchor, "ole-anchor.docx")
    2004             : {
    2005             :     // This was AS_CHARACTER, even if the VML style explicitly contains "position:absolute".
    2006           1 :     CPPUNIT_ASSERT_EQUAL(text::TextContentAnchorType_AT_CHARACTER, getProperty<text::TextContentAnchorType>(getShape(1), "AnchorType"));
    2007             :     // This was DYNAMIC, even if the default is THROUGHT and there is no w10:wrap element in the bugdoc.
    2008           1 :     CPPUNIT_ASSERT_EQUAL(text::WrapTextMode_THROUGHT, getProperty<text::WrapTextMode>(getShape(1), "Surround"));
    2009           1 : }
    2010             : 
    2011          12 : DECLARE_OOXMLIMPORT_TEST(testDMLGroupShapeCapitalization, "dml-groupshape-capitalization.docx")
    2012             : {
    2013             :     // Capitalization inside a group shape was not imported
    2014           1 :     uno::Reference<container::XIndexAccess> xGroup(getShape(1), uno::UNO_QUERY);
    2015           2 :     uno::Reference<text::XText> xText = uno::Reference<text::XTextRange>(xGroup->getByIndex(1), uno::UNO_QUERY)->getText();
    2016             :     // 2nd line is written with uppercase letters
    2017           1 :     CPPUNIT_ASSERT_EQUAL(style::CaseMap::UPPERCASE, getProperty<sal_Int16>(getRun(getParagraphOfText(2, xText), 1), "CharCaseMap"));
    2018             :     // 3rd line has no capitalization
    2019           1 :     CPPUNIT_ASSERT_EQUAL(style::CaseMap::NONE, getProperty<sal_Int16>(getRun(getParagraphOfText(3, xText), 1), "CharCaseMap"));
    2020             :     // 4th line has written with small capitals
    2021           1 :     CPPUNIT_ASSERT_EQUAL(style::CaseMap::SMALLCAPS, getProperty<sal_Int16>(getRun(getParagraphOfText(4, xText), 1), "CharCaseMap"));
    2022             :     // 5th line has no capitalization
    2023           2 :     CPPUNIT_ASSERT_EQUAL(style::CaseMap::NONE, getProperty<sal_Int16>(getRun(getParagraphOfText(5, xText), 1), "CharCaseMap"));
    2024           1 : }
    2025             : 
    2026          12 : DECLARE_OOXMLIMPORT_TEST(testDMLGroupShapeParaAdjust, "dml-groupshape-paraadjust.docx")
    2027             : {
    2028             :     // Paragraph adjustment inside a group shape was not imported
    2029           1 :     uno::Reference<container::XIndexAccess> xGroup(getShape(1), uno::UNO_QUERY);
    2030           2 :     uno::Reference<text::XText> xText = uno::Reference<text::XTextRange>(xGroup->getByIndex(1), uno::UNO_QUERY)->getText();
    2031             :     // 2nd line is adjusted to the right
    2032           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(style::ParagraphAdjust_RIGHT), getProperty<sal_Int16>(getRun(getParagraphOfText(2, xText), 1), "ParaAdjust"));
    2033             :     // 3rd line has no adjustment
    2034           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(style::ParagraphAdjust_LEFT), getProperty<sal_Int16>(getRun(getParagraphOfText(3, xText), 1), "ParaAdjust"));
    2035             :     // 4th line is adjusted to center
    2036           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(style::ParagraphAdjust_CENTER), getProperty<sal_Int16>(getRun(getParagraphOfText(4, xText), 1), "ParaAdjust"));
    2037             :     // 5th line has no adjustment
    2038           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(style::ParagraphAdjust_LEFT), getProperty<sal_Int16>(getRun(getParagraphOfText(5, xText), 1), "ParaAdjust"));
    2039             :     // 6th line is justified
    2040           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(style::ParagraphAdjust_BLOCK), getProperty<sal_Int16>(getRun(getParagraphOfText(6, xText), 1), "ParaAdjust"));
    2041             :     // 7th line has no adjustment
    2042           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(style::ParagraphAdjust_LEFT), getProperty<sal_Int16>(getRun(getParagraphOfText(7, xText), 1), "ParaAdjust"));
    2043           1 : }
    2044             : 
    2045          12 : DECLARE_OOXMLIMPORT_TEST(testPictureWithSchemeColor, "picture-with-schemecolor.docx")
    2046             : {
    2047             :     // At the start of the document, a picture which has a color specified with a color scheme, lost
    2048             :     // it's color during import.
    2049           1 :     uno::Reference<beans::XPropertySet> xImage(getShape(1), uno::UNO_QUERY);
    2050           2 :     uno::Reference<graphic::XGraphic> xGraphic = getProperty<uno::Reference<graphic::XGraphic> >(xImage, "Graphic");
    2051           2 :     Graphic aVclGraphic(xGraphic);
    2052           2 :     Bitmap aBitmap(aVclGraphic.GetBitmap());
    2053           1 :     BitmapReadAccess* pAccess = aBitmap.AcquireReadAccess();
    2054           1 :     CPPUNIT_ASSERT(pAccess);
    2055           1 :     CPPUNIT_ASSERT_EQUAL(341L, pAccess->Width());
    2056           1 :     CPPUNIT_ASSERT_EQUAL(181L, pAccess->Height());
    2057           1 :     Color aColor(pAccess->GetPixel(30, 120));
    2058           1 :     CPPUNIT_ASSERT_EQUAL(aColor.GetColor(), RGB_COLORDATA( 0xb1, 0xc8, 0xdd ));
    2059           1 :     aColor = pAccess->GetPixel(130, 260);
    2060           1 :     CPPUNIT_ASSERT_EQUAL(aColor.GetColor(), RGB_COLORDATA( 0xb1, 0xc8, 0xdd ));
    2061           2 :     Bitmap::ReleaseAccess(pAccess);
    2062           1 : }
    2063             : 
    2064          12 : DECLARE_OOXMLIMPORT_TEST(testFdo69656, "Table_cell_auto_width_fdo69656.docx")
    2065             : {
    2066           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    2067           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    2068           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(8154), getProperty<sal_Int32>(xTables->getByIndex(0), "Width"));
    2069           1 : }
    2070             : 
    2071          12 : DECLARE_OOXMLIMPORT_TEST(testFloatingTablesAnchor, "floating-tables-anchor.docx")
    2072             : {
    2073             :     // Problem was one of the two text frames was anchored to the other text frame
    2074             :     // Both frames should be anchored to the paragraph with the text "Anchor point"
    2075           1 :     uno::Reference<text::XTextContent> xTextContent(getShape(1), uno::UNO_QUERY);
    2076           2 :     uno::Reference<text::XTextRange> xRange(xTextContent->getAnchor(), uno::UNO_QUERY);
    2077           2 :     uno::Reference<text::XText> xText(xRange->getText(), uno::UNO_QUERY);
    2078           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Anchor point"), xText->getString());
    2079             : 
    2080           1 :     xTextContent.set(getShape(2), uno::UNO_QUERY);
    2081           1 :     xRange.set(xTextContent->getAnchor(), uno::UNO_QUERY);
    2082           1 :     xText.set(xRange->getText(), uno::UNO_QUERY);
    2083           2 :     CPPUNIT_ASSERT_EQUAL(OUString("Anchor point"), xText->getString());
    2084           1 : }
    2085             : 
    2086          12 : DECLARE_OOXMLIMPORT_TEST(testAnnotationFormatting, "annotation-formatting.docx")
    2087             : {
    2088           1 :     uno::Reference<beans::XPropertySet> xTextField = getProperty< uno::Reference<beans::XPropertySet> >(getRun(getParagraph(2), 2), "TextField");
    2089           2 :     uno::Reference<text::XText> xText = getProperty< uno::Reference<text::XText> >(xTextField, "TextRange");
    2090             :     // Make sure we test the right annotation.
    2091           2 :     uno::Reference<text::XTextRange> xParagraph = getParagraphOfText(1, xText, "days");
    2092             :     // Formatting was lost: the second text portion was NONE, not SINGLE.
    2093           2 :     CPPUNIT_ASSERT_EQUAL(awt::FontUnderline::SINGLE, getProperty<sal_Int16>(getRun(xParagraph, 1), "CharUnderline"));
    2094           1 : }
    2095             : 
    2096          12 : DECLARE_OOXMLIMPORT_TEST(testDMLGroupShapeRunFonts, "dml-groupshape-runfonts.docx")
    2097             : {
    2098             :     // Fonts defined by w:rFonts was not imported and so the font specified by a:fontRef was used.
    2099           1 :     uno::Reference<container::XIndexAccess> xGroup(getShape(1), uno::UNO_QUERY);
    2100           2 :     uno::Reference<text::XText> xText = uno::Reference<text::XTextRange>(xGroup->getByIndex(1), uno::UNO_QUERY)->getText();
    2101           2 :     uno::Reference<text::XTextRange> xRun = getRun(getParagraphOfText(1, xText),1);
    2102           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Arial"), getProperty<OUString>(xRun, "CharFontName"));
    2103           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Arial Unicode MS"), getProperty<OUString>(xRun, "CharFontNameComplex"));
    2104           2 :     CPPUNIT_ASSERT_EQUAL(OUString("MS Mincho"), getProperty<OUString>(xRun, "CharFontNameAsian"));
    2105           1 : }
    2106             : 
    2107          12 : DECLARE_OOXMLIMPORT_TEST(testStrict, "strict.docx")
    2108             : {
    2109           1 :     uno::Reference<beans::XPropertySet> xPageStyle(getStyles("PageStyles")->getByName(DEFAULT_STYLE), uno::UNO_QUERY);
    2110             :     // This was only 127, pt suffix was ignored, so this got parsed as twips instead of points.
    2111           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(convertTwipToMm100(72 * 20)), getProperty<sal_Int32>(xPageStyle, "BottomMargin"));
    2112             :     // This was only 1397, same issue
    2113           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(convertTwipToMm100(792 * 20)), getProperty<sal_Int32>(xPageStyle, "Height"));
    2114             :     // Text was missing, due to not handling the strict namespaces.
    2115           1 :     getParagraph(1, "Hello world!");
    2116             : 
    2117             :     // Header in the document caused a crash on import.
    2118           2 :     uno::Reference<text::XText> xHeaderText(xPageStyle->getPropertyValue("HeaderText"), uno::UNO_QUERY);
    2119           1 :     getParagraphOfText(1, xHeaderText, "This is a header.");
    2120             : 
    2121             :     // Picture was missing.
    2122           2 :     uno::Reference<lang::XServiceInfo> xServiceInfo(getShape(1), uno::UNO_QUERY);
    2123           1 :     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.text.TextGraphicObject"));
    2124             : 
    2125             :     // SmartArt was missing.
    2126           1 :     xServiceInfo.set(getShape(2), uno::UNO_QUERY);
    2127           1 :     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.drawing.GroupShape"));
    2128             : 
    2129             :     // Chart was missing.
    2130           1 :     xServiceInfo.set(getShape(3), uno::UNO_QUERY);
    2131           1 :     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.text.TextEmbeddedObject"));
    2132             : 
    2133             :     // Math was missing.
    2134           1 :     xServiceInfo.set(getShape(4), uno::UNO_QUERY);
    2135           2 :     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.text.TextEmbeddedObject"));
    2136           1 : }
    2137             : 
    2138          12 : DECLARE_OOXMLIMPORT_TEST(testStrictLockedcanvas, "strict-lockedcanvas.docx")
    2139             : {
    2140             :     // locked canvas shape was missing.
    2141           1 :     getShape(1);
    2142           1 : }
    2143             : 
    2144          12 : DECLARE_OOXMLIMPORT_TEST(testSmartartStrict, "strict-smartart.docx")
    2145             : {
    2146           1 :     uno::Reference<container::XIndexAccess> xGroup(getShape(1), uno::UNO_QUERY);
    2147             :     // This was 0, SmartArt was visually missing.
    2148           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(6), xGroup->getCount()); // 3 ellipses + 3 arrows
    2149           1 : }
    2150             : 
    2151          12 : DECLARE_OOXMLIMPORT_TEST(testLibreOfficeHang, "frame-wrap-auto.docx")
    2152             : {
    2153             :     // fdo#72775
    2154             :     // This was text::WrapTextMode_NONE.
    2155           1 :     CPPUNIT_ASSERT_EQUAL(text::WrapTextMode_DYNAMIC, getProperty<text::WrapTextMode>(getShape(1), "Surround"));
    2156           1 : }
    2157             : 
    2158          12 : DECLARE_OOXMLIMPORT_TEST(testI124106, "i124106.docx")
    2159             : {
    2160             :     // This was 2.
    2161           1 :     CPPUNIT_ASSERT_EQUAL(1, getPages());
    2162           1 : }
    2163             : 
    2164          12 : DECLARE_OOXMLIMPORT_TEST(testLargeTwips, "large-twips.docx" )
    2165             : {
    2166             :     // cp#1000043: MSO seems to ignore large twips values, we didn't, which resulted in different
    2167             :     // layout of broken documents (text not visible in this specific document).
    2168           1 :     OUString width = parseDump( "/root/page/body/tab/row[1]/cell[1]/txt/infos/bounds", "width" );
    2169           1 :     CPPUNIT_ASSERT( width.toInt32() > 0 );
    2170           1 : }
    2171             : 
    2172          12 : DECLARE_OOXMLIMPORT_TEST(testNegativeCellMarginTwips, "negative-cell-margin-twips.docx" )
    2173             : {
    2174             :     // Sligtly related to cp#1000043, the twips value was negative, which wrapped around somewhere,
    2175             :     // while MSO seems to ignore that as well.
    2176           1 :     OUString width = parseDump( "/root/page/body/tab/row[1]/cell[1]/txt/infos/bounds", "width" );
    2177           1 :     CPPUNIT_ASSERT( width.toInt32() > 0 );
    2178           1 : }
    2179             : 
    2180          12 : DECLARE_OOXMLIMPORT_TEST(testFdo38414, "fdo38414.docx" )
    2181             : {
    2182             :     // The cells in the last (4th) column were merged properly and so the result didn't have the same height.
    2183             :     // (Since w:gridBefore is worked around by faking another cell in the row, so column count is thus 5
    2184             :     // instead of 4, therefore compare height of cells 4 and 5 rather than 3 and 4.)
    2185           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    2186           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    2187           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    2188           2 :     uno::Reference<table::XTableColumns> xTableColumns(xTextTable->getColumns(), uno::UNO_QUERY);
    2189           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 5 ), xTableColumns->getCount());
    2190           2 :     OUString height3 = parseDump("/root/page/body/tab/row[1]/cell[4]/infos/bounds", "height" );
    2191           2 :     OUString height4 = parseDump("/root/page/body/tab/row[1]/cell[5]/infos/bounds", "height" );
    2192           2 :     CPPUNIT_ASSERT_EQUAL( height3, height4 );
    2193           1 : }
    2194             : 
    2195          12 : DECLARE_OOXMLIMPORT_TEST(test_extra_image, "test_extra_image.docx" )
    2196             : {
    2197             :     // fdo#74652 Check there is no shape added to the doc during import
    2198           1 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
    2199           2 :     uno::Reference<container::XIndexAccess> xDraws(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
    2200           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xDraws->getCount());
    2201           1 : }
    2202             : 
    2203          12 : DECLARE_OOXMLIMPORT_TEST(testFdo74401, "fdo74401.docx")
    2204             : {
    2205           1 :     uno::Reference<drawing::XShapes> xGroupShape(getShape(1), uno::UNO_QUERY);
    2206           2 :     uno::Reference<drawing::XShapeDescriptor> xShape(xGroupShape->getByIndex(1), uno::UNO_QUERY);
    2207             :     // The triangle (second child) was a TextShape before, so it was shown as a rectangle.
    2208           2 :     CPPUNIT_ASSERT_EQUAL(OUString("com.sun.star.drawing.CustomShape"), xShape->getShapeType());
    2209           1 : }
    2210             : 
    2211          12 : DECLARE_OOXMLIMPORT_TEST(testFdo75722vml, "fdo75722-vml.docx")
    2212             : {
    2213           1 :     uno::Reference<drawing::XShape> xShape = getShape(1);
    2214           1 :     awt::Point aPos = xShape->getPosition();
    2215           1 :     awt::Size aSize = xShape->getSize();
    2216           1 :     sal_Int64 nRot = getProperty<sal_Int64>(xShape, "RotateAngle");
    2217             : 
    2218           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3720), aPos.X);
    2219           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(-392), aPos.Y);
    2220           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(5457), aSize.Width);
    2221           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3447), aSize.Height);
    2222           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int64(3100), nRot);
    2223           1 : }
    2224             : 
    2225          12 : DECLARE_OOXMLIMPORT_TEST(testFdo75722dml, "fdo75722-dml.docx")
    2226             : {
    2227           1 :     uno::Reference<drawing::XShape> xShape = getShape(1);
    2228           1 :     awt::Point aPos = xShape->getPosition();
    2229           1 :     awt::Size aSize = xShape->getSize();
    2230           1 :     sal_Int64 nRot = getProperty<sal_Int64>(xShape, "RotateAngle");
    2231             : 
    2232             :     // a slight difference regarding vml file is tolerated due to rounding errors
    2233           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3720), aPos.X);
    2234           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(-397), aPos.Y);
    2235           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(5457), aSize.Width);
    2236           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3447), aSize.Height);
    2237           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int64(3128), nRot);
    2238           1 : }
    2239             : 
    2240          12 : DECLARE_OOXMLIMPORT_TEST(testFdo55381, "fdo55381.docx")
    2241             : {
    2242           1 :     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
    2243           2 :     uno::Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(), uno::UNO_QUERY);
    2244           2 :     uno::Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), uno::UNO_QUERY);
    2245           1 :     xCursor->jumpToLastPage();
    2246           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(4), xCursor->getPage());
    2247           1 : }
    2248             : 
    2249          12 : DECLARE_OOXMLIMPORT_TEST(testGridBefore, "gridbefore.docx")
    2250             : {
    2251             :     // w:gridBefore is faked by inserting two cells without border (because Writer can't do non-rectangular tables).
    2252             :     // So check the first cell in the first row is in fact 3rd and that it's more to the right than the second
    2253             :     // cell on the second row.
    2254           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    2255           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    2256           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    2257           2 :     uno::Reference<table::XTableColumns> xTableColumns(xTextTable->getColumns(), uno::UNO_QUERY);
    2258           1 :     CPPUNIT_ASSERT_EQUAL( sal_Int32( 3 ), xTableColumns->getCount());
    2259           2 :     OUString textA3 = parseDump("/root/page/body/tab/row[1]/cell[3]/txt/text()" );
    2260           2 :     OUString leftA3 = parseDump("/root/page/body/tab/row[1]/cell[3]/infos/bounds", "left" );
    2261           2 :     OUString leftB2 = parseDump("/root/page/body/tab/row[2]/cell[2]/infos/bounds", "left" );
    2262           1 :     CPPUNIT_ASSERT_EQUAL( OUString( "A3" ), textA3 );
    2263           2 :     CPPUNIT_ASSERT( leftA3.toInt32() > leftB2.toInt32());
    2264           1 : }
    2265             : 
    2266          12 : DECLARE_OOXMLIMPORT_TEST(testMsoBrightnessContrast, "msobrightnesscontrast.docx")
    2267             : {
    2268           1 :     uno::Reference<text::XTextDocument> textDocument(mxComponent, uno::UNO_QUERY);
    2269           2 :     uno::Reference<drawing::XShape> image(getShape(1), uno::UNO_QUERY);
    2270           2 :     uno::Reference<beans::XPropertySet> imageProperties(image, uno::UNO_QUERY);
    2271           2 :     uno::Reference<graphic::XGraphic> graphic;
    2272           1 :     imageProperties->getPropertyValue( "Graphic" ) >>= graphic;
    2273           2 :     uno::Reference<awt::XBitmap> bitmap(graphic, uno::UNO_QUERY);
    2274           2 :     Graphic aVclGraphic(graphic);
    2275           2 :     Bitmap aBitmap(aVclGraphic.GetBitmap());
    2276           1 :     BitmapReadAccess* pAccess = aBitmap.AcquireReadAccess();
    2277           1 :     CPPUNIT_ASSERT(pAccess);
    2278           1 :     CPPUNIT_ASSERT_EQUAL(58L, pAccess->Width());
    2279           1 :     CPPUNIT_ASSERT_EQUAL(320L, pAccess->Height());
    2280           1 :     Color aColor(pAccess->GetPixel(30, 20));
    2281           1 :     CPPUNIT_ASSERT_EQUAL(aColor.GetColor(), RGB_COLORDATA( 0xce, 0xce, 0xce ));
    2282           2 :     Bitmap::ReleaseAccess(pAccess);
    2283           1 : }
    2284             : 
    2285          12 : DECLARE_OOXMLIMPORT_TEST(testChartSize, "chart-size.docx")
    2286             : {
    2287             :     // When chart was in a TextFrame, its size was too large.
    2288           1 :     uno::Reference<text::XTextEmbeddedObjectsSupplier> xTextEmbeddedObjectsSupplier(mxComponent, uno::UNO_QUERY);
    2289           2 :     uno::Reference<container::XIndexAccess> xEmbeddedObjects(xTextEmbeddedObjectsSupplier->getEmbeddedObjects(), uno::UNO_QUERY);
    2290             :     // This was 10954.
    2291           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(6008), getProperty<sal_Int32>(xEmbeddedObjects->getByIndex(0), "Width"));
    2292             : 
    2293             :     // Layout modified the document when it had this chart.
    2294           2 :     uno::Reference<util::XModifiable> xModifiable(mxComponent, uno::UNO_QUERY);
    2295           2 :     CPPUNIT_ASSERT_EQUAL(false, bool(xModifiable->isModified()));
    2296           1 : }
    2297             : 
    2298          12 : DECLARE_OOXMLIMPORT_TEST(testInlineGroupshape, "inline-groupshape.docx")
    2299             : {
    2300             :     // Inline groupshape was in the background, so it was hidden sometimes by other shapes.
    2301           1 :     CPPUNIT_ASSERT_EQUAL(true, getProperty<bool>(getShape(1), "Opaque"));
    2302           1 : }
    2303             : 
    2304          12 : DECLARE_OOXMLIMPORT_TEST(testFdo78883, "fdo78883.docx")
    2305             : {
    2306             :     // fdo#78883 : LO was getting hang while opening document
    2307             :     // Checking there is a single page after loading a doc in LO.
    2308           1 :     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
    2309           2 :     uno::Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(), uno::UNO_QUERY);
    2310           2 :     uno::Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), uno::UNO_QUERY);
    2311           1 :     xCursor->jumpToLastPage();
    2312             : 
    2313             :     // Check to make sure the document loaded.  Note that the page number may
    2314             :     // be 1 or 2 depending on the environment.
    2315           2 :     CPPUNIT_ASSERT(xCursor->getPage() > sal_Int16(0));
    2316           1 : }
    2317             : 
    2318          12 : DECLARE_OOXMLIMPORT_TEST(testFdo79535, "fdo79535.docx")
    2319             : {
    2320             :     // fdo#79535 : LO was crashing while opening document
    2321             :     // Checking there is a single page after loading a doc successfully in LO.
    2322           1 :     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
    2323           2 :     uno::Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(), uno::UNO_QUERY);
    2324           2 :     uno::Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), uno::UNO_QUERY);
    2325           1 :     xCursor->jumpToLastPage();
    2326           2 :     CPPUNIT_ASSERT_EQUAL(sal_Int16(1), xCursor->getPage());
    2327           1 : }
    2328             : 
    2329          12 : DECLARE_OOXMLIMPORT_TEST(testBnc875718, "bnc875718.docx")
    2330             : {
    2331             :     // The frame in the footer must not accidentally end up in the document body.
    2332             :     // The easiest way for this to test I've found is checking that
    2333             :     // xray ThisComponent.TextFrames.GetByIndex( index ).Anchor.Text.ImplementationName
    2334             :     // is not SwXBodyText but rather SwXHeadFootText
    2335           1 :     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(mxComponent, uno::UNO_QUERY);
    2336           2 :     uno::Reference<container::XIndexAccess> xIndexAccess(xTextFramesSupplier->getTextFrames(), uno::UNO_QUERY);
    2337           6 :     for( int i = 0;
    2338           3 :          i < xIndexAccess->getCount();
    2339             :          ++i )
    2340             :     {
    2341           2 :         uno::Reference<text::XTextFrame> frame(xIndexAccess->getByIndex( i ), uno::UNO_QUERY);
    2342           4 :         uno::Reference<text::XTextRange> range(frame->getAnchor(), uno::UNO_QUERY);
    2343           4 :         uno::Reference<lang::XServiceInfo> text(range->getText(), uno::UNO_QUERY);
    2344           2 :         CPPUNIT_ASSERT_EQUAL( OUString( "SwXHeadFootText" ), text->getImplementationName());
    2345           2 :     }
    2346             :     // Also check that the footer contents are not in the body text.
    2347           2 :     uno::Reference<text::XTextDocument> textDocument(mxComponent, uno::UNO_QUERY);
    2348           2 :     uno::Reference<text::XText> text(textDocument->getText(), uno::UNO_QUERY);
    2349           2 :     CPPUNIT_ASSERT_EQUAL( OUString( "Text" ), text->getString());
    2350           1 : }
    2351             : 
    2352          12 : DECLARE_OOXMLIMPORT_TEST(testCaption, "caption.docx")
    2353             : {
    2354           1 :     uno::Reference<beans::XPropertySet> xStyle(getStyles("ParagraphStyles")->getByName("Caption"), uno::UNO_QUERY);
    2355             :     // This was awt::FontSlant_ITALIC: Writer default was used instead of what is in the document.
    2356           1 :     CPPUNIT_ASSERT_EQUAL(awt::FontSlant_NONE, getProperty<awt::FontSlant>(xStyle, "CharPosture"));
    2357           1 : }
    2358             : 
    2359          12 : DECLARE_OOXMLIMPORT_TEST(testGroupshapeTrackedchanges, "groupshape-trackedchanges.docx")
    2360             : {
    2361           1 :     uno::Reference<drawing::XShapes> xGroup(getShape(1), uno::UNO_QUERY);
    2362           2 :     uno::Reference<text::XTextRange> xShape(xGroup->getByIndex(0), uno::UNO_QUERY);
    2363             :     // Shape text was completely missing, ensure inserted text is available.
    2364           2 :     CPPUNIT_ASSERT_EQUAL(OUString(" Inserted"), xShape->getString());
    2365           1 : }
    2366             : 
    2367          12 : DECLARE_OOXMLIMPORT_TEST(testFdo78939, "fdo78939.docx")
    2368             : {
    2369             :     // fdo#78939 : LO hanged while opening issue document
    2370             : 
    2371             :     // Whenever a para-style was applied to a Numbering format level,
    2372             :     // LO incorrectly also changed the para-style..
    2373             : 
    2374             :     // check that file opens and does not hang while opening and also
    2375             :     // check that an incorrect numbering style is not applied ...
    2376           1 :     CPPUNIT_ASSERT_EQUAL(OUString(), getProperty<OUString>(getParagraph(1), "NumberingStyleName"));
    2377           1 : }
    2378             : 
    2379          12 : DECLARE_OOXMLIMPORT_TEST(testFootnote, "footnote.docx")
    2380             : {
    2381           1 :     uno::Reference<text::XFootnotesSupplier> xFootnotesSupplier(mxComponent, uno::UNO_QUERY);
    2382           2 :     uno::Reference<container::XIndexAccess> xFootnotes(xFootnotesSupplier->getFootnotes(), uno::UNO_QUERY);
    2383           2 :     uno::Reference<text::XTextRange> xFootnote(xFootnotes->getByIndex(0), uno::UNO_QUERY);
    2384           2 :     OUString aFootnote = xFootnote->getString();
    2385             :     // Ensure there are no additional newlines after "bar".
    2386           2 :     CPPUNIT_ASSERT(aFootnote.endsWith("bar"));
    2387           1 : }
    2388             : 
    2389          12 : DECLARE_OOXMLIMPORT_TEST(testTableBtlrCenter, "table-btlr-center.docx")
    2390             : {
    2391           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    2392           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables(), uno::UNO_QUERY);
    2393           2 :     uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0), uno::UNO_QUERY);
    2394             :     // Cell vertical alignment was NONE, should be CENTER.
    2395           2 :     CPPUNIT_ASSERT_EQUAL(text::VertOrientation::CENTER, getProperty<sal_Int16>(xTable->getCellByName("A2"), "VertOrient"));
    2396           1 : }
    2397             : 
    2398          12 : DECLARE_OOXMLIMPORT_TEST(testFdo80555, "fdo80555.docx")
    2399             : {
    2400           1 :     uno::Reference<drawing::XShape> xShape = getShape(1);
    2401             :     // Shape was wrongly placed at X=0, Y=0
    2402           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(3318), xShape->getPosition().X);
    2403           1 :     CPPUNIT_ASSERT_EQUAL(sal_Int32(247), xShape->getPosition().Y);
    2404           1 : }
    2405             : 
    2406          12 : DECLARE_OOXMLIMPORT_TEST(testFdo76803, "fdo76803.docx")
    2407             : {
    2408             :     // The ContourPolyPolygon was wrong
    2409           1 :     uno::Reference<beans::XPropertySet> xPropertySet(getShape(1), uno::UNO_QUERY);
    2410             : 
    2411           2 :     drawing::PointSequenceSequence rContour = getProperty<drawing::PointSequenceSequence>(xPropertySet, "ContourPolyPolygon");
    2412           2 :     basegfx::B2DPolyPolygon aPolyPolygon(basegfx::tools::UnoPointSequenceSequenceToB2DPolyPolygon(rContour));
    2413             : 
    2414             :     // We've got exactly one polygon inside
    2415           1 :     CPPUNIT_ASSERT_EQUAL(sal_uInt32(1), aPolyPolygon.count());
    2416             : 
    2417             :     // Now check it deeply
    2418           2 :     basegfx::B2DPolygon aPolygon(aPolyPolygon.getB2DPolygon(0));
    2419             : 
    2420           1 :     CPPUNIT_ASSERT_EQUAL(sal_uInt32(4), aPolygon.count());
    2421             : 
    2422           1 :     CPPUNIT_ASSERT_EQUAL(double(-163), aPolygon.getB2DPoint(0).getX());
    2423           1 :     CPPUNIT_ASSERT_EQUAL(double(0), aPolygon.getB2DPoint(0).getY());
    2424             : 
    2425           1 :     CPPUNIT_ASSERT_EQUAL(double(-163), aPolygon.getB2DPoint(1).getX());
    2426           1 :     CPPUNIT_ASSERT_EQUAL(double(3661), aPolygon.getB2DPoint(1).getY());
    2427             : 
    2428           1 :     CPPUNIT_ASSERT_EQUAL(double(16988), aPolygon.getB2DPoint(2).getX());
    2429           1 :     CPPUNIT_ASSERT_EQUAL(double(3661), aPolygon.getB2DPoint(2).getY());
    2430             : 
    2431           1 :     CPPUNIT_ASSERT_EQUAL(double(16988), aPolygon.getB2DPoint(3).getX());
    2432           2 :     CPPUNIT_ASSERT_EQUAL(double(0), aPolygon.getB2DPoint(3).getY());
    2433           1 : }
    2434             : 
    2435          12 : DECLARE_OOXMLIMPORT_TEST(testUnbalancedColumns, "unbalanced-columns.docx")
    2436             : {
    2437           1 :     uno::Reference<text::XTextSectionsSupplier> xTextSectionsSupplier(mxComponent, uno::UNO_QUERY);
    2438           2 :     uno::Reference<container::XIndexAccess> xTextSections(xTextSectionsSupplier->getTextSections(), uno::UNO_QUERY);
    2439             :     // This was false, last section was balanced, but it's unbalanced in Word.
    2440           2 :     CPPUNIT_ASSERT_EQUAL(true, getProperty<bool>(xTextSections->getByIndex(2), "DontBalanceTextColumns"));
    2441           1 : }
    2442             : 
    2443          12 : DECLARE_OOXMLIMPORT_TEST(testUnbalancedColumnsCompat, "unbalanced-columns-compat.docx")
    2444             : {
    2445           1 :     uno::Reference<text::XTextSectionsSupplier> xTextSectionsSupplier(mxComponent, uno::UNO_QUERY);
    2446           2 :     uno::Reference<container::XIndexAccess> xTextSections(xTextSectionsSupplier->getTextSections(), uno::UNO_QUERY);
    2447             :     // This was false, we ignored the relevant compat setting to make this non-last section unbalanced.
    2448           2 :     CPPUNIT_ASSERT_EQUAL(true, getProperty<bool>(xTextSections->getByIndex(0), "DontBalanceTextColumns"));
    2449           1 : }
    2450             : 
    2451          12 : DECLARE_OOXMLIMPORT_TEST(testFloatingTableSectionColumns, "floating-table-section-columns.docx")
    2452             : {
    2453           1 :     OUString tableWidth = parseDump("/root/page[1]/body/section/column[2]/body/txt/anchored/fly/tab/infos/bounds", "width");
    2454             :     // table width was restricted by a column
    2455           1 :     CPPUNIT_ASSERT( tableWidth.toInt32() > 10000 );
    2456           1 : }
    2457             : 
    2458          12 : DECLARE_OOXMLIMPORT_TEST(testHidemark, "hidemark.docx")
    2459             : {
    2460             :     // Problem was that <w:hideMark> cell property was ignored.
    2461           1 :     uno::Reference<text::XTextTablesSupplier> xTablesSupplier(mxComponent, uno::UNO_QUERY);
    2462           2 :     uno::Reference<container::XIndexAccess> xTables(xTablesSupplier->getTextTables( ), uno::UNO_QUERY);
    2463           2 :     uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0), uno::UNO_QUERY);
    2464           2 :     uno::Reference<table::XTableRows> xTableRows(xTextTable->getRows(), uno::UNO_QUERY);
    2465             :     // Height should be minimal
    2466           1 :     CPPUNIT_ASSERT_EQUAL(convertTwipToMm100(MINLAY), getProperty<sal_Int64>(xTableRows->getByIndex(1), "Height"));
    2467             :     // Size type was MIN, should be FIX to avoid considering the end of paragraph marker.
    2468           2 :     CPPUNIT_ASSERT_EQUAL(text::SizeType::FIX, getProperty<sal_Int16>(xTableRows->getByIndex(1), "SizeType"));
    2469           1 : }
    2470             : 
    2471          12 : DECLARE_OOXMLIMPORT_TEST(testBnc519228OddBreaks, "bnc519228_odd-breaks.docx")
    2472             : {
    2473             :     // Check that all the normal styles are not set as right-only, those should be only those used after odd page breaks.
    2474           1 :     uno::Reference<beans::XPropertySet> defaultStyle(getStyles("PageStyles")->getByName(DEFAULT_STYLE), uno::UNO_QUERY);
    2475           1 :     CPPUNIT_ASSERT_EQUAL(uno::makeAny(style::PageStyleLayout_ALL), defaultStyle->getPropertyValue("PageStyleLayout"));
    2476           2 :     uno::Reference<beans::XPropertySet> firstPage( getStyles("PageStyles")->getByName("First Page"), uno::UNO_QUERY );
    2477           1 :     CPPUNIT_ASSERT_EQUAL(uno::makeAny(style::PageStyleLayout_ALL), firstPage->getPropertyValue("PageStyleLayout"));
    2478             : 
    2479           2 :     OUString page1StyleName = getProperty<OUString>( getParagraph( 1, "This is the first page." ), "PageDescName");
    2480           2 :     uno::Reference<beans::XPropertySet> page1Style(getStyles("PageStyles")->getByName(page1StyleName), uno::UNO_QUERY);
    2481           1 :     CPPUNIT_ASSERT_EQUAL(uno::makeAny(style::PageStyleLayout_RIGHT), page1Style->getPropertyValue("PageStyleLayout"));
    2482           1 :     getParagraphOfText( 1, getProperty< uno::Reference<text::XText> >(page1Style, "HeaderText"), "This is the header for odd pages");
    2483             : 
    2484             :     // Page2 comes from follow of style for page 1 and should be a normal page. Also check the two page style have the same properties,
    2485             :     // since page style for page1 was created from page style for page 2.
    2486             :     uno::Any page2StyleAny = uno::Reference<beans::XPropertySet>(
    2487             :         getParagraph(3, "This is page 2, which is obviously an even page."),
    2488           2 :         uno::UNO_QUERY_THROW)->getPropertyValue("PageDescName");
    2489           1 :     CPPUNIT_ASSERT_EQUAL(uno::Any(), page2StyleAny);
    2490           2 :     OUString page2StyleName = getProperty<OUString>( page1Style, "FollowStyle" );
    2491           2 :     uno::Reference<beans::XPropertySet> page2Style(getStyles("PageStyles")->getByName(page2StyleName), uno::UNO_QUERY);
    2492           1 :     CPPUNIT_ASSERT_EQUAL(uno::makeAny(style::PageStyleLayout_ALL), page2Style->getPropertyValue("PageStyleLayout"));
    2493           1 :     getParagraphOfText( 1, getProperty< uno::Reference<text::XText> >(page2Style, "HeaderTextLeft"), "This is the even header");
    2494           1 :     getParagraphOfText( 1, getProperty< uno::Reference<text::XText> >(page2Style, "HeaderTextRight"), "This is the header for odd pages");
    2495           1 :     CPPUNIT_ASSERT_EQUAL(getProperty<sal_Int32>(page1Style, "TopMargin"), getProperty<sal_Int32>(page2Style, "TopMargin"));
    2496             : 
    2497           2 :     OUString page5StyleName = getProperty<OUString>( getParagraph( 5, "Then an odd break after an odd page, should lead us to page #5." ), "PageDescName");
    2498           2 :     uno::Reference<beans::XPropertySet> page5Style(getStyles("PageStyles")->getByName(page5StyleName), uno::UNO_QUERY);
    2499           1 :     CPPUNIT_ASSERT_EQUAL(uno::makeAny(style::PageStyleLayout_RIGHT), page5Style->getPropertyValue("PageStyleLayout"));
    2500           2 :     getParagraphOfText( 1, getProperty< uno::Reference<text::XText> >(page5Style, "HeaderText"), "This is the header for odd pages");
    2501           1 : }
    2502             : 
    2503          12 : DECLARE_OOXMLIMPORT_TEST(testBnc891663, "bnc891663.docx")
    2504             : {
    2505             :     // The image should be inside a cell, so the text in the following cell should be below it.
    2506           1 :     int imageTop = parseDump("/root/page/body/tab/row[1]/cell[2]/txt[1]/anchored/fly/infos/bounds", "top").toInt32();
    2507           1 :     int imageHeight = parseDump("/root/page/body/tab/row[1]/cell[2]/txt[1]/anchored/fly/infos/bounds", "height").toInt32();
    2508           1 :     int textNextRowTop = parseDump("/root/page/body/tab/row[2]/cell[1]/txt[1]/infos/bounds", "top").toInt32();
    2509           1 :     CPPUNIT_ASSERT( textNextRowTop >= imageTop + imageHeight );
    2510           1 : }
    2511             : 
    2512           5 : static OString dateTimeToString( const util::DateTime& dt )
    2513             : {
    2514           5 :     return DateTimeToOString( DateTime( Date( dt.Day, dt.Month, dt.Year ), tools::Time( dt.Hours, dt.Minutes, dt.Seconds )));
    2515             : }
    2516             : 
    2517          12 : DECLARE_OOXMLIMPORT_TEST(testTcwRounding, "tcw-rounding.docx")
    2518             : {
    2519             :     // Width of the A1 cell in twips was 3200, due to a rounding error.
    2520           1 :     CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(3201),  parseDump("/root/page/body/tab/row/cell[1]/infos/bounds", "width").toInt32());
    2521           1 : }
    2522             : 
    2523          12 : DECLARE_OOXMLIMPORT_TEST(testBnc821804, "bnc821804.docx")
    2524             : {
    2525           1 :     CPPUNIT_ASSERT_EQUAL( OUString( "TITLE" ), getRun( getParagraph( 1 ), 1 )->getString());
    2526           1 :     CPPUNIT_ASSERT(!hasProperty(getRun(getParagraph(1), 1), "RedlineType"));
    2527             :     // Redline information (SwXRedlinePortion) are separate "runs" apparently.
    2528           1 :     CPPUNIT_ASSERT(hasProperty(getRun(getParagraph(1), 2), "RedlineType"));
    2529           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(1), 2), "RedlineType"));
    2530           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(1), 2), "IsStart"));
    2531           1 :     CPPUNIT_ASSERT_EQUAL(OUString("unknown1"),getProperty<OUString>(getRun(getParagraph(1), 2), "RedlineAuthor"));
    2532           1 :     CPPUNIT_ASSERT_EQUAL(OString("2006-08-29T09:46:00Z"),dateTimeToString(getProperty<util::DateTime>(getRun(getParagraph(1), 2), "RedlineDateTime")));
    2533             :     // So only the 3rd run is actual text (and the two runs have been merged into one, not sure why, but that shouldn't be a problem).
    2534           1 :     CPPUNIT_ASSERT_EQUAL(OUString(" (1st run of an insert) (2nd run of an insert)"), getRun(getParagraph(1),3)->getString());
    2535           1 :     CPPUNIT_ASSERT(!hasProperty(getRun(getParagraph(1), 3), "RedlineType"));
    2536             :     // And the end SwXRedlinePortion of the redline.
    2537           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(1), 4), "RedlineType"));
    2538           1 :     CPPUNIT_ASSERT_EQUAL(OUString("unknown1"),getProperty<OUString>(getRun(getParagraph(1), 4), "RedlineAuthor"));
    2539           1 :     CPPUNIT_ASSERT_EQUAL(OString("2006-08-29T09:46:00Z"),dateTimeToString(getProperty<util::DateTime>(getRun(getParagraph(1), 4), "RedlineDateTime")));
    2540           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(1), 4), "IsStart"));
    2541             : 
    2542           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Normal text"), getRun(getParagraph(2),1)->getString());
    2543           1 :     CPPUNIT_ASSERT(!hasProperty(getRun(getParagraph(2), 1), "RedlineType"));
    2544             : 
    2545           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Delete"),getProperty<OUString>(getRun(getParagraph(3), 1), "RedlineType"));
    2546           1 :     CPPUNIT_ASSERT_EQUAL(OUString("unknown2"),getProperty<OUString>(getRun(getParagraph(3), 1), "RedlineAuthor"));
    2547           1 :     CPPUNIT_ASSERT_EQUAL(OString("2006-08-29T09:47:00Z"),dateTimeToString(getProperty<util::DateTime>(getRun(getParagraph(3), 1), "RedlineDateTime")));
    2548           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Deleted"), getRun(getParagraph(3),2)->getString());
    2549             : 
    2550             :     // This is both inserted and formatted, so there are two SwXRedlinePortion "runs". Given that the redlines overlap and Writer core
    2551             :     // doesn't officially expect that (even though it copes, the redline info will be split depending on how Writer deal with it).
    2552           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(4), 1), "RedlineType"));
    2553           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(4), 1), "IsStart"));
    2554           1 :     CPPUNIT_ASSERT_EQUAL(OUString("ParagraphFormat"),getProperty<OUString>(getRun(getParagraph(4), 2), "RedlineType"));
    2555           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(4), 2), "IsStart"));
    2556           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Inserted and formatted"), getRun(getParagraph(4),3)->getString());
    2557           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(4), 4), "RedlineType"));
    2558           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(4), 4), "IsStart"));
    2559           1 :     CPPUNIT_ASSERT_EQUAL(OUString(" and this is only formatted"), getRun(getParagraph(4),5)->getString());
    2560           1 :     CPPUNIT_ASSERT_EQUAL(OUString("ParagraphFormat"),getProperty<OUString>(getRun(getParagraph(4), 6), "RedlineType"));
    2561           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(4), 6), "IsStart"));
    2562             : 
    2563           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Normal text"), getRun(getParagraph(5),1)->getString());
    2564           1 :     CPPUNIT_ASSERT(!hasProperty(getRun(getParagraph(5), 1), "RedlineType"));
    2565             : 
    2566           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Format"),getProperty<OUString>(getRun(getParagraph(6), 1), "RedlineType"));
    2567           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(6), 1), "IsStart"));
    2568           1 :     CPPUNIT_ASSERT_EQUAL(OUString("unknown5"),getProperty<OUString>(getRun(getParagraph(6), 1), "RedlineAuthor"));
    2569           1 :     CPPUNIT_ASSERT_EQUAL(OString("2006-08-29T10:02:00Z"),dateTimeToString(getProperty<util::DateTime>(getRun(getParagraph(6), 1), "RedlineDateTime")));
    2570           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Formatted run"), getRun(getParagraph(6),2)->getString());
    2571           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Format"),getProperty<OUString>(getRun(getParagraph(6), 3), "RedlineType"));
    2572           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(6), 3), "IsStart"));
    2573           1 :     CPPUNIT_ASSERT_EQUAL(OUString(" and normal text here "), getRun(getParagraph(6),4)->getString());
    2574           1 :     CPPUNIT_ASSERT(!hasProperty(getRun(getParagraph(6), 4), "RedlineType"));
    2575           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(6), 5), "RedlineType"));
    2576           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(6), 5), "IsStart"));
    2577           1 :     CPPUNIT_ASSERT_EQUAL(OUString("unknown6"),getProperty<OUString>(getRun(getParagraph(6), 5), "RedlineAuthor"));
    2578           1 :     CPPUNIT_ASSERT_EQUAL(OString("2006-08-29T09:48:00Z"),dateTimeToString(getProperty<util::DateTime>(getRun(getParagraph(6), 5), "RedlineDateTime")));
    2579           1 :     CPPUNIT_ASSERT_EQUAL(OUString("and inserted again"), getRun(getParagraph(6),6)->getString());
    2580           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(6), 7), "RedlineType"));
    2581           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(6), 7), "IsStart"));
    2582           1 :     CPPUNIT_ASSERT_EQUAL(OUString(" and normal text again "), getRun(getParagraph(6),8)->getString());
    2583           1 :     CPPUNIT_ASSERT(!hasProperty(getRun(getParagraph(6), 8), "RedlineType"));
    2584           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Format"),getProperty<OUString>(getRun(getParagraph(6), 9), "RedlineType"));
    2585           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(6), 9), "IsStart"));
    2586           1 :     CPPUNIT_ASSERT_EQUAL(OUString("unknown7"),getProperty<OUString>(getRun(getParagraph(6), 9), "RedlineAuthor"));
    2587           1 :     CPPUNIT_ASSERT_EQUAL(OUString("and formatted"), getRun(getParagraph(6),10)->getString());
    2588           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(6), 11), "IsStart"));
    2589           1 :     CPPUNIT_ASSERT_EQUAL(OUString(" and normal."), getRun(getParagraph(6),12)->getString());
    2590           1 :     CPPUNIT_ASSERT(!hasProperty(getRun(getParagraph(6), 12), "RedlineType"));
    2591             : 
    2592           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(7), 1), "RedlineType"));
    2593           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(7), 1), "IsStart"));
    2594           1 :     CPPUNIT_ASSERT_EQUAL(OUString("unknown8"),getProperty<OUString>(getRun(getParagraph(7), 1), "RedlineAuthor"));
    2595           1 :     CPPUNIT_ASSERT_EQUAL(OUString("One insert."), getRun(getParagraph(7),2)->getString());
    2596           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(7), 3), "RedlineType"));
    2597           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(7), 3), "IsStart"));
    2598           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(7), 4), "RedlineType"));
    2599           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(7), 4), "IsStart"));
    2600           1 :     CPPUNIT_ASSERT_EQUAL(OUString("unknown9"),getProperty<OUString>(getRun(getParagraph(7), 4), "RedlineAuthor"));
    2601           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Second insert."), getRun(getParagraph(7),5)->getString());
    2602           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Insert"),getProperty<OUString>(getRun(getParagraph(7), 6), "RedlineType"));
    2603           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(7), 6), "IsStart"));
    2604             : 
    2605             :     // Overlapping again.
    2606           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Delete"),getProperty<OUString>(getRun(getParagraph(8), 1), "RedlineType"));
    2607           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(8), 1), "IsStart"));
    2608           1 :     CPPUNIT_ASSERT_EQUAL(OUString("ParagraphFormat"),getProperty<OUString>(getRun(getParagraph(8), 2), "RedlineType"));
    2609           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(8), 2), "IsStart"));
    2610           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Deleted and formatted"), getRun(getParagraph(8),3)->getString());
    2611           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Delete"),getProperty<OUString>(getRun(getParagraph(8), 4), "RedlineType"));
    2612           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(8), 4), "IsStart"));
    2613           1 :     CPPUNIT_ASSERT_EQUAL(OUString(" and this is only formatted"), getRun(getParagraph(8),5)->getString());
    2614           1 :     CPPUNIT_ASSERT_EQUAL(OUString("ParagraphFormat"),getProperty<OUString>(getRun(getParagraph(8), 6), "RedlineType"));
    2615           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(8), 6), "IsStart"));
    2616             : 
    2617           1 :     CPPUNIT_ASSERT_EQUAL(OUString("Normal text"), getRun(getParagraph(9),1)->getString());
    2618           1 :     CPPUNIT_ASSERT(!hasProperty(getRun(getParagraph(9), 1), "RedlineType"));
    2619             : 
    2620           1 :     CPPUNIT_ASSERT_EQUAL(OUString("ParagraphFormat"),getProperty<OUString>(getRun(getParagraph(10), 1), "RedlineType"));
    2621           1 :     CPPUNIT_ASSERT_EQUAL(true,getProperty<bool>(getRun(getParagraph(10), 1), "IsStart"));
    2622           1 :     CPPUNIT_ASSERT_EQUAL(OUString("This is only formatted."), getRun(getParagraph(10),2)->getString());
    2623           1 :     CPPUNIT_ASSERT_EQUAL(OUString("ParagraphFormat"),getProperty<OUString>(getRun(getParagraph(10), 3), "RedlineType"));
    2624           1 :     CPPUNIT_ASSERT_EQUAL(false,getProperty<bool>(getRun(getParagraph(10), 3), "IsStart"));
    2625           1 : }
    2626             : 
    2627          12 : DECLARE_OOXMLIMPORT_TEST(testFdo85542, "fdo85542.docx")
    2628             : {
    2629           1 :     uno::Reference<text::XBookmarksSupplier> xBookmarksSupplier(mxComponent, uno::UNO_QUERY);
    2630           2 :     uno::Reference<container::XIndexAccess> xBookmarksByIdx(xBookmarksSupplier->getBookmarks(), uno::UNO_QUERY);
    2631           1 :     CPPUNIT_ASSERT_EQUAL(xBookmarksByIdx->getCount(), static_cast<sal_Int32>(3));
    2632           2 :     uno::Reference<container::XNameAccess> xBookmarksByName(xBookmarksSupplier->getBookmarks(), uno::UNO_QUERY);
    2633           1 :     CPPUNIT_ASSERT(xBookmarksByName->hasByName("B1"));
    2634           1 :     CPPUNIT_ASSERT(xBookmarksByName->hasByName("B2"));
    2635           1 :     CPPUNIT_ASSERT(xBookmarksByName->hasByName("B3"));
    2636             :     // B1
    2637           2 :     uno::Reference<text::XTextContent> xContent1(xBookmarksByName->getByName("B1"), uno::UNO_QUERY);
    2638           2 :     uno::Reference<text::XTextRange> xRange1(xContent1->getAnchor(), uno::UNO_QUERY);
    2639           1 :     CPPUNIT_ASSERT_EQUAL(xRange1->getString(), OUString("ABB"));
    2640             :     // B2
    2641           2 :     uno::Reference<text::XTextContent> xContent2(xBookmarksByName->getByName("B2"), uno::UNO_QUERY);
    2642           2 :     uno::Reference<text::XTextRange> xRange2(xContent2->getAnchor(), uno::UNO_QUERY);
    2643           1 :     CPPUNIT_ASSERT_EQUAL(xRange2->getString(), OUString("BBC"));
    2644             :     // B3 -- testing a collapsed bookmark
    2645           2 :     uno::Reference<text::XTextContent> xContent3(xBookmarksByName->getByName("B3"), uno::UNO_QUERY);
    2646           2 :     uno::Reference<text::XTextRange> xRange3(xContent3->getAnchor(), uno::UNO_QUERY);
    2647           1 :     CPPUNIT_ASSERT_EQUAL(xRange3->getString(), OUString(""));
    2648           2 :     uno::Reference<text::XText> xText(xRange3->getText( ), uno::UNO_QUERY);
    2649           2 :     uno::Reference<text::XTextCursor> xNeighborhoodCursor(xText->createTextCursor( ), uno::UNO_QUERY);
    2650           1 :     xNeighborhoodCursor->gotoRange(xRange3, false);
    2651           1 :     xNeighborhoodCursor->goLeft(1, false);
    2652           1 :     xNeighborhoodCursor->goRight(2, true);
    2653           2 :     uno::Reference<text::XTextRange> xTextNeighborhood(xNeighborhoodCursor, uno::UNO_QUERY);
    2654           2 :     CPPUNIT_ASSERT_EQUAL(xTextNeighborhood->getString(), OUString("AB"));
    2655           1 : }
    2656             : 
    2657          12 : DECLARE_OOXMLIMPORT_TEST(testChtOutlineNumberingOoxml, "chtoutline.docx")
    2658             : {
    2659           1 :     const sal_Unicode aExpectedPrefix[2] = { 0x7b2c, 0x0020 };
    2660           1 :     const sal_Unicode aExpectedSuffix[2] = { 0x0020, 0x7ae0 };
    2661           1 :     uno::Reference< text::XChapterNumberingSupplier > xChapterNumberingSupplier(mxComponent, uno::UNO_QUERY);
    2662           2 :     uno::Reference< container::XIndexAccess> xLevels(xChapterNumberingSupplier->getChapterNumberingRules());
    2663           2 :     uno::Sequence<beans::PropertyValue> aProps;
    2664           1 :     xLevels->getByIndex(0) >>= aProps; // 1st level
    2665             : 
    2666           2 :     OUString aSuffix,aPrefix;
    2667          14 :     for (int i = 0; i < aProps.getLength(); ++i)
    2668             :     {
    2669          13 :         const beans::PropertyValue& rProp = aProps[i];
    2670             : 
    2671          13 :         if (rProp.Name == "Suffix")
    2672           1 :             aSuffix = rProp.Value.get<OUString>();
    2673          13 :         if (rProp.Name == "Prefix")
    2674           1 :             aPrefix = rProp.Value.get<OUString>();
    2675             :     }
    2676           1 :     CPPUNIT_ASSERT_EQUAL(OUString(aExpectedPrefix,SAL_N_ELEMENTS(aExpectedPrefix)), aPrefix);
    2677           2 :     CPPUNIT_ASSERT_EQUAL(OUString(aExpectedSuffix,SAL_N_ELEMENTS(aExpectedSuffix)), aSuffix);
    2678           1 : }
    2679             : 
    2680          12 : DECLARE_OOXMLIMPORT_TEST(testFdo87488, "fdo87488.docx")
    2681             : {
    2682             :     // The shape on the right (index 0, CustomShape within a
    2683             :     // GroupShape) is rotated 90 degrees clockwise and contains text
    2684             :     // rotated 90 degrees anticlockwise.  Must be read with SmartArt
    2685             :     // enabled in preTest above, otherwise it gets converted to a
    2686             :     // StarView MetaFile.
    2687           1 :     uno::Reference<container::XIndexAccess> group(getShape(1), uno::UNO_QUERY);
    2688             :     {
    2689           1 :         uno::Reference<text::XTextRange> text(group->getByIndex(0), uno::UNO_QUERY);
    2690           1 :         CPPUNIT_ASSERT_EQUAL(OUString("text2"), text->getString());
    2691             :     }
    2692             :     {
    2693           1 :         uno::Reference<beans::XPropertySet> props(group->getByIndex(0), uno::UNO_QUERY);
    2694           2 :         CPPUNIT_ASSERT_EQUAL(props->getPropertyValue("RotateAngle"),
    2695           1 :                              uno::makeAny<sal_Int32>(270 * 100));
    2696           2 :         comphelper::SequenceAsHashMap geom(props->getPropertyValue("CustomShapeGeometry"));
    2697           2 :         CPPUNIT_ASSERT_EQUAL(sal_Int32(90), geom["TextPreRotateAngle"].get<sal_Int32>());
    2698           1 :     }
    2699           1 : }
    2700             : 
    2701          12 : DECLARE_OOXMLIMPORT_TEST(mathtype, "mathtype.docx")
    2702             : {
    2703           1 :     uno::Reference<text::XTextEmbeddedObjectsSupplier> xTextEmbeddedObjectsSupplier(mxComponent, uno::UNO_QUERY);
    2704           2 :     uno::Reference<container::XIndexAccess> xEmbeddedObjects(xTextEmbeddedObjectsSupplier->getEmbeddedObjects(), uno::UNO_QUERY);
    2705             :     // This failed as the Model property was empty.
    2706           2 :     auto xModel = getProperty< uno::Reference<lang::XServiceInfo> >(xEmbeddedObjects->getByIndex(0), "Model");
    2707           2 :     CPPUNIT_ASSERT(xModel->supportsService("com.sun.star.formula.FormulaProperties"));
    2708           1 : }
    2709             : 
    2710          12 : DECLARE_OOXMLIMPORT_TEST(testTdf8255, "tdf8255.docx")
    2711             : {
    2712           1 :     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
    2713           2 :     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xTextDocument, uno::UNO_QUERY);
    2714           2 :     uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
    2715             :     // This was 1: a full-page-wide multi-page floating table was imported as a TextFrame.
    2716           2 :     CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(0), xDrawPage->getCount());
    2717           1 : }
    2718             : 
    2719             : #endif
    2720             : 
    2721           4 : CPPUNIT_PLUGIN_IMPLEMENT();
    2722             : 
    2723             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11