sc/qa/perf/scperfobj.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 <sal/config.h>
  11
  12 #include <string_view>
  13
  14 #include <test/unoapi_test.hxx>
  15
  16 #include <rtl/ustring.hxx>
  17 #include <cppunit/extensions/HelperMacros.h>
  18 #include <comphelper/processfactory.hxx>
  19
  20 #include <com/sun/star/frame/Desktop.hpp>
  21 #include <com/sun/star/frame/XModel2.hpp>
  22
  23 #include <com/sun/star/util/XSearchable.hpp>
  24 #include <com/sun/star/util/XSearchDescriptor.hpp>
  25 #include <com/sun/star/container/XIndexAccess.hpp>
  26 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
  27 #include <com/sun/star/sheet/XSpreadsheet.hpp>
  28 #include <com/sun/star/sheet/XSpreadsheets.hpp>
  29
  30 #include <com/sun/star/beans/XPropertySet.hpp>
  31 #include <com/sun/star/sheet/XArrayFormulaRange.hpp>
  32 #include <com/sun/star/sheet/XCalculatable.hpp>
  33 #include <com/sun/star/table/XCellRange.hpp>
  34 #include <com/sun/star/sheet/XCellRangeFormula.hpp>
  35 #include <com/sun/star/sheet/XNamedRanges.hpp>
  36 #include <com/sun/star/table/XCell.hpp>
  37 #include <com/sun/star/table/CellAddress.hpp>
  38 #include <com/sun/star/table/CellRangeAddress.hpp>
  39 #include <com/sun/star/sheet/Border.hpp>
  40 #include <com/sun/star/sheet/XSubTotalCalculatable.hpp>
  41 #include <com/sun/star/sheet/SubTotalColumn.hpp>
  42 #include <com/sun/star/sheet/GeneralFunction.hpp>
  43
  44 #include <test/callgrind.hxx>
  45
  46 #include <calcconfig.hxx>
  47 #include <docsh.hxx>
  48 #include <tabvwsh.hxx>
  49
  50 using namespace css;
  51 using namespace css::uno;
  52
  53 namespace sc_apitest {
  54
  55 class ScPerfObj : public UnoApiTest
  56 {
  57 public:
  58
  59     ScPerfObj();
  60
  61     CPPUNIT_TEST_SUITE(ScPerfObj);
  62     CPPUNIT_TEST(testSheetFindAll);
  63     CPPUNIT_TEST(testFixedSum);
  64     CPPUNIT_TEST(testSheetNamedRanges);
  65     CPPUNIT_TEST(testSheets);
  66     CPPUNIT_TEST(testSum);
  67     CPPUNIT_TEST(testFTest);
  68     CPPUNIT_TEST(testChiTest);
  69     CPPUNIT_TEST(testSumX2PY2Test);
  70     CPPUNIT_TEST(testTTest);
  71     CPPUNIT_TEST(testLcm);
  72     CPPUNIT_TEST(testGcd);
  73     CPPUNIT_TEST(testPearson);
  74     CPPUNIT_TEST(testSubTotalWithFormulas);
  75     CPPUNIT_TEST(testSubTotalWithoutFormulas);
  76     CPPUNIT_TEST(testLoadingFileWithSingleBigSheet);
  77     CPPUNIT_TEST(testMatConcatSmall);
  78     CPPUNIT_TEST(testMatConcatLarge);
  79     CPPUNIT_TEST_SUITE_END();
  80
  81 private:
  82     // tests
  83     void testSheetFindAll();
  84     void testSheetNamedRanges();
  85     void testSheets();
  86     void testSum();
  87     void testFTest();
  88     void testChiTest();
  89     void testSumX2PY2Test();
  90     void testTTest();
  91     void testLcm();
  92     void testGcd();
  93     void testPearson();
  94     void testSubTotalWithFormulas();
  95     void testSubTotalWithoutFormulas();
  96     void testLoadingFileWithSingleBigSheet();
  97     void testFixedSum();
  98     void testMatConcatSmall();
  99     void testMatConcatLarge();
 100 };
 101
 102 ScPerfObj::ScPerfObj()
 103     : UnoApiTest("sc/qa/perf/testdocuments/")
 104 {
 105 }
 106
 107 void ScPerfObj::testSheetFindAll()
 108 {
 109     loadFromFile(u"scBigFile.ods");
 110     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 111
 112     // get sheet
 113     uno::Reference< container::XIndexAccess > xSheetIndex (xDoc->getSheets(), UNO_QUERY_THROW);
 114
 115     uno::Reference< sheet::XSpreadsheet > xSheet( xSheetIndex->getByIndex(0), UNO_QUERY_THROW);
 116
 117     // create descriptor
 118     uno::Reference< util::XSearchable > xSearchable(xSheet, UNO_QUERY_THROW);
 119     uno::Reference< util::XSearchDescriptor> xSearchDescr = xSearchable->createSearchDescriptor();
 120
 121     // search for a value
 122     xSearchDescr->setSearchString("value_1");
 123
 124     callgrindStart();
 125
 126     uno::Reference< container::XIndexAccess > xIndex = xSearchable->findAll(xSearchDescr);
 127
 128     callgrindDump("sc:search_all_sheets_by_value");
 129
 130     CPPUNIT_ASSERT(xIndex.is());
 131
 132     int nCount = xIndex->getCount();
 133
 134     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong Count" , 20000, nCount);
 135
 136     // search for style
 137     uno::Reference< sheet::XSpreadsheet > xSheet2( xSheetIndex->getByIndex(2), UNO_QUERY_THROW);
 138     uno::Reference< util::XSearchable > xSearchableStyle(xSheet2, UNO_QUERY_THROW);
 139     xSearchDescr = xSearchableStyle->createSearchDescriptor();
 140
 141     uno::Reference< beans::XPropertySet > xSearchProp(xSearchDescr,UNO_QUERY_THROW);
 142     xSearchProp->setPropertyValue("SearchStyles", Any(true));
 143
 144     xSearchDescr->setSearchString("aCellStyle");
 145
 146     callgrindStart();
 147
 148     uno::Reference< container::XIndexAccess > xIndex2 = xSearchableStyle->findAll(xSearchDescr);
 149
 150     callgrindDump("sc:search_all_sheets_by_style");
 151
 152     CPPUNIT_ASSERT(xIndex2.is());
 153
 154     nCount = xIndex2->getCount();
 155
 156     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong Count" , 160, nCount);
 157
 158 }
 159
 160 void ScPerfObj::testSheetNamedRanges()
 161 {
 162
 163     loadFromFile(u"scBigFile.ods");
 164     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 165
 166     // get NamedRanges
 167     uno::Reference< beans::XPropertySet > xPropSet (mxComponent, UNO_QUERY_THROW);
 168     uno::Reference< sheet::XNamedRanges > xNamedRanges(xPropSet->getPropertyValue("NamedRanges"), UNO_QUERY_THROW);
 169     uno::Reference< container::XIndexAccess > xIndexNamedRanges(xNamedRanges, UNO_QUERY_THROW);
 170
 171     // get sheet - named ranges are defined in sheet #1
 172     uno::Reference< container::XIndexAccess > xSheetIndex (xDoc->getSheets(), UNO_QUERY_THROW);
 173     uno::Reference< sheet::XSpreadsheet > xSheet( xSheetIndex->getByIndex(1), UNO_QUERY_THROW);
 174
 175     // test removeByName
 176     OUString maNameToRemove("namedRange_4999");
 177     bool bHasIt = xNamedRanges->hasByName(maNameToRemove);
 178     CPPUNIT_ASSERT_MESSAGE("NamedRange initial1 does not exist, can't remove it", bHasIt);
 179
 180     if (bHasIt)
 181     {
 182         callgrindStart();
 183         xNamedRanges->removeByName(maNameToRemove);
 184         callgrindDump("sc:remove_named_range_by_name");
 185     }
 186
 187     // test addNewByName
 188     table::CellAddress aBaseAddress(0, 0, 0);
 189
 190     sal_Int32 nType = 0;
 191     callgrindStart();
 192     xNamedRanges->addNewByName("single_added", "B4999", aBaseAddress, nType);
 193     callgrindDump("sc:add_named_range_by_name");
 194
 195     //test AddNewFromTitles with some 1000 new named ranges
 196     table::CellRangeAddress aCellRangeAddress(0, 1, 0, 2, 999);
 197     callgrindStart();
 198     xNamedRanges->addNewFromTitles(aCellRangeAddress, sheet::Border_LEFT);
 199     callgrindDump("sc:add_named_range_from_titles");
 200
 201 }
 202
 203 void ScPerfObj::testSheets()
 204 {
 205     loadFromFile(u"scBigFile.ods");
 206     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 207
 208     // get getSheets
 209     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 210
 211     OUString aSheetName = "NewSheet";
 212
 213     callgrindStart();
 214     xSheets->insertNewByName(aSheetName, 80);
 215     callgrindDump("sc:insert_new_sheet_by_name");
 216
 217     callgrindStart();
 218     xSheets->copyByName("aSheet_2", "aCopiedSheet", 70);
 219     callgrindDump("sc:copy_sheet_by_name");
 220
 221     uno::Reference< sheet::XSpreadsheets > xSheetsNameContainer (xSheets, UNO_SET_THROW);
 222
 223     callgrindStart();
 224     xSheetsNameContainer->removeByName(aSheetName);
 225     callgrindDump("sc:remove_sheet_by_name");
 226
 227 }
 228
 229 void ScPerfObj::testSum()
 230 {
 231     loadFromFile(u"scMathFunctions.ods");
 232     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 233
 234     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 235
 236     // get getSheets
 237     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 238
 239     uno::Any rSheet = xSheets->getByName("SumSheet");
 240
 241     // query for the XSpreadsheet interface
 242     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 243     uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(1, 0);
 244
 245
 246     callgrindStart();
 247     xCell->setFormula("=SUM(A1:A10000)");
 248     xCalculatable->calculate();
 249     callgrindDump("sc:sum_numbers_column");
 250
 251     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong Sum" , 504178.0, xCell->getValue());
 252
 253     // query for the XCellRange interface
 254     uno::Reference< table::XCellRange > rCellRange(rSheet, UNO_QUERY);
 255     // query the cell range
 256     uno::Reference< table::XCellRange > xCellRange = rCellRange->getCellRangeByName("B1");
 257
 258     uno::Reference< sheet::XArrayFormulaRange > xArrayFormulaRange(xCellRange, UNO_QUERY_THROW);
 259
 260     callgrindStart();
 261     xArrayFormulaRange->setArrayFormula("=SUM(A1:A10000=30)");
 262     xCalculatable->calculate();
 263     callgrindDump("sc:sum_with_array_formula_condition");
 264
 265     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong Sum - number of elements equal 30" , 99.0, xCell->getValue());
 266 }
 267
 268 void ScPerfObj::testFTest()
 269 {
 270     loadFromFile(u"scMathFunctions.ods");
 271     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 272
 273     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 274
 275     // get getSheets
 276     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 277
 278     uno::Any rSheet = xSheets->getByName("FTestSheet");
 279
 280     // query for the XSpreadsheet interface
 281     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 282     uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(0, 0);
 283
 284     callgrindStart();
 285     xCell->setFormula("=FTEST(B1:K10;L1:U10)");
 286     xCalculatable->calculate();
 287     callgrindDump("sc:ftest");
 288
 289     CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Wrong FTest result" , 0.8909, xCell->getValue(), 10e-4);
 290 }
 291
 292 void ScPerfObj::testChiTest()
 293 {
 294     loadFromFile(u"scMathFunctions.ods");
 295     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 296
 297     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 298
 299     // get getSheets
 300     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 301
 302     uno::Any rSheet = xSheets->getByName("ChiTestSheet");
 303
 304     // query for the XSpreadsheet interface
 305     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 306     uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(0, 0);
 307
 308     callgrindStart();
 309     xCell->setFormula("=CHITEST(B1:CV100;CW1:GQ100)");
 310     xCalculatable->calculate();
 311     callgrindDump("sc:chitest");
 312
 313     CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Wrong ChiTest result" , 0.0, xCell->getValue(), 10e-4);
 314 }
 315
 316 void ScPerfObj::testSumX2PY2Test()
 317 {
 318     loadFromFile(u"scMathFunctions2.ods");
 319     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 320
 321     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 322
 323     // get getSheets
 324     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 325
 326     uno::Any rSheet = xSheets->getByName("SumX2PY2Sheet");
 327
 328     // query for the XSpreadsheet interface
 329     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 330     uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(2, 0);
 331
 332     callgrindStart();
 333     xCell->setFormula("=SUMX2PY2(A1:A10000;B1:B10000)");
 334     xCalculatable->calculate();
 335     callgrindDump("sc:sumx2py2");
 336
 337     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong SumX2PY2 result" , 574539.0, xCell->getValue());
 338 }
 339
 340 void ScPerfObj::testTTest()
 341 {
 342     loadFromFile(u"scMathFunctions2.ods");
 343     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 344
 345     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 346
 347     // get getSheets
 348     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 349
 350     uno::Any rSheet = xSheets->getByName("TTestSheet");
 351
 352     // query for the XSpreadsheet interface
 353     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 354     uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(0, 0);
 355
 356     callgrindStart();
 357     xCell->setFormula("=T.TEST(B1:CV100;CW1:GQ100;2;1)");
 358     xCalculatable->calculate();
 359     callgrindDump("sc:ttest");
 360
 361     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong TTest result" , 0.0, xCell->getValue());
 362 }
 363
 364 void ScPerfObj::testLcm()
 365 {
 366     loadFromFile(u"scMathFunctions2.ods");
 367     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 368
 369     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 370
 371     // get getSheets
 372     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 373
 374     uno::Any rSheet = xSheets->getByName("LCMSheet");
 375
 376     // query for the XSpreadsheet interface
 377     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 378     uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(1, 0);
 379
 380     callgrindStart();
 381     xCell->setFormula("=LCM(A1:A10000)");
 382     xCalculatable->calculate();
 383     callgrindDump("sc:lcm");
 384
 385     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong LCM" , 2520.0, xCell->getValue());
 386 }
 387
 388 void ScPerfObj::testGcd()
 389 {
 390     loadFromFile(u"scMathFunctions2.ods");
 391     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 392
 393     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 394
 395     // get getSheets
 396     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 397
 398     uno::Any rSheet = xSheets->getByName("GCDSheet");
 399
 400     // query for the XSpreadsheet interface
 401     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 402     uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(1, 0);
 403
 404     callgrindStart();
 405     xCell->setFormula("=GCD(A1:A10000)");
 406     xCalculatable->calculate();
 407     callgrindDump("sc:gcd");
 408
 409     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong GCD", 3.0, xCell->getValue());
 410 }
 411
 412 void ScPerfObj::testPearson()
 413 {
 414     loadFromFile(u"scMathFunctions2.ods");
 415     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 416
 417     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 418
 419     // get getSheets
 420     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 421
 422     uno::Any rSheet = xSheets->getByName("PearsonSheet");
 423
 424     // query for the XSpreadsheet interface
 425     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 426     uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(0, 0);
 427
 428     callgrindStart();
 429     xCell->setFormula("=PEARSON(B1:CV100;CW1:GQ100)");
 430     xCalculatable->calculate();
 431     callgrindDump("sc:pearson");
 432
 433     CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Wrong Pearson result" , 0.01255, xCell->getValue(), 10e-4);
 434 }
 435
 436 void ScPerfObj::testSubTotalWithFormulas()
 437 {
 438     loadFromFile(u"scBigSingleSheet200.ods");
 439     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 440
 441     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 442
 443     // get getSheets
 444     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 445     uno::Any rSheet = xSheets->getByName("scBigSingleSheet");
 446
 447     // query for the XCellRange interface
 448     uno::Reference< table::XCellRange > rCellRange(rSheet, UNO_QUERY);
 449
 450     // query the cell range
 451     uno::Reference< table::XCellRange > xCellRange = rCellRange->getCellRangeByPosition(0,0,1023,1000000);
 452
 453     // Create the subtotal interface
 454     uno::Reference< sheet::XSubTotalCalculatable > xSub(xCellRange, UNO_QUERY_THROW);
 455     uno::Reference< sheet::XSubTotalDescriptor > xSubDesc = xSub->createSubTotalDescriptor(true);
 456
 457     // Create the column used for subtotal
 458     uno::Sequence < sheet::SubTotalColumn > xSubTotalColumns { { 1, sheet::GeneralFunction_SUM } };
 459
 460     xSubDesc->addNew(xSubTotalColumns, 0);
 461
 462     // Run the subtotal function
 463     callgrindStart();
 464     xSub->applySubTotals(xSubDesc, true);
 465     callgrindDump("sc:doSubTotal_on_large_sheet_with_formulas");
 466 }
 467
 468 void ScPerfObj::testSubTotalWithoutFormulas()
 469 {
 470     loadFromFile(u"scBigSingleSheet200.ods");
 471     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 472
 473     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 474
 475     // get getSheets
 476     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 477     uno::Any rSheet = xSheets->getByName("scBigSingleSheet");
 478
 479     // query for the XCellRange interface
 480     uno::Reference< table::XCellRange > rCellRange(rSheet, UNO_QUERY);
 481
 482     // query the cell range
 483     uno::Reference< table::XCellRange > xCellRange = rCellRange->getCellRangeByPosition(0,0,10,1000000);
 484
 485     // Create the subtotal interface
 486     uno::Reference< sheet::XSubTotalCalculatable > xSub(xCellRange, UNO_QUERY_THROW);
 487     uno::Reference< sheet::XSubTotalDescriptor > xSubDesc = xSub->createSubTotalDescriptor(true);
 488
 489     // Create the column used for subtotal
 490     uno::Sequence < sheet::SubTotalColumn> xSubTotalColumns { { 1, sheet::GeneralFunction_SUM } };
 491
 492     xSubDesc->addNew(xSubTotalColumns, 0);
 493
 494     // Run the subtotal function
 495     callgrindStart();
 496     xSub->applySubTotals(xSubDesc, true);
 497     callgrindDump("sc:doSubTotal_on_large_sheet_without_formulas");
 498 }
 499
 500 void ScPerfObj::testLoadingFileWithSingleBigSheet()
 501 {
 502     callgrindStart();
 503     loadFromFile(u"scBigSingleSheet2000.ods");
 504     uno::Reference< sheet::XSpreadsheetDocument > xDoc1(mxComponent, UNO_QUERY_THROW);
 505     uno::Reference< sheet::XCalculatable > xCalculatable1(xDoc1, UNO_QUERY_THROW);
 506     callgrindDump("sc:loadingFileWithSingleBigSheetdoSubTotal_2000lines");
 507 }
 508
 509 namespace {
 510     void setupBlockFormula(
 511         const uno::Reference< sheet::XSpreadsheetDocument > & xDoc,
 512         const OUString &rSheetName,
 513         const OUString &rCellRange,
 514         const OUString &rFormula)
 515     {
 516         uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 517
 518         uno::Any aSheet = xSheets->getByName(rSheetName);
 519         uno::Reference< table::XCellRange > xSheetCellRange(aSheet, UNO_QUERY);
 520         uno::Reference< sheet::XCellRangeFormula > xCellRange(
 521             xSheetCellRange->getCellRangeByName(rCellRange), UNO_QUERY);
 522
 523         uno::Sequence< uno::Sequence< OUString > > aFormulae(1000);
 524         auto pFormulae = aFormulae.getArray();
 525         for (sal_Int32 i = 0; i < 1000; ++i)
 526         {
 527             pFormulae[i] = { rFormula };
 528         }
 529
 530         // NB. not set Array (matrix) formula
 531         xCellRange->setFormulaArray(aFormulae);
 532     }
 533 }
 534
 535 void ScPerfObj::testFixedSum()
 536 {
 537     loadFromFile(u"scMathFunctions3.ods");
 538     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 539
 540     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 541
 542     setupBlockFormula(xDoc, "FixedSumSheet", "B1:B1000", "=SUM(A$1:A$1000)");
 543
 544     callgrindStart();
 545     xCalculatable->calculateAll();
 546     callgrindDump("sc:sum_with_fixed_array_formula");
 547
 548     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 549     uno::Any aSheet = xSheets->getByName("FixedSumSheet");
 550     uno::Reference< sheet::XSpreadsheet > xSheet (aSheet, UNO_QUERY);
 551
 552     for( sal_Int32 i = 0; i < 1000; ++i )
 553     {
 554         uno::Reference< table::XCell > xCell = xSheet->getCellByPosition(1, i);
 555         CPPUNIT_ASSERT_DOUBLES_EQUAL(50206.0, xCell->getValue(), 1e-12);
 556     }
 557 }
 558
 559 void ScPerfObj::testMatConcatSmall()
 560 {
 561     loadFromFile(u"empty.ods");
 562     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 563
 564     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 565
 566     // get getSheets
 567     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 568
 569     uno::Any rSheet = xSheets->getByName("Sheet1");
 570
 571     // query for the XSpreadsheet interface
 572     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 573
 574     // query for the XCellRange interface
 575     uno::Reference< table::XCellRange > rCellRange(rSheet, UNO_QUERY);
 576     // query the cell range
 577     uno::Reference< table::XCellRange > xCellRange = rCellRange->getCellRangeByName("C1");
 578
 579     uno::Reference< sheet::XArrayFormulaRange > xArrayFormulaRange(xCellRange, UNO_QUERY_THROW);
 580
 581     xArrayFormulaRange->setArrayFormula("=A1:A20&B1:B20");
 582     callgrindStart();
 583     xCalculatable->calculateAll();
 584     callgrindDump("sc:mat_concat_small");
 585 }
 586
 587 void ScPerfObj::testMatConcatLarge()
 588 {
 589     loadFromFile(u"empty.ods");
 590     uno::Reference< sheet::XSpreadsheetDocument > xDoc(mxComponent, UNO_QUERY_THROW);
 591
 592     uno::Reference< sheet::XCalculatable > xCalculatable(xDoc, UNO_QUERY_THROW);
 593
 594     // get getSheets
 595     uno::Reference< sheet::XSpreadsheets > xSheets (xDoc->getSheets(), UNO_SET_THROW);
 596
 597     uno::Any rSheet = xSheets->getByName("Sheet1");
 598
 599     // query for the XSpreadsheet interface
 600     uno::Reference< sheet::XSpreadsheet > xSheet (rSheet, UNO_QUERY);
 601
 602     // query for the XCellRange interface
 603     uno::Reference< table::XCellRange > rCellRange(rSheet, UNO_QUERY);
 604     // query the cell range
 605     uno::Reference< table::XCellRange > xCellRange = rCellRange->getCellRangeByName("C1");
 606
 607     uno::Reference< sheet::XArrayFormulaRange > xArrayFormulaRange(xCellRange, UNO_QUERY_THROW);
 608
 609     callgrindStart();
 610     xArrayFormulaRange->setArrayFormula("=A1:A30000&B1:B30000");
 611     xCalculatable->calculate();
 612     callgrindDump("sc:mat_concat");
 613 }
 614
 615 CPPUNIT_TEST_SUITE_REGISTRATION(ScPerfObj);
 616
 617 }
 618
 619 CPPUNIT_PLUGIN_IMPLEMENT();
 620
 621 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */