sc/qa/unit/ucalc_parallelism.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2
   3 #include <sal/config.h>
   4
   5 #include "helper/qahelper.hxx"
   6
   7 #include <docsh.hxx>
   8 #include <document.hxx>
   9 #include <markdata.hxx>
  10 #include <formulacell.hxx>
  11 #include <formulagroup.hxx>
  12 #include <scopetools.hxx>
  13
  14 #include <officecfg/Office/Calc.hxx>
  15
  16 using namespace css;
  17
  18 // test-suite suitable for creating documents to test parallelism in
  19 // with access to internal unexported symbols
  20
  21 class ScParallelismTest : public ScUcalcTestBase
  22 {
  23 public:
  24     virtual void setUp() override;
  25     virtual void tearDown() override;
  26
  27 private:
  28
  29     bool getThreadingFlag() const;
  30     void setThreadingFlag(bool bSet);
  31
  32     bool m_bThreadingFlagCfg;
  33 };
  34
  35 bool ScParallelismTest::getThreadingFlag() const
  36 {
  37     return officecfg::Office::Calc::Formula::Calculation::UseThreadedCalculationForFormulaGroups::get();
  38 }
  39
  40 void ScParallelismTest::setThreadingFlag( bool bSet )
  41 {
  42     std::shared_ptr<comphelper::ConfigurationChanges> xBatch(comphelper::ConfigurationChanges::create());
  43     officecfg::Office::Calc::Formula::Calculation::UseThreadedCalculationForFormulaGroups::set(bSet, xBatch);
  44     xBatch->commit();
  45 }
  46
  47 void ScParallelismTest::setUp()
  48 {
  49     ScUcalcTestBase::setUp();
  50
  51     sc::FormulaGroupInterpreter::disableOpenCL_UnitTestsOnly();
  52
  53     m_bThreadingFlagCfg = getThreadingFlag();
  54     if (!m_bThreadingFlagCfg)
  55         setThreadingFlag(true);
  56 }
  57
  58 void ScParallelismTest::tearDown()
  59 {
  60     // Restore threading flag
  61     if (!m_bThreadingFlagCfg)
  62         setThreadingFlag(false);
  63
  64     ScUcalcTestBase::tearDown();
  65 }
  66
  67 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testSUMIFS)
  68 {
  69     m_pDoc->InsertTab(0, u"1"_ustr);
  70
  71     m_pDoc->SetValue(0, 0, 0, 1001);
  72
  73     for (auto i = 1; i < 1000; i++)
  74     {
  75         /*A*/
  76         if (i%19)
  77             m_pDoc->SetValue(0, i, 0, i/10 + 1000);
  78         else
  79             m_pDoc->SetValue(0, i, 0, 123456);
  80         /*B*/ m_pDoc->SetValue(1, i, 0, i%10);
  81         /*C*/ m_pDoc->SetValue(2, i, 0, i%5);
  82
  83         /*F*/ m_pDoc->SetValue(5, i, 0, i%17 + i%13);
  84
  85         /*L*/ m_pDoc->SetValue(11, i, 0, i%10);
  86         /*M*/ m_pDoc->SetValue(12, i, 0, i%5);
  87     }
  88
  89     for (auto i = 1; i < 1000; i++)
  90     {
  91         // For instance P389 will contain the formula:
  92         // =SUMIFS($F$2:$F$1000; $A$2:$A$1000; A$1; $B$2:$B$1000; $L389; $C$2:$C$1000; $M389)
  93
  94         // In other words, it will sum those values in F2:1000 where the A value matches A1 (1001),
  95         // the B value matches L389 and the C value matches M389. (There should be just one such
  96         // value, so the formula is actually simply used to pick out that single value from the F
  97         // column where A,B,C match. Silly, but that is how SUMIFS is used in some corners of the
  98         // real world, apparently.)
  99
 100         /*P*/ m_pDoc->SetFormula(ScAddress(15, i, 0),
 101                                 "=SUMIFS($F$2:$F$1000; "
 102                                 "$A$2:$A$1000; A$1; "
 103                                 "$B$2:$B$1000; $L" + OUString::number(i+1) + "; "
 104                                 "$C$2:$C$1000; $M" + OUString::number(i+1) +
 105                                  ")",
 106                                  formula::FormulaGrammar::GRAM_NATIVE_UI);
 107     }
 108
 109     m_xDocShell->DoHardRecalc();
 110
 111 #if 1
 112     OUString sFormula;
 113
 114     std::cerr << "A1=" << m_pDoc->GetValue(0, 0, 0) << std::endl;
 115
 116     std::cerr << "      A,B,C  F  L,M" << std::endl;
 117     for (auto i = 1; i < 30; i++)
 118     {
 119         std::cerr <<
 120             i+1 << ": " <<
 121             m_pDoc->GetValue(0, i, 0) << "," <<
 122             m_pDoc->GetValue(1, i, 0) << "," <<
 123             m_pDoc->GetValue(2, i, 0) << "  " <<
 124             m_pDoc->GetValue(5, i, 0) << "  " <<
 125             m_pDoc->GetValue(11, i, 0) << "," <<
 126             m_pDoc->GetValue(12, i, 0) << "  \"";
 127         sFormula = m_pDoc->GetFormula(15, i, 0);
 128         std::cerr << sFormula << "\": \"" <<
 129             m_pDoc->GetString(15, i, 0) << "\": " <<
 130             m_pDoc->GetValue(15, i, 0) << std::endl;
 131     }
 132 #endif
 133
 134     for (auto i = 1; i < 1000; i++)
 135     {
 136         OString sMessage = "At row " + OString::number(i+1);
 137         if ((10+i%10)%19)
 138             CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(sMessage.getStr(), m_pDoc->GetValue(5, 10+i%10, 0), m_pDoc->GetValue(15, i, 0), 1e-10);
 139         else
 140             CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(sMessage.getStr(), 0, m_pDoc->GetValue(15, i, 0), 1e-10);
 141     }
 142
 143     m_pDoc->DeleteTab(0);
 144 }
 145
 146 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testDivision)
 147 {
 148     m_pDoc->InsertTab(0, u"1"_ustr);
 149
 150     for (auto i = 1; i < 1000; i++)
 151     {
 152         /*A*/ m_pDoc->SetValue(0, i, 0, i);
 153         /*B*/ m_pDoc->SetValue(1, i, 0, i%10);
 154         /*C*/ m_pDoc->SetFormula(ScAddress(2, i, 0),
 155                                  "=A" + OUString::number(i+1) + "/B" + OUString::number(i+1),
 156                                  formula::FormulaGrammar::GRAM_NATIVE_UI);
 157     }
 158
 159     m_xDocShell->DoHardRecalc();
 160
 161     for (auto i = 1; i < 1000; i++)
 162     {
 163         OString sMessage = "At row " + OString::number(i+1);
 164         if (i%10)
 165             CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(sMessage.getStr(), static_cast<double>(i)/(i%10), m_pDoc->GetValue(2, i, 0), 1e-10);
 166         else
 167             CPPUNIT_ASSERT_EQUAL_MESSAGE(sMessage.getStr(), u"#DIV/0!"_ustr, m_pDoc->GetString(2, i, 0));
 168     }
 169
 170     m_pDoc->DeleteTab(0);
 171 }
 172
 173 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testVLOOKUP)
 174 {
 175     m_pDoc->InsertTab(0, u"1"_ustr);
 176
 177     for (auto i = 1; i < 2000; i++)
 178     {
 179         if (i == 1042)
 180             m_pDoc->SetValue(0, i, 0, 1042.42);
 181         else if (i%5)
 182             m_pDoc->SetValue(0, i, 0, i);
 183         else
 184             m_pDoc->SetValue(0, i, 0, i+0.1);
 185
 186         if (i%2)
 187             m_pDoc->SetValue(1, i, 0, i*10);
 188         else
 189             m_pDoc->SetString(1, i, 0, "N" + OUString::number(i*10));
 190
 191         if (i < 1000)
 192         {
 193             m_pDoc->SetFormula(ScAddress(2, i, 0),
 194                                "=VLOOKUP(" + OUString::number(i) + "; "
 195                                "A$2:B$2000; 2; 0)",
 196                                formula::FormulaGrammar::GRAM_NATIVE_UI);
 197         }
 198
 199         else
 200         {
 201             if (i == 1042)
 202                 m_pDoc->SetFormula(ScAddress(2, i, 0),
 203                                    u"=VLOOKUP(1042.42; "
 204                                    "A$2:B$2000; 2; 0)"_ustr,
 205                                    formula::FormulaGrammar::GRAM_NATIVE_UI);
 206             else
 207                 m_pDoc->SetFormula(ScAddress(2, i, 0),
 208                                    u"=VLOOKUP(1.234; "
 209                                    "A$2:B$2000; 2; 0)"_ustr,
 210                                    formula::FormulaGrammar::GRAM_NATIVE_UI);
 211         }
 212     }
 213
 214     m_xDocShell->DoHardRecalc();
 215
 216     for (auto i = 1; i < 2000; i++)
 217     {
 218         OString sMessage = "At row " + OString::number(i+1);
 219         if (i < 1000)
 220         {
 221             if (i%5)
 222             {
 223                 if (i%2)
 224                     CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(sMessage.getStr(), static_cast<double>(i*10), m_pDoc->GetValue(2, i, 0), 1e-10);
 225                 else
 226                     CPPUNIT_ASSERT_EQUAL_MESSAGE(sMessage.getStr(), OUString("N" + OUString::number(i*10)), m_pDoc->GetString(2, i, 0));
 227             }
 228             else
 229             {
 230                 // The corresponding value in A is i+0.1
 231                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sMessage.getStr(), u"#N/A"_ustr, m_pDoc->GetString(2, i, 0));
 232             }
 233         }
 234         else
 235         {
 236             if (i == 1042)
 237                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sMessage.getStr(), OUString("N" + OUString::number(i*10)), m_pDoc->GetString(2, i, 0));
 238             else
 239                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sMessage.getStr(), u"#N/A"_ustr, m_pDoc->GetString(2, i, 0));
 240         }
 241     }
 242
 243     m_pDoc->DeleteTab(0);
 244 }
 245
 246 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testVLOOKUPSUM)
 247 {
 248     m_pDoc->InsertTab(0, u"1"_ustr);
 249
 250     const size_t nNumRows = 2048;
 251     OUString aTableRef = "$A$1:$B$" + OUString::number(nNumRows);
 252     for (size_t i = 0; i < nNumRows; ++i)
 253     {
 254         m_pDoc->SetValue(0, i, 0, static_cast<double>(i));
 255         m_pDoc->SetValue(1, i, 0, static_cast<double>(5*i + 100));
 256         m_pDoc->SetValue(2, i, 0, static_cast<double>(nNumRows - i - 1));
 257     }
 258     for (size_t i = 0; i < nNumRows; ++i)
 259     {
 260         OUString aArgNum = "C" + OUString::number(i+1);
 261         m_pDoc->SetFormula(ScAddress(3, i, 0),
 262                            "=SUM(" + aArgNum + ";VLOOKUP(" + aArgNum + ";" + aTableRef + "; 2; 0)) + SUM($A1:$A2)",
 263                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 264     }
 265
 266     m_xDocShell->DoHardRecalc();
 267
 268     for (size_t i = 0; i < nNumRows; ++i)
 269     {
 270         OString aMsg = "At row " + OString::number(i);
 271         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), 6 * (nNumRows - i - 1) + 101, static_cast<size_t>(m_pDoc->GetValue(3, i, 0)));
 272     }
 273     m_pDoc->DeleteTab(0);
 274 }
 275
 276 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testSingleRef)
 277 {
 278     m_pDoc->InsertTab(0, u"1"_ustr);
 279
 280     const size_t nNumRows = 200;
 281     for (size_t i = 0; i < nNumRows; ++i)
 282     {
 283         m_pDoc->SetValue(0, i, 0, static_cast<double>(i));
 284         m_pDoc->SetFormula(ScAddress(1, i, 0), "=A" + OUString::number(i+1), formula::FormulaGrammar::GRAM_NATIVE_UI);
 285     }
 286
 287     m_xDocShell->DoHardRecalc();
 288
 289     for (size_t i = 0; i < nNumRows; ++i)
 290     {
 291         OString aMsg = "At row " + OString::number(i);
 292         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), i, static_cast<size_t>(m_pDoc->GetValue(1, i, 0)));
 293     }
 294     m_pDoc->DeleteTab(0);
 295 }
 296
 297 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testTdf147905)
 298 {
 299     m_pDoc->InsertTab(0, u"1"_ustr);
 300
 301     OUString aFormula;
 302     const size_t nNumRows = 500;
 303     for (size_t i = 0; i < nNumRows; ++i)
 304     {
 305         m_pDoc->SetString(0, i, 0, u"AAAAAAAA"_ustr);
 306         aFormula = "=PROPER($A" + OUString::number(i+1) + ")";
 307         m_pDoc->SetFormula(ScAddress(1, i, 0),
 308                            aFormula,
 309                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 310     }
 311
 312     m_xDocShell->DoHardRecalc();
 313
 314     for (size_t i = 0; i < nNumRows; ++i)
 315     {
 316         OString aMsg = "At row " + OString::number(i);
 317         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), u"AAAAAAAA"_ustr, m_pDoc->GetString(0, i, 0));
 318
 319         // Without the fix in place, this test would have failed here
 320         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), u"Aaaaaaaa"_ustr, m_pDoc->GetString(1, i, 0));
 321     }
 322     m_pDoc->DeleteTab(0);
 323 }
 324
 325 // Common test setup steps for testSUMIFImplicitRange*()
 326 static void lcl_setupCommon(ScDocument* pDoc, size_t nNumRows, size_t nConstCellValue)
 327 {
 328     pDoc->SetValue(3, 0, 0, static_cast<double>(nConstCellValue));  // D1
 329     for (size_t i = 0; i <= (nNumRows*2); ++i)
 330     {
 331         pDoc->SetValue(0, i, 0, static_cast<double>(i));
 332         pDoc->SetFormula(ScAddress(1, i, 0),
 333                          "=A" + OUString::number(i+1),
 334                          formula::FormulaGrammar::GRAM_NATIVE_UI);
 335     }
 336 }
 337
 338 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testSUMIFImplicitRange)
 339 {
 340     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 341     m_pDoc->InsertTab(0, u"1"_ustr);
 342
 343     const size_t nNumRows = 1048;
 344     const size_t nConstCellValue = 20;
 345     lcl_setupCommon(m_pDoc, nNumRows, nConstCellValue);
 346     OUString aSrcRange = "$A$1:$A$" + OUString::number(nNumRows);
 347     OUString aFormula;
 348     for (size_t i = 0; i < nNumRows; ++i)
 349     {
 350         aFormula = "=SUMIF(" + aSrcRange + ";$D$1;$B$1)";
 351         m_pDoc->SetFormula(ScAddress(2, i, 0),
 352                            aFormula,
 353                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 354     }
 355
 356     ScFormulaCell* pCell = m_pDoc->GetFormulaCell(ScAddress(2, 0, 0));
 357     sc::AutoCalcSwitch aACSwitch2(*m_pDoc, true);
 358     pCell->InterpretFormulaGroup();  // Start calculation on the F.G at C1
 359
 360     for (size_t i = 0; i < nNumRows; ++i)
 361     {
 362         OString aMsg = "At row " + OString::number(i);
 363         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nConstCellValue, static_cast<size_t>(m_pDoc->GetValue(2, i, 0)));
 364     }
 365     m_pDoc->DeleteTab(0);
 366 }
 367
 368 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testFGCycleWithPlainFormulaCell1)
 369 {
 370     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 371     m_pDoc->InsertTab(0, u"1"_ustr);
 372     const size_t nNumRows = 1048;
 373     // Column A contains no formula-group
 374     // A1 = 100
 375     m_pDoc->SetValue(0, 0, 0, 100.0);
 376     // A500 = B499 + 1
 377     m_pDoc->SetFormula(ScAddress(0, 499, 0),
 378                        u"=$B499 + 1"_ustr,
 379                        formula::FormulaGrammar::GRAM_NATIVE_UI);
 380     // Column B has a formula-group referencing column A.
 381     OUString aFormula;
 382     for (size_t i = 0; i < nNumRows; ++i)
 383     {
 384         aFormula = "=$A" + OUString::number(i+1) + " + 100";
 385         m_pDoc->SetFormula(ScAddress(1, i, 0),
 386                            aFormula,
 387                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 388     }
 389     m_xDocShell->DoHardRecalc();
 390     // Value at A500 must be 101
 391     const size_t nVal = 100;
 392     CPPUNIT_ASSERT_EQUAL_MESSAGE("Value at A500", nVal + 1, static_cast<size_t>(m_pDoc->GetValue(0, 499, 0)));
 393     for (size_t i = 0; i < nNumRows; ++i)
 394     {
 395         OString aMsg = "Value at cell B" + OString::number(i+1);
 396         size_t nExpected = nVal;
 397         if (i == 0)
 398             nExpected = 200;
 399         else if (i == 499)
 400             nExpected = 201;
 401         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpected, static_cast<size_t>(m_pDoc->GetValue(1, i, 0)));
 402     }
 403     m_pDoc->DeleteTab(0);
 404 }
 405
 406 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testFGCycleWithPlainFormulaCell2)
 407 {
 408     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 409     m_pDoc->InsertTab(0, u"1"_ustr);
 410     const size_t nNumRows = 1048;
 411     // Column A
 412     OUString aFormula;
 413     for (size_t i = 0; i < nNumRows; ++i)
 414     {
 415         aFormula = "=$B" + OUString::number(i+1) + " + 1";
 416         m_pDoc->SetFormula(ScAddress(0, i, 0),
 417                            aFormula,
 418                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 419     }
 420     // Column B
 421     for (size_t i = 0; i < nNumRows; ++i)
 422     {
 423         aFormula = "=$C" + OUString::number(i+1) + " + 1";
 424         m_pDoc->SetFormula(ScAddress(1, i, 0),
 425                            aFormula,
 426                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 427     }
 428
 429     // Column C has no FG but a cell at C500 that references A499
 430     m_pDoc->SetFormula(ScAddress(2, 499, 0), // C500
 431                        u"=$A499 + 1"_ustr,
 432                        formula::FormulaGrammar::GRAM_NATIVE_UI);
 433     m_xDocShell->DoHardRecalc();
 434
 435     size_t nExpected = 0;
 436     for (size_t i = 0; i < nNumRows; ++i)
 437     {
 438         OString aMsg = "Value at cell A" + OString::number(i+1);
 439         nExpected = 2;
 440         if (i == 499)  // A500 must have value = 5
 441             nExpected = 5;
 442         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpected, static_cast<size_t>(m_pDoc->GetValue(0, i, 0)));
 443         aMsg = "Value at cell B" + OString::number(i+1);
 444         nExpected = 1;
 445         if (i == 499)  // B500 must have value = 4
 446             nExpected = 4;
 447         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpected, static_cast<size_t>(m_pDoc->GetValue(1, i, 0)));
 448     }
 449
 450     // C500 must have value = 3
 451     nExpected = 3;
 452     CPPUNIT_ASSERT_EQUAL_MESSAGE("Value at cell C500", nExpected, static_cast<size_t>(m_pDoc->GetValue(2, 499, 0)));
 453     m_pDoc->DeleteTab(0);
 454 }
 455
 456 static void lcl_setupMultipleFGColumn(ScDocument* pDocument, size_t nNumRowsInBlock, size_t nNumFG, size_t nOffset)
 457 {
 458     OUString aFormula;
 459     ScAddress aAddr(1, 0, 0);
 460     // Column B with multiple FG's
 461     for (size_t nFGIdx = 0; nFGIdx < nNumFG; ++nFGIdx)
 462     {
 463         size_t nRowStart = 2*nFGIdx*nNumRowsInBlock;
 464         for (size_t nRow = nRowStart; nRow < (nRowStart + nNumRowsInBlock); ++nRow)
 465         {
 466             aAddr.SetRow(nRow);
 467             aFormula = "=$C" + OUString::number(nRow+1) + " + 0";
 468             pDocument->SetFormula(aAddr, aFormula,
 469                                   formula::FormulaGrammar::GRAM_NATIVE_UI);
 470             // Fill Column C with doubles.
 471             pDocument->SetValue(2, nRow, 0, static_cast<double>(nFGIdx));
 472         }
 473     }
 474
 475     // Column A with a single FG that depends on Column B.
 476     size_t nNumRowsInRef = nNumRowsInBlock*2;
 477     size_t nColAFGLen = 2*nNumRowsInBlock*nNumFG - nNumRowsInRef + 1;
 478     aAddr.SetCol(0);
 479     for (size_t nRow = nOffset; nRow < nColAFGLen; ++nRow)
 480     {
 481         aAddr.SetRow(nRow);
 482         aFormula = "=SUM($B" + OUString::number(nRow+1) + ":$B" + OUString::number(nRow+nNumRowsInRef) + ")";
 483         pDocument->SetFormula(aAddr, aFormula,
 484                               formula::FormulaGrammar::GRAM_NATIVE_UI);
 485     }
 486 }
 487
 488 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testMultipleFGColumn)
 489 {
 490     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 491     m_pDoc->InsertTab(0, u"1"_ustr);
 492
 493     constexpr size_t nNumRowsInBlock = 200;
 494     constexpr size_t nNumFG = 50;
 495     constexpr size_t nNumRowsInRef = nNumRowsInBlock*2;
 496     constexpr size_t nColAFGLen = 2*nNumRowsInBlock*nNumFG - nNumRowsInRef + 1;
 497     constexpr size_t nColAStartOffset = nNumRowsInBlock/2;
 498     lcl_setupMultipleFGColumn(m_pDoc, nNumRowsInBlock, nNumFG, nColAStartOffset);
 499
 500     m_xDocShell->DoHardRecalc();
 501
 502     OString aMsg;
 503     // First cell in the FG in col A references nColAStartOffset cells in second formula-group of column B each having value 1.
 504     size_t nExpected = nColAStartOffset;
 505     size_t nIn = 0, nOut = 0;
 506     for (size_t nRow = nColAStartOffset; nRow < nColAFGLen; ++nRow)
 507     {
 508         aMsg = "Value at Cell A" + OString::number(nRow+1);
 509         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpected, static_cast<size_t>(m_pDoc->GetValue(0, nRow, 0)));
 510         nIn = static_cast<size_t>(m_pDoc->GetValue(2, nRow+nNumRowsInRef, 0));
 511         nOut = static_cast<size_t>(m_pDoc->GetValue(2, nRow, 0));
 512         nExpected = nExpected + nIn - nOut;
 513     }
 514
 515     m_pDoc->DeleteTab(0);
 516 }
 517
 518 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testFormulaGroupSpanEval)
 519 {
 520     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 521     m_pDoc->InsertTab(0, u"1"_ustr);
 522
 523     constexpr size_t nFGLen = 2048;
 524     OUString aFormula;
 525
 526     for (size_t nRow = 0; nRow < nFGLen; ++nRow)
 527     {
 528         aFormula = "=$C" + OUString::number(nRow+1) + " + 0";
 529         m_pDoc->SetFormula(ScAddress(1, nRow, 0), aFormula,
 530                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 531         aFormula = "=SUM($B" + OUString::number(nRow+1) + ":$B" + OUString::number(nRow+2) + ")";
 532         m_pDoc->SetFormula(ScAddress(0, nRow, 0), aFormula,
 533                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 534     }
 535
 536     m_xDocShell->DoHardRecalc();
 537
 538     for (size_t nRow = 0; nRow < nFGLen; ++nRow)
 539     {
 540         m_pDoc->SetValue(2, nRow, 0, 1.0);
 541         ScFormulaCell* pFCell = m_pDoc->GetFormulaCell(ScAddress(1, nRow, 0));
 542         pFCell->SetDirtyVar();
 543         pFCell = m_pDoc->GetFormulaCell(ScAddress(0, nRow, 0));
 544         pFCell->SetDirtyVar();
 545     }
 546
 547     constexpr size_t nSpanStart = 100;
 548     constexpr size_t nSpanLen = 1024;
 549     constexpr size_t nSpanEnd = nSpanStart + nSpanLen - 1;
 550
 551     m_pDoc->SetAutoCalc(true);
 552
 553     // EnsureFormulaCellResults should only calculate the specified range along with the dependent spans recursively and nothing more.
 554     // The specified range is A99:A1124, and the dependent range is B99:B1125 (since A99 = SUM(B99:B100) and A1124 = SUM(B1124:B1125) )
 555     bool bAnyDirty = m_pDoc->EnsureFormulaCellResults(ScRange(0, nSpanStart, 0, 0, nSpanEnd, 0));
 556     CPPUNIT_ASSERT(bAnyDirty);
 557     m_pDoc->SetAutoCalc(false);
 558
 559     OString aMsg;
 560     for (size_t nRow = 0; nRow < nFGLen; ++nRow)
 561     {
 562         size_t nExpectedA = 0, nExpectedB = 0;
 563         // For nRow from 100(nSpanStart) to 1123(nSpanEnd) column A must have the value of 2 and
 564         // column B should have value 1.
 565
 566         // For nRow == 1124, column A should have value 0 and column B should have value 1.
 567
 568         // For all other rows both column A and B must have value 0.
 569         if (nRow >= nSpanStart)
 570         {
 571             if (nRow <= nSpanEnd)
 572             {
 573                 nExpectedA = 2;
 574                 nExpectedB = 1;
 575             }
 576             else if (nRow == nSpanEnd + 1)
 577                 nExpectedB = 1;
 578         }
 579
 580         aMsg = "Value at Cell A" + OString::number(nRow+1);
 581         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpectedA, static_cast<size_t>(m_pDoc->GetValue(0, nRow, 0)));
 582         aMsg = "Value at Cell B" + OString::number(nRow+1);
 583         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpectedB, static_cast<size_t>(m_pDoc->GetValue(1, nRow, 0)));
 584     }
 585
 586     m_pDoc->DeleteTab(0);
 587 }
 588
 589 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testFormulaGroupSpanEvalNonGroup)
 590 {
 591     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 592     m_pDoc->InsertTab(0, u"1"_ustr);
 593
 594     constexpr size_t nFGLen = 2048;
 595     OUString aFormula;
 596
 597     for (size_t nRow = 0; nRow < nFGLen; ++nRow)
 598     {
 599         aFormula = "=$B" + OUString::number(nRow+1) + " + 0";
 600         m_pDoc->SetFormula(ScAddress(0, nRow, 0), aFormula,
 601                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 602     }
 603
 604     m_xDocShell->DoHardRecalc();
 605
 606     constexpr size_t nNumChanges = 12;
 607     constexpr size_t nChangeRows[nNumChanges] = {10, 11, 12, 101, 102, 103, 251, 252, 253, 503, 671, 1029};
 608     for (size_t nIdx = 0; nIdx < nNumChanges; ++nIdx)
 609     {
 610         size_t nRow = nChangeRows[nIdx];
 611         m_pDoc->SetValue(1, nRow, 0, 1.0);
 612         ScFormulaCell* pFCell = m_pDoc->GetFormulaCell(ScAddress(0, nRow, 0));
 613         pFCell->SetDirtyVar();
 614     }
 615
 616     m_pDoc->SetAutoCalc(true);
 617     bool bAnyDirty = m_pDoc->EnsureFormulaCellResults(ScRange(0, 9, 0, 0, 1030, 0));
 618     CPPUNIT_ASSERT(bAnyDirty);
 619     m_pDoc->SetAutoCalc(false);
 620
 621     OString aMsg;
 622     for (size_t nRow = 0, nIdx = 0; nRow < nFGLen; ++nRow)
 623     {
 624         size_t nExpected = 0;
 625         if (nIdx < nNumChanges && nRow == nChangeRows[nIdx])
 626         {
 627             nExpected = 1;
 628             ++nIdx;
 629         }
 630
 631         aMsg = "Value at Cell A" + OString::number(nRow+1);
 632         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpected, static_cast<size_t>(m_pDoc->GetValue(0, nRow, 0)));
 633     }
 634
 635     m_pDoc->DeleteTab(0);
 636 }
 637
 638 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testArrayFormulaGroup)
 639 {
 640     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 641     m_pDoc->InsertTab(0, u"1"_ustr);
 642
 643     m_pDoc->SetValue(1, 0, 0, 2.0);  // B1 <== 2
 644     m_pDoc->SetValue(2, 0, 0, 1.0);  // C1 <== 1
 645     OUString aFormula;
 646
 647     for (size_t nRow = 1; nRow < 16; ++nRow)
 648     {
 649         m_pDoc->SetValue(0, nRow, 0, 1.0);  // A2:A16 <== 1
 650
 651         if (nRow > 10)
 652             continue;
 653
 654         aFormula = "=SUMPRODUCT(($A" + OUString::number(1 + nRow) +
 655             ":$A" + OUString::number(499 + nRow) + ")*B$1+C$1)";
 656         // Formula-group in B2:B11 with first cell = "=SUMPRODUCT(($A2:$A500)*B$1+C$1)"
 657         m_pDoc->SetFormula(ScAddress(1, nRow, 0), aFormula,
 658                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 659     }
 660
 661     m_xDocShell->DoHardRecalc();
 662
 663     size_t nExpected = 529;
 664     OString aMsg;
 665     for (size_t nRow = 1; nRow < 11; ++nRow)
 666     {
 667         aMsg = "Value at Cell B" + OString::number(nRow+1);
 668         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpected, static_cast<size_t>(m_pDoc->GetValue(1, nRow, 0)));
 669         nExpected -= 2;
 670     }
 671
 672     m_pDoc->DeleteTab(0);
 673 }
 674
 675 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testDependentFormulaGroupCollection)
 676 {
 677     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 678     m_pDoc->InsertTab(0, u"1"_ustr);
 679
 680     OUString aFormula;
 681
 682     for (size_t nRow = 0; nRow < 16; ++nRow)
 683     {
 684         m_pDoc->SetValue(0, nRow, 0, 1.0);  // A1:A16 <== 1
 685
 686         if (nRow > 7)
 687             continue;
 688
 689         // Formula-group in B1:B8 with first cell = "=SUM($A1:$A1024)"
 690         aFormula = "=SUM($A" + OUString::number(1 + nRow) +
 691             ":$A" + OUString::number(1024 + nRow) + ")";
 692         m_pDoc->SetFormula(ScAddress(1, nRow, 0), aFormula,
 693                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 694
 695         // Formula-group in C1:C8 with first cell = "=SUM($K1:$K1024)"
 696         aFormula = "=SUM($K" + OUString::number(1 + nRow) +
 697             ":$K" + OUString::number(1024 + nRow) + ")";
 698         m_pDoc->SetFormula(ScAddress(2, nRow, 0), aFormula,
 699                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 700
 701         // Formula-group in D1:D8 with first cell = "=SUM($A1:$A1024) - $A2"
 702         aFormula = "=SUM($A" + OUString::number(1 + nRow) +
 703             ":$A" + OUString::number(1024 + nRow) + ") - $A" + OUString::number(2 + nRow);
 704         m_pDoc->SetFormula(ScAddress(3, nRow, 0), aFormula,
 705                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 706
 707         // Formula-group in K1:K8 with first cell = "=SUM($B1:$B1024)"
 708         aFormula = "=SUM($B" + OUString::number(1 + nRow) +
 709             ":$B" + OUString::number(1024 + nRow) + ")";
 710         m_pDoc->SetFormula(ScAddress(10, nRow, 0), aFormula,
 711                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 712     }
 713
 714     m_xDocShell->DoHardRecalc();
 715
 716     size_t nExpected[8] = { 408, 308, 224, 155, 100, 58, 28, 9 };
 717
 718     OString aMsg;
 719     for (size_t nRow = 0; nRow < 8; ++nRow)
 720     {
 721         aMsg = "Value at Cell C" + OString::number(nRow+1);
 722         CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), nExpected[nRow], static_cast<size_t>(m_pDoc->GetValue(2, nRow, 0)));
 723     }
 724
 725     m_pDoc->DeleteTab(0);
 726 }
 727
 728 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testFormulaGroupWithForwardSelfReference)
 729 {
 730     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 731     m_pDoc->InsertTab(0, u"1"_ustr);
 732
 733     OUString aFormula;
 734     m_pDoc->SetValue(2, 4, 0, 10.0);  // C5 <== 10
 735
 736     for (size_t nRow = 0; nRow < 4; ++nRow)
 737     {
 738         // Formula-group in B1:B4 with first cell = "=SUM($A1:$A1024) + C1"
 739         aFormula = "=SUM($A" + OUString::number(1 + nRow) +
 740             ":$A" + OUString::number(1024 + nRow) + ") + C" + OUString::number(nRow + 1);
 741         m_pDoc->SetFormula(ScAddress(1, nRow, 0), aFormula,
 742                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 743
 744         // Formula-group in C1:C4 with first cell = "=SUM($A1:$A1024) + C2"
 745         aFormula = "=SUM($A" + OUString::number(1 + nRow) +
 746             ":$A" + OUString::number(1024 + nRow) + ") + C" + OUString::number(nRow + 2);
 747         m_pDoc->SetFormula(ScAddress(2, nRow, 0), aFormula,
 748                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 749     }
 750
 751     m_xDocShell->DoHardRecalc();
 752
 753     OString aMsg;
 754     for (size_t nCol = 0; nCol < 2; ++nCol)
 755     {
 756         for (size_t nRow = 0; nRow < 4; ++nRow)
 757         {
 758             aMsg = "Value at Cell (Col = " + OString::number(nCol + 1) + ", Row = " + OString::number(nRow) + ", Tab = 0)";
 759             CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), 10.0, m_pDoc->GetValue(1 + nCol, nRow, 0));
 760         }
 761     }
 762
 763     m_pDoc->DeleteTab(0);
 764 }
 765
 766 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testFormulaGroupsInCyclesAndWithSelfReference)
 767 {
 768     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 769     m_pDoc->InsertTab(0, u"1"_ustr);
 770
 771     m_pDoc->SetValue(1, 0, 0, 1.0); // B1 <== 1
 772     m_pDoc->SetValue(3, 0, 0, 2.0); // D1 <== 2
 773     OUString aFormula;
 774
 775     for (size_t nRow = 0; nRow < 5; ++nRow)
 776     {
 777         // Formula-group in C1:C5 with first cell = "=SUM($A1:$A1024) + D1"
 778         aFormula = "=SUM($A" + OUString::number(1 + nRow) +
 779             ":$A" + OUString::number(1024 + nRow) + ") + D" + OUString::number(nRow + 1);
 780         m_pDoc->SetFormula(ScAddress(2, nRow, 0), aFormula,
 781                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 782
 783         if (nRow == 0)
 784             continue;
 785
 786         // nRow starts from 1 till 4 (for D2 to D5).
 787         // Formula-group in D2:D5 with first cell = "=SUM($A1:$A1024) + D1 + B2"
 788         aFormula = "=SUM($A" + OUString::number(nRow) +
 789             ":$A" + OUString::number(1023 + nRow) + ") + D" + OUString::number(nRow) +
 790             " + B" + OUString::number(nRow + 1);
 791         m_pDoc->SetFormula(ScAddress(3, nRow, 0), aFormula,
 792                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 793
 794         // Formula-group in B2:B5 with first cell = "=SUM($A1:$A1024) + C1 + B1"
 795         aFormula = "=SUM($A" + OUString::number(nRow) +
 796             ":$A" + OUString::number(1023 + nRow) + ") + C" + OUString::number(nRow) +
 797             " + B" + OUString::number(nRow);
 798         m_pDoc->SetFormula(ScAddress(1, nRow, 0), aFormula,
 799                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 800     }
 801
 802     m_xDocShell->DoHardRecalc();
 803     m_pDoc->SetAutoCalc(true);
 804
 805     const ScRange aChangeRange(1, 1, 0, 1, 4, 0); // B2:B5
 806     ScMarkData aMark(m_pDoc->GetSheetLimits());
 807     aMark.SelectOneTable(0);
 808
 809     // Set up clip document.
 810     ScDocument aClipDoc(SCDOCMODE_CLIP);
 811     aClipDoc.ResetClip(m_pDoc, &aMark);
 812     // Cut B1:B2 to clipboard.
 813     cutToClip(*m_xDocShell, aChangeRange, &aClipDoc, false);
 814     pasteFromClip(m_pDoc, aChangeRange, &aClipDoc);
 815
 816     double fExpected[3][5] = {
 817         { 1, 3,  8, 21, 55 },
 818         { 2, 5, 13, 34, 89 },
 819         { 2, 5, 13, 34, 89 }
 820     };
 821
 822     OString aMsg;
 823     for (size_t nCol = 0; nCol < 3; ++nCol)
 824     {
 825         for (size_t nRow = 0; nRow < 5; ++nRow)
 826         {
 827             aMsg = "Value at Cell (Col = " + OString::number(nCol + 1) + ", Row = " + OString::number(nRow) + ", Tab = 0)";
 828             CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), fExpected[nCol][nRow], m_pDoc->GetValue(1 + nCol, nRow, 0));
 829         }
 830     }
 831
 832     m_pDoc->DeleteTab(0);
 833 }
 834
 835 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testFormulaGroupsInCyclesAndWithSelfReference2)
 836 {
 837     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 838     m_pDoc->InsertTab(0, u"1"_ustr);
 839
 840     m_pDoc->SetValue(1, 0, 0, 1.0); // B1 <== 1
 841     m_pDoc->SetValue(3, 0, 0, 2.0); // D1 <== 2
 842     m_pDoc->SetValue(4, 0, 0, 1.0); // E1 <== 1
 843     OUString aFormula;
 844
 845     for (size_t nRow = 0; nRow < 5; ++nRow)
 846     {
 847         // Formula-group in C1:C5 with first cell = "=SUM($A1:$A1024) + D1 + E1"
 848         aFormula = "=SUM($A" + OUString::number(1 + nRow) +
 849             ":$A" + OUString::number(1024 + nRow) + ") + D" + OUString::number(nRow + 1) +
 850             " + E" + OUString::number(nRow + 1);
 851         m_pDoc->SetFormula(ScAddress(2, nRow, 0), aFormula,
 852                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 853
 854         if (nRow == 0)
 855             continue;
 856
 857         // Formula-group in B2:B5 with first cell = "=SUM($A1:$A1024) + C1 + B1"
 858         aFormula = "=SUM($A" + OUString::number(nRow) +
 859             ":$A" + OUString::number(1023 + nRow) + ") + C" + OUString::number(nRow) +
 860             " + B" + OUString::number(nRow);
 861         m_pDoc->SetFormula(ScAddress(1, nRow, 0), aFormula,
 862                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 863
 864         // Formula-group in D2:D5 with first cell = "=SUM($A1:$A1024) + D1 + B2"
 865         aFormula = "=SUM($A" + OUString::number(nRow) +
 866             ":$A" + OUString::number(1023 + nRow) + ") + D" + OUString::number(nRow) +
 867             " + B" + OUString::number(nRow + 1);
 868         m_pDoc->SetFormula(ScAddress(3, nRow, 0), aFormula,
 869                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 870
 871         // Formula-group in E2:E5 with first cell = "=SUM($A1:$A1024) + E1 + D2"
 872         aFormula = "=SUM($A" + OUString::number(nRow) +
 873             ":$A" + OUString::number(1023 + nRow) + ") + E" + OUString::number(nRow) +
 874             " + D" + OUString::number(nRow + 1);
 875         m_pDoc->SetFormula(ScAddress(4, nRow, 0), aFormula,
 876                            formula::FormulaGrammar::GRAM_NATIVE_UI);
 877     }
 878
 879     m_xDocShell->DoHardRecalc();
 880
 881     double fExpected[4][5] = {
 882         {  1,   4,  17,  70,  286 },
 883         {  3,  13,  53, 216,  881 },
 884         {  2,   6,  23,  93,  379 },
 885         {  1,   7,  30, 123,  502 }
 886     };
 887
 888     OString aMsg;
 889     for (size_t nCol = 0; nCol < 4; ++nCol)
 890     {
 891         for (size_t nRow = 0; nRow < 5; ++nRow)
 892         {
 893             aMsg = "Value at Cell (Col = " + OString::number(nCol + 1) + ", Row = " + OString::number(nRow) + ", Tab = 0)";
 894             CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), fExpected[nCol][nRow], m_pDoc->GetValue(1 + nCol, nRow, 0));
 895         }
 896     }
 897
 898     m_pDoc->DeleteTab(0);
 899 }
 900
 901 CPPUNIT_TEST_FIXTURE(ScParallelismTest, testFormulaGroupsInCyclesAndWithSelfReference3)
 902 {
 903     sc::AutoCalcSwitch aACSwitch(*m_pDoc, false);
 904     m_pDoc->InsertTab(0, u"1"_ustr);
 905
 906     m_pDoc->SetValue(1, 1, 0, 2.0); // B2 <== 2
 907     for (size_t nRow = 1; nRow < 105; ++nRow)
 908     {
 909         // Formula-group in B3:B104 with first cell "=D2+0.001"
 910         if( nRow != 1 )
 911             m_pDoc->SetFormula(ScAddress(1, nRow, 0), "=D" + OUString::number(nRow) + "+0.001",
 912                 formula::FormulaGrammar::GRAM_NATIVE_UI);
 913         // Formula-group in C2:C104 with first cell "=B2*1.01011"
 914         m_pDoc->SetFormula(ScAddress(2, nRow, 0), "=B" + OUString::number(nRow + 1) + "*1.01011",
 915             formula::FormulaGrammar::GRAM_NATIVE_UI);
 916         // Formula-group in D2:C104 with first cell "=C2*1.02"
 917         m_pDoc->SetFormula(ScAddress(3, nRow, 0), "=C" + OUString::number(nRow + 1) + "*1.02",
 918             formula::FormulaGrammar::GRAM_NATIVE_UI);
 919     }
 920
 921     m_xDocShell->DoHardRecalc();
 922
 923     // What happens with tdf#132451 is that the copy&paste C6->C5 really just sets the dirty flag
 924     // for C5 and all the cells that depend on it (D5,B6,C6,D6,B7,...), and it also resets
 925     // flags marking the C formula group as disabled for parallel calculation because of the cycle.
 926     m_pDoc->SetFormula(ScAddress(2, 4, 0), u"=B5*1.01011"_ustr, formula::FormulaGrammar::GRAM_NATIVE_UI);
 927     m_pDoc->GetFormulaCell(ScAddress(2,4,0))->GetCellGroup()->mbPartOfCycle = false;
 928     m_pDoc->GetFormulaCell(ScAddress(2,4,0))->GetCellGroup()->meCalcState = sc::GroupCalcEnabled;
 929
 930     m_pDoc->SetAutoCalc(true);
 931     // Without the fix, getting value of C5 would try to parallel-interpret formula group in B
 932     // from its first dirty cell (B6), which depends on D5, which depends on C5, where the cycle
 933     // would be detected and dependency check would bail out. But the result from Interpret()-ing
 934     // D5 would be used and D5's dirty flag reset, with D5 value incorrect.
 935     m_pDoc->GetValue(2,4,0);
 936
 937     double fExpected[2][3] = {
 938         { 2.19053373572776, 2.21268003179597, 2.25693363243189 },
 939         { 2.25793363243189, 2.28076134145577, 2.32637656828489 }
 940     };
 941     for (size_t nCol = 1; nCol < 4; ++nCol)
 942     {
 943         for (size_t nRow = 4; nRow < 6; ++nRow)
 944         {
 945             OString aMsg = "Value at Cell (Col = " + OString::number(nCol) + ", Row = " + OString::number(nRow) + ", Tab = 0)";
 946             ASSERT_DOUBLES_EQUAL_MESSAGE(aMsg.getStr(), fExpected[nRow - 4][nCol - 1], m_pDoc->GetValue(nCol, nRow, 0));
 947         }
 948     }
 949
 950     m_pDoc->DeleteTab(0);
 951 }
 952
 953 CPPUNIT_PLUGIN_IMPLEMENT();
 954
 955 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */