sw/qa/unit/swmodeltestbase.cxx

   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 <swmodeltestbase.hxx>
  11
  12 #include <com/sun/star/container/XContentEnumerationAccess.hpp>
  13 #include <com/sun/star/document/XFilter.hpp>
  14 #include <com/sun/star/document/XImporter.hpp>
  15 #include <com/sun/star/text/XPageCursor.hpp>
  16 #include <com/sun/star/view/XSelectionSupplier.hpp>
  17 #include <com/sun/star/text/XTextTable.hpp>
  18 #include <com/sun/star/text/XTextViewCursorSupplier.hpp>
  19
  20 #include <comphelper/propertyvalue.hxx>
  21 #include <sfx2/docfile.hxx>
  22 #include <rtl/ustrbuf.hxx>
  23 #include <unotools/streamwrap.hxx>
  24 #include <unotools/ucbstreamhelper.hxx>
  25 #include <vcl/scheduler.hxx>
  26 #include <comphelper/configuration.hxx>
  27 #include <officecfg/Office/Writer.hxx>
  28
  29 #include <IDocumentLayoutAccess.hxx>
  30 #include <docsh.hxx>
  31 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  32 #include <rootfrm.hxx>
  33 #include <unotxdoc.hxx>
  34 #include <view.hxx>
  35 #include <viewsh.hxx>
  36
  37 using namespace css;
  38
  39 void SwModelTestBase::paste(std::u16string_view aFilename, OUString aInstance,
  40                             uno::Reference<text::XTextRange> const& xTextRange)
  41 {
  42     uno::Reference<document::XFilter> xFilter(m_xSFactory->createInstance(aInstance),
  43                                               uno::UNO_QUERY_THROW);
  44     uno::Reference<document::XImporter> xImporter(xFilter, uno::UNO_QUERY_THROW);
  45     xImporter->setTargetDocument(mxComponent);
  46     std::unique_ptr<SvStream> pStream = utl::UcbStreamHelper::CreateStream(
  47         m_directories.getURLFromSrc(u"/sw/qa/extras/") + aFilename, StreamMode::STD_READ);
  48     CPPUNIT_ASSERT_EQUAL(ERRCODE_NONE, pStream->GetError());
  49     uno::Reference<io::XStream> xStream(new utl::OStreamWrapper(std::move(pStream)));
  50     uno::Sequence aDescriptor{ comphelper::makePropertyValue("InputStream", xStream),
  51                                comphelper::makePropertyValue("InsertMode", true),
  52                                comphelper::makePropertyValue("TextInsertModeRange", xTextRange) };
  53     CPPUNIT_ASSERT(xFilter->filter(aDescriptor));
  54 }
  55
  56 SwModelTestBase::SwModelTestBase(const OUString& pTestDocumentPath, const OUString& pFilter)
  57     : UnoApiXmlTest(pTestDocumentPath)
  58     , mbExported(false)
  59     , mpXmlBuffer(nullptr)
  60     , mpFilter(pFilter)
  61     , mnStartTime(0)
  62 {
  63 }
  64
  65 void SwModelTestBase::executeImportTest(const char* filename, const char* pPassword)
  66 {
  67     maTempFile.EnableKillingFile(false);
  68     header();
  69     std::unique_ptr<Resetter> const pChanges(preTest(filename));
  70     loadURL(createFileURL(OUString::createFromAscii(filename)), pPassword);
  71     verify();
  72     finish();
  73     maTempFile.EnableKillingFile();
  74 }
  75
  76 void SwModelTestBase::executeLoadVerifyReloadVerify(const char* filename, const char* pPassword)
  77 {
  78     maTempFile.EnableKillingFile(false);
  79     header();
  80     std::unique_ptr<Resetter> const pChanges(preTest(filename));
  81     loadURL(createFileURL(OUString::createFromAscii(filename)), pPassword);
  82     verify();
  83     postLoad(filename);
  84     saveAndReload(mpFilter, pPassword);
  85     verify();
  86     finish();
  87     maTempFile.EnableKillingFile();
  88 }
  89
  90 void SwModelTestBase::executeLoadReloadVerify(const char* filename, const char* pPassword)
  91 {
  92     maTempFile.EnableKillingFile(false);
  93     header();
  94     std::unique_ptr<Resetter> const pChanges(preTest(filename));
  95     loadURL(createFileURL(OUString::createFromAscii(filename)), pPassword);
  96     postLoad(filename);
  97     saveAndReload(mpFilter, pPassword);
  98     verify();
  99     finish();
 100     maTempFile.EnableKillingFile();
 101 }
 102
 103 void SwModelTestBase::executeImportExport(const char* filename, const char* pPassword)
 104 {
 105     maTempFile.EnableKillingFile(false);
 106     header();
 107     std::unique_ptr<Resetter> const pChanges(preTest(filename));
 108     loadAndSave(filename, pPassword);
 109     maTempFile.EnableKillingFile(false);
 110     verify();
 111     finish();
 112     maTempFile.EnableKillingFile();
 113 }
 114
 115 void SwModelTestBase::dumpLayout(const uno::Reference<lang::XComponent>& rComponent)
 116 {
 117     // create the xml writer
 118     mpXmlBuffer = xmlBufferCreate();
 119     xmlTextWriterPtr pXmlWriter = xmlNewTextWriterMemory(mpXmlBuffer, 0);
 120     (void)xmlTextWriterStartDocument(pXmlWriter, nullptr, nullptr, nullptr);
 121
 122     // create the dump
 123     SwXTextDocument* pTextDoc = dynamic_cast<SwXTextDocument*>(rComponent.get());
 124     CPPUNIT_ASSERT(pTextDoc);
 125     SwDoc* pDoc = pTextDoc->GetDocShell()->GetDoc();
 126     SwRootFrame* pLayout = pDoc->getIDocumentLayoutAccess().GetCurrentLayout();
 127     pLayout->dumpAsXml(pXmlWriter);
 128
 129     // delete xml writer
 130     (void)xmlTextWriterEndDocument(pXmlWriter);
 131     xmlFreeTextWriter(pXmlWriter);
 132 }
 133
 134 void SwModelTestBase::discardDumpedLayout()
 135 {
 136     if (mpXmlBuffer)
 137     {
 138         xmlBufferFree(mpXmlBuffer);
 139         mpXmlBuffer = nullptr;
 140     }
 141 }
 142
 143 void SwModelTestBase::calcLayout()
 144 {
 145     getSwDoc()->getIDocumentLayoutAccess().GetCurrentViewShell()->CalcLayout();
 146 }
 147
 148 int SwModelTestBase::getLength() const { return getBodyText().getLength(); }
 149
 150 OUString SwModelTestBase::getBodyText() const
 151 {
 152     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
 153     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xTextDocument->getText(),
 154                                                                   uno::UNO_QUERY);
 155     uno::Reference<container::XEnumeration> xParaEnum = xParaEnumAccess->createEnumeration();
 156     OUStringBuffer aBuf;
 157     while (xParaEnum->hasMoreElements())
 158     {
 159         uno::Reference<container::XEnumerationAccess> xRangeEnumAccess(xParaEnum->nextElement(),
 160                                                                        uno::UNO_QUERY);
 161         uno::Reference<container::XEnumeration> xRangeEnum = xRangeEnumAccess->createEnumeration();
 162         while (xRangeEnum->hasMoreElements())
 163         {
 164             uno::Reference<text::XTextRange> xRange(xRangeEnum->nextElement(), uno::UNO_QUERY);
 165             aBuf.append(xRange->getString());
 166         }
 167     }
 168     return aBuf.makeStringAndClear();
 169 }
 170
 171 uno::Reference<container::XNameAccess> SwModelTestBase::getStyles(const OUString& aFamily)
 172 {
 173     uno::Reference<style::XStyleFamiliesSupplier> xStyleFamiliesSupplier(mxComponent,
 174                                                                          uno::UNO_QUERY);
 175     uno::Reference<container::XNameAccess> xStyleFamilies
 176         = xStyleFamiliesSupplier->getStyleFamilies();
 177     uno::Reference<container::XNameAccess> xStyleFamily(xStyleFamilies->getByName(aFamily),
 178                                                         uno::UNO_QUERY);
 179     return xStyleFamily;
 180 }
 181
 182 uno::Reference<style::XAutoStyleFamily> SwModelTestBase::getAutoStyles(const OUString& aFamily)
 183 {
 184     uno::Reference<style::XAutoStylesSupplier> xAutoStylesSupplier(mxComponent, uno::UNO_QUERY);
 185     uno::Reference<style::XAutoStyles> xAutoStyles(xAutoStylesSupplier->getAutoStyles());
 186     uno::Reference<style::XAutoStyleFamily> xAutoStyleFamily(xAutoStyles->getByName(aFamily),
 187                                                              uno::UNO_QUERY);
 188     return xAutoStyleFamily;
 189 }
 190
 191 xmlDocUniquePtr SwModelTestBase::parseLayoutDump()
 192 {
 193     if (!mpXmlBuffer)
 194         dumpLayout(mxComponent);
 195
 196     auto pBuffer = reinterpret_cast<const char*>(xmlBufferContent(mpXmlBuffer));
 197     SAL_INFO("sw.qa", "SwModelTestBase::parseLayoutDump: pBuffer is '" << pBuffer << "'");
 198     return xmlDocUniquePtr(xmlParseMemory(pBuffer, xmlBufferLength(mpXmlBuffer)));
 199 }
 200
 201 OUString SwModelTestBase::parseDump(const OString& aXPath, const OString& aAttribute)
 202 {
 203     xmlDocUniquePtr pXmlDoc = parseLayoutDump();
 204
 205     xmlXPathContextPtr pXmlXpathCtx = xmlXPathNewContext(pXmlDoc.get());
 206     xmlXPathObjectPtr pXmlXpathObj
 207         = xmlXPathEvalExpression(BAD_CAST(aXPath.getStr()), pXmlXpathCtx);
 208     CPPUNIT_ASSERT_MESSAGE("xpath evaluation failed", pXmlXpathObj);
 209     xmlChar* pXpathStrResult;
 210     if (pXmlXpathObj->type == XPATH_NODESET)
 211     {
 212         xmlNodeSetPtr pXmlNodes = pXmlXpathObj->nodesetval;
 213         CPPUNIT_ASSERT_EQUAL_MESSAGE("xpath should match exactly 1 node", 1,
 214                                      xmlXPathNodeSetGetLength(pXmlNodes));
 215         xmlNodePtr pXmlNode = pXmlNodes->nodeTab[0];
 216         if (aAttribute.getLength())
 217             pXpathStrResult = xmlGetProp(pXmlNode, BAD_CAST(aAttribute.getStr()));
 218         else
 219             pXpathStrResult = xmlNodeGetContent(pXmlNode);
 220     }
 221     else
 222     {
 223         // the xpath expression evaluated to a value, not a node
 224         CPPUNIT_ASSERT_EQUAL_MESSAGE("attr name should not be supplied when xpath evals to a value",
 225                                      sal_Int32(0), aAttribute.getLength());
 226         pXpathStrResult = xmlXPathCastToString(pXmlXpathObj);
 227         CPPUNIT_ASSERT_MESSAGE("xpath result cannot be cast to string", pXpathStrResult);
 228     }
 229
 230     OUString aRet(reinterpret_cast<char*>(pXpathStrResult), xmlStrlen(pXpathStrResult),
 231                   RTL_TEXTENCODING_UTF8);
 232     xmlFree(pXpathStrResult);
 233     xmlFree(pXmlXpathObj);
 234     xmlFree(pXmlXpathCtx);
 235
 236     return aRet;
 237 }
 238
 239 bool SwModelTestBase::hasProperty(const uno::Reference<uno::XInterface>& obj,
 240                                   const OUString& name) const
 241 {
 242     uno::Reference<beans::XPropertySet> properties(obj, uno::UNO_QUERY_THROW);
 243     return properties->getPropertySetInfo()->hasPropertyByName(name);
 244 }
 245
 246 xml::AttributeData SwModelTestBase::getUserDefineAttribute(const uno::Any& obj,
 247                                                            const OUString& name,
 248                                                            const OUString& rValue) const
 249 {
 250     uno::Reference<container::XNameContainer> attrsCnt(
 251         getProperty<uno::Any>(obj, "UserDefinedAttributes"), uno::UNO_QUERY_THROW);
 252
 253     xml::AttributeData aValue;
 254     attrsCnt->getByName(name) >>= aValue;
 255     if (!rValue.isEmpty())
 256         CPPUNIT_ASSERT_EQUAL_MESSAGE("attribute of cell does not contain expected value", rValue,
 257                                      aValue.Value);
 258
 259     return aValue;
 260 }
 261
 262 int SwModelTestBase::getParagraphs(uno::Reference<text::XText> const& xText)
 263 {
 264     int nRet = 0;
 265     if (!xText.is())
 266         return nRet;
 267
 268     uno::Reference<container::XEnumerationAccess> xParaEnumAccess(xText->getText(), uno::UNO_QUERY);
 269     uno::Reference<container::XEnumeration> xParaEnum = xParaEnumAccess->createEnumeration();
 270     while (xParaEnum->hasMoreElements())
 271     {
 272         xParaEnum->nextElement();
 273         nRet++;
 274     }
 275     return nRet;
 276 }
 277
 278 int SwModelTestBase::getParagraphs()
 279 {
 280     uno::Reference<text::XTextDocument> xTextDocument(mxComponent, uno::UNO_QUERY);
 281     return getParagraphs(xTextDocument->getText());
 282 }
 283
 284 uno::Reference<text::XTextContent>
 285 SwModelTestBase::getParagraphOrTable(int number, uno::Reference<text::XText> const& xText) const
 286 {
 287     assert(number != 0); // this thing is 1-based
 288     uno::Reference<container::XEnumerationAccess> paraEnumAccess;
 289     if (xText.is())
 290         paraEnumAccess.set(xText, uno::UNO_QUERY);
 291     else
 292     {
 293         uno::Reference<text::XTextDocument> textDocument(mxComponent, uno::UNO_QUERY);
 294         paraEnumAccess.set(textDocument->getText(), uno::UNO_QUERY);
 295     }
 296     uno::Reference<container::XEnumeration> paraEnum = paraEnumAccess->createEnumeration();
 297     for (int i = 1; i < number; ++i)
 298         paraEnum->nextElement();
 299     uno::Reference<text::XTextContent> const xElem(paraEnum->nextElement(), uno::UNO_QUERY_THROW);
 300     return xElem;
 301 }
 302
 303 uno::Reference<text::XTextRange> SwModelTestBase::getParagraph(int number,
 304                                                                const OUString& content) const
 305 {
 306     uno::Reference<text::XTextRange> const xParagraph(getParagraphOrTable(number),
 307                                                       uno::UNO_QUERY_THROW);
 308     if (!content.isEmpty())
 309         CPPUNIT_ASSERT_EQUAL_MESSAGE("paragraph does not have expected content", content,
 310                                      xParagraph->getString());
 311     return xParagraph;
 312 }
 313
 314 sal_Int16 SwModelTestBase::getNumberingTypeOfParagraph(int nPara)
 315 {
 316     sal_Int16 nNumberingType = -1;
 317     uno::Reference<text::XTextRange> xPara(getParagraph(nPara));
 318     uno::Reference<beans::XPropertySet> properties(xPara, uno::UNO_QUERY);
 319     bool isNumber = false;
 320     properties->getPropertyValue("NumberingIsNumber") >>= isNumber;
 321     if (isNumber)
 322     {
 323         uno::Reference<container::XIndexAccess> xLevels(
 324             properties->getPropertyValue("NumberingRules"), uno::UNO_QUERY);
 325         sal_Int16 nNumberingLevel = -1;
 326         properties->getPropertyValue("NumberingLevel") >>= nNumberingLevel;
 327         if (nNumberingLevel >= 0 && nNumberingLevel < xLevels->getCount())
 328         {
 329             uno::Sequence<beans::PropertyValue> aPropertyValue;
 330             xLevels->getByIndex(nNumberingLevel) >>= aPropertyValue;
 331             auto pProp = std::find_if(
 332                 std::cbegin(aPropertyValue), std::cend(aPropertyValue),
 333                 [](const beans::PropertyValue& rProp) { return rProp.Name == "NumberingType"; });
 334             if (pProp != std::cend(aPropertyValue))
 335                 nNumberingType = pProp->Value.get<sal_Int16>();
 336         }
 337     }
 338     return nNumberingType;
 339 }
 340
 341 uno::Reference<text::XTextRange>
 342 SwModelTestBase::getParagraphOfText(int number, uno::Reference<text::XText> const& xText,
 343                                     const OUString& content) const
 344 {
 345     uno::Reference<text::XTextRange> const xParagraph(getParagraphOrTable(number, xText),
 346                                                       uno::UNO_QUERY_THROW);
 347     if (!content.isEmpty())
 348         CPPUNIT_ASSERT_EQUAL_MESSAGE("paragraph does not contain expected content", content,
 349                                      xParagraph->getString());
 350     return xParagraph;
 351 }
 352
 353 uno::Reference<beans::XPropertySet>
 354 SwModelTestBase::getParagraphAnchoredObject(int const index,
 355                                             uno::Reference<text::XTextRange> const& xPara) const
 356 {
 357     uno::Reference<container::XContentEnumerationAccess> xContentEnumAccess(xPara, uno::UNO_QUERY);
 358     uno::Reference<container::XEnumeration> xContentEnum
 359         = xContentEnumAccess->createContentEnumeration("com.sun.star.text.TextContent");
 360     for (int i = 1; i < index; ++i)
 361     {
 362         xContentEnum->nextElement();
 363     }
 364     return uno::Reference<beans::XPropertySet>(xContentEnum->nextElement(), uno::UNO_QUERY);
 365 }
 366
 367 uno::Reference<text::XTextRange>
 368 SwModelTestBase::getRun(uno::Reference<text::XTextRange> const& xParagraph, int number,
 369                         const OUString& content) const
 370 {
 371     uno::Reference<container::XEnumerationAccess> xRunEnumAccess(xParagraph, uno::UNO_QUERY);
 372     uno::Reference<container::XEnumeration> xRunEnum = xRunEnumAccess->createEnumeration();
 373     for (int i = 1; i < number; ++i)
 374         xRunEnum->nextElement();
 375     uno::Reference<text::XTextRange> xRun(xRunEnum->nextElement(), uno::UNO_QUERY);
 376     if (!content.isEmpty())
 377         CPPUNIT_ASSERT_EQUAL_MESSAGE("run does not contain expected content", content,
 378                                      xRun->getString());
 379     return xRun;
 380 }
 381
 382 OUString SwModelTestBase::getFormula(uno::Reference<text::XTextRange> const& xRun) const
 383 {
 384     uno::Reference<container::XContentEnumerationAccess> xContentEnumAccess(xRun, uno::UNO_QUERY);
 385     uno::Reference<container::XEnumeration> xContentEnum
 386         = xContentEnumAccess->createContentEnumeration("");
 387     uno::Reference<beans::XPropertySet> xFormula(xContentEnum->nextElement(), uno::UNO_QUERY);
 388     return getProperty<OUString>(
 389         getProperty<uno::Reference<beans::XPropertySet>>(xFormula, "Model"), "Formula");
 390 }
 391
 392 uno::Reference<table::XCell>
 393 SwModelTestBase::getCell(uno::Reference<uno::XInterface> const& xTableIfc, OUString const& rCell,
 394                          OUString const& rContent)
 395 {
 396     uno::Reference<text::XTextTable> const xTable(xTableIfc, uno::UNO_QUERY_THROW);
 397     uno::Reference<table::XCell> const xCell(xTable->getCellByName(rCell), uno::UNO_SET_THROW);
 398     if (!rContent.isEmpty())
 399     {
 400         uno::Reference<text::XText> const xCellText(xCell, uno::UNO_QUERY_THROW);
 401         CPPUNIT_ASSERT_EQUAL_MESSAGE("cell does not contain expected content", rContent,
 402                                      xCellText->getString());
 403     }
 404     return xCell;
 405 }
 406
 407 uno::Reference<drawing::XShape> SwModelTestBase::getShape(int number)
 408 {
 409     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
 410     uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 411     uno::Reference<drawing::XShape> xShape(xDrawPage->getByIndex(number - 1), uno::UNO_QUERY);
 412     return xShape;
 413 }
 414
 415 void SwModelTestBase::selectShape(int number)
 416 {
 417     SwXTextDocument* pXTextDocument = dynamic_cast<SwXTextDocument*>(mxComponent.get());
 418     uno::Reference<view::XSelectionSupplier> xSelectionSupplier(
 419         pXTextDocument->getCurrentController(), uno::UNO_QUERY);
 420     xSelectionSupplier->select(uno::Any(getShape(number)));
 421     CPPUNIT_ASSERT(xSelectionSupplier->getSelection().hasValue());
 422
 423     SwDoc* pDoc = pXTextDocument->GetDocShell()->GetDoc();
 424     SwView* pView = pDoc->GetDocShell()->GetView();
 425     // Make sure SwTextShell is replaced with SwDrawShell right now, not after 120 ms, as set in the
 426     // SwView ctor.
 427     pView->StopShellTimer();
 428 }
 429
 430 uno::Reference<drawing::XShape> SwModelTestBase::getShapeByName(std::u16string_view aName)
 431 {
 432     uno::Reference<drawing::XShape> xRet;
 433
 434     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
 435     uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 436     for (sal_Int32 i = 0; i < xDrawPage->getCount(); ++i)
 437     {
 438         uno::Reference<container::XNamed> xShape(xDrawPage->getByIndex(i), uno::UNO_QUERY);
 439         if (xShape->getName() == aName)
 440         {
 441             xRet.set(xShape, uno::UNO_QUERY);
 442             break;
 443         }
 444     }
 445
 446     return xRet;
 447 }
 448
 449 uno::Reference<drawing::XShape> SwModelTestBase::getTextFrameByName(const OUString& aName)
 450 {
 451     uno::Reference<text::XTextFramesSupplier> xTextFramesSupplier(mxComponent, uno::UNO_QUERY);
 452     uno::Reference<container::XNameAccess> xNameAccess = xTextFramesSupplier->getTextFrames();
 453     uno::Reference<drawing::XShape> xShape(xNameAccess->getByName(aName), uno::UNO_QUERY);
 454     return xShape;
 455 }
 456
 457 void SwModelTestBase::header() {}
 458
 459 void SwModelTestBase::loadURL(OUString const& rURL, const char* pPassword)
 460 {
 461     // Output name at load time, so in the case of a hang, the name of the hanging input file is visible.
 462     if (!isExported())
 463     {
 464         std::cout << rURL << ":\n";
 465         mnStartTime = osl_getGlobalTimer();
 466     }
 467
 468     UnoApiXmlTest::load(rURL, pPassword);
 469
 470     CPPUNIT_ASSERT(!getSwDocShell()->GetMedium()->GetWarningError());
 471
 472     discardDumpedLayout();
 473     calcLayout();
 474 }
 475
 476 void SwModelTestBase::saveAndReload(const OUString& pFilter, const char* pPassword)
 477 {
 478     save(pFilter, pPassword);
 479     mbExported = true;
 480
 481     loadURL(maTempFile.GetURL(), pPassword);
 482 }
 483
 484 void SwModelTestBase::loadAndSave(const char* pName, const char* pPassword)
 485 {
 486     loadURL(createFileURL(OUString::createFromAscii(pName)), pPassword);
 487     save(mpFilter);
 488     mbExported = true;
 489 }
 490
 491 void SwModelTestBase::loadAndReload(const char* pName)
 492 {
 493     loadURL(createFileURL(OUString::createFromAscii(pName)));
 494     saveAndReload(mpFilter);
 495 }
 496
 497 void SwModelTestBase::finish()
 498 {
 499     sal_uInt32 nEndTime = osl_getGlobalTimer();
 500     std::cout << (nEndTime - mnStartTime) << std::endl;
 501     discardDumpedLayout();
 502 }
 503
 504 int SwModelTestBase::getPages() const
 505 {
 506     uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
 507     uno::Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(
 508         xModel->getCurrentController(), uno::UNO_QUERY);
 509     uno::Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(),
 510                                               uno::UNO_QUERY);
 511     xCursor->jumpToLastPage();
 512     return xCursor->getPage();
 513 }
 514
 515 int SwModelTestBase::getShapes() const
 516 {
 517     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
 518     uno::Reference<container::XIndexAccess> xDraws = xDrawPageSupplier->getDrawPage();
 519     return xDraws->getCount();
 520 }
 521
 522 xmlDocUniquePtr SwModelTestBase::parseExportedFile()
 523 {
 524     auto stream(SvFileStream(maTempFile.GetURL(), StreamMode::READ | StreamMode::TEMPORARY));
 525     return parseXmlStream(&stream);
 526 }
 527
 528 void SwModelTestBase::createSwDoc(const char* pName, const char* pPassword)
 529 {
 530     if (!pName)
 531         loadURL("private:factory/swriter");
 532     else
 533         loadURL(createFileURL(OUString::createFromAscii(pName)), pPassword);
 534
 535     uno::Reference<lang::XServiceInfo> xServiceInfo(mxComponent, uno::UNO_QUERY_THROW);
 536     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.text.TextDocument"));
 537 }
 538
 539 void SwModelTestBase::createSwWebDoc(const char* pName)
 540 {
 541     if (!pName)
 542         loadURL("private:factory/swriter/web");
 543     else
 544         loadURL(createFileURL(OUString::createFromAscii(pName)));
 545
 546     uno::Reference<lang::XServiceInfo> xServiceInfo(mxComponent, uno::UNO_QUERY_THROW);
 547     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.text.WebDocument"));
 548 }
 549
 550 void SwModelTestBase::createSwGlobalDoc(const char* pName)
 551 {
 552     if (!pName)
 553         loadURL("private:factory/swriter/GlobalDocument");
 554     else
 555         loadURL(createFileURL(OUString::createFromAscii(pName)));
 556
 557     uno::Reference<lang::XServiceInfo> xServiceInfo(mxComponent, uno::UNO_QUERY_THROW);
 558     CPPUNIT_ASSERT(xServiceInfo->supportsService("com.sun.star.text.GlobalDocument"));
 559 }
 560
 561 SwDoc* SwModelTestBase::getSwDoc() { return getSwDocShell()->GetDoc(); }
 562
 563 SwDocShell* SwModelTestBase::getSwDocShell()
 564 {
 565     SwXTextDocument* pTextDoc = dynamic_cast<SwXTextDocument*>(mxComponent.get());
 566     CPPUNIT_ASSERT(pTextDoc);
 567
 568     return pTextDoc->GetDocShell();
 569 }
 570
 571 xmlDocUniquePtr SwModelTestBase::WrapReqifFromTempFile()
 572 {
 573     SvMemoryStream aStream;
 574     aStream.WriteOString("<reqif-xhtml:html xmlns:reqif-xhtml=\"http://www.w3.org/1999/xhtml\">\n");
 575     SvFileStream aFileStream(maTempFile.GetURL(), StreamMode::READ);
 576     aStream.WriteStream(aFileStream);
 577     aStream.WriteOString("</reqif-xhtml:html>\n");
 578     aStream.Seek(0);
 579     xmlDocUniquePtr pXmlDoc = parseXmlStream(&aStream);
 580     // Make sure the output is well-formed.
 581     CPPUNIT_ASSERT(pXmlDoc);
 582     return pXmlDoc;
 583 }
 584
 585 void SwModelTestBase::WrapFromTempFile(SvMemoryStream& rStream)
 586 {
 587     SvFileStream aFileStream(maTempFile.GetURL(), StreamMode::READ);
 588     rStream.WriteStream(aFileStream);
 589     rStream.Seek(0);
 590 }
 591
 592 void SwModelTestBase::emulateTyping(SwXTextDocument& rTextDoc, const std::u16string_view& rStr)
 593 {
 594     for (const char16_t c : rStr)
 595     {
 596         rTextDoc.postKeyEvent(LOK_KEYEVENT_KEYINPUT, c, 0);
 597         rTextDoc.postKeyEvent(LOK_KEYEVENT_KEYUP, c, 0);
 598         Scheduler::ProcessEventsToIdle();
 599     }
 600 }
 601
 602 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */