sc/qa/unit/ucalc_condformat.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 "helper/qahelper.hxx"
  11
  12 #include <conditio.hxx>
  13 #include <colorscale.hxx>
  14
  15 #include <hints.hxx>
  16 #include <globstr.hrc>
  17 #include <scresid.hxx>
  18 #include <docfunc.hxx>
  19 #include <scitems.hxx>
  20 #include <attrib.hxx>
  21 #include <fillinfo.hxx>
  22 #include <compiler.hxx>
  23 #include <undomanager.hxx>
  24
  25 #include <svl/sharedstringpool.hxx>
  26
  27 namespace {
  28
  29 struct PaintListener : public SfxListener
  30 {
  31     bool mbPaintAllMergedCell = false;
  32     virtual void Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint) override
  33     {
  34         const ScPaintHint* pPaintHint = dynamic_cast<const ScPaintHint*>(&rHint);
  35         if (pPaintHint)
  36         {
  37             if (pPaintHint->GetStartCol() == 0 && pPaintHint->GetEndCol() == 0
  38                 && pPaintHint->GetStartRow() == 0 && pPaintHint->GetEndRow() == 1)
  39             {
  40                 mbPaintAllMergedCell = true;
  41             }
  42         }
  43     }
  44 };
  45
  46 struct ScDataBarLengthData
  47 {
  48     double nVal;
  49     double nLength;
  50 };
  51
  52 void testDataBarLengthImpl(ScDocument* pDoc, const ScDataBarLengthData* pData, const ScRange& rRange,
  53         double nMinVal, ScColorScaleEntryType eMinType,
  54         double nMaxVal, ScColorScaleEntryType eMaxType,
  55         double nZeroPos, databar::ScAxisPosition eAxisPos)
  56 {
  57     std::unique_ptr<ScConditionalFormat> pFormat(new ScConditionalFormat(1, pDoc));
  58     ScRangeList aRangeList(rRange);
  59     pFormat->SetRange(aRangeList);
  60
  61     SCCOL nCol = rRange.aStart.Col();
  62
  63     ScDataBarFormat* pDatabar = new ScDataBarFormat(pDoc);
  64     pFormat->AddEntry(pDatabar);
  65
  66     ScDataBarFormatData* pFormatData = new ScDataBarFormatData();
  67     pFormatData->meAxisPosition = eAxisPos;
  68
  69     pFormatData->mpLowerLimit.reset(new ScColorScaleEntry());
  70     pFormatData->mpLowerLimit->SetValue(nMinVal);
  71     pFormatData->mpLowerLimit->SetType(eMinType);
  72     pFormatData->mpUpperLimit.reset(new ScColorScaleEntry());
  73     pFormatData->mpUpperLimit->SetValue(nMaxVal);
  74     pFormatData->mpUpperLimit->SetType(eMaxType);
  75     pDatabar->SetDataBarData(pFormatData);
  76
  77     for (size_t i = 0; pData[i].nLength != -200; ++i)
  78     {
  79         pDoc->SetValue(nCol, i, 0, pData[i].nVal);
  80     }
  81
  82     for (size_t i = 0; pData[i].nLength != -200; ++i)
  83     {
  84         std::unique_ptr<ScDataBarInfo> xInfo(pDatabar->GetDataBarInfo(ScAddress(nCol, i, 0)));
  85         CPPUNIT_ASSERT(xInfo);
  86         ASSERT_DOUBLES_EQUAL(pData[i].nLength, xInfo->mnLength);
  87         ASSERT_DOUBLES_EQUAL(nZeroPos, xInfo->mnZero);
  88     }
  89 }
  90
  91 sal_uInt32 addSingleCellCondFormat(ScDocument* pDoc, const ScAddress& rAddr, sal_uInt32 nKey, const OUString& rCondition)
  92 {
  93     auto pFormat = std::make_unique<ScConditionalFormat>(nKey, pDoc);
  94     ScRange aCondFormatRange(rAddr);
  95     ScRangeList aRangeList(aCondFormatRange);
  96     pFormat->SetRange(aRangeList);
  97
  98     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct, rCondition, "",
  99             *pDoc, ScAddress(0,0,0), ScResId(STR_STYLENAME_RESULT));
 100     pFormat->AddEntry(pEntry);
 101     return pDoc->AddCondFormat(std::move(pFormat), 0);
 102 }
 103
 104 }
 105
 106 class TestCondformat : public ScUcalcTestBase
 107 {
 108 };
 109
 110 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatINSDEL)
 111 {
 112     // fdo#62206
 113     m_pDoc->InsertTab(0, "Test");
 114     ScConditionalFormatList* pList = m_pDoc->GetCondFormList(0);
 115
 116     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 117     ScRangeList aRangeList(ScRange(0,0,0,0,3,0));
 118     pFormat->SetRange(aRangeList);
 119     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 120     pFormat->AddEntry(pEntry);
 121
 122     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
 123     auto pFormatTmp = pFormat.get();
 124     pList->InsertNew(std::move(pFormat));
 125
 126     m_pDoc->InsertCol(0,0,m_pDoc->MaxRow(),0,0,2);
 127     const ScRangeList& rRange = pFormatTmp->GetRange();
 128     CPPUNIT_ASSERT_EQUAL(static_cast<const ScRangeList&>(ScRange(2,0,0,2,3,0)), rRange);
 129
 130     OUString aExpr = pEntry->GetExpression(ScAddress(2,0,0), 0);
 131     CPPUNIT_ASSERT_EQUAL(OUString("D2"), aExpr);
 132
 133     m_pDoc->DeleteTab(0);
 134 }
 135
 136 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatInsertCol)
 137 {
 138     m_pDoc->InsertTab(0, "Test");
 139     ScConditionalFormatList* pList = m_pDoc->GetCondFormList(0);
 140
 141     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 142     ScRangeList aRangeList(ScRange(0,0,0,3,3,0));
 143     pFormat->SetRange(aRangeList);
 144
 145     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 146     pFormat->AddEntry(pEntry);
 147
 148     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
 149     auto pFormatTmp = pFormat.get();
 150     pList->InsertNew(std::move(pFormat));
 151
 152     m_pDoc->InsertCol(0,0,m_pDoc->MaxRow(),0,4,2);
 153     const ScRangeList& rRange = pFormatTmp->GetRange();
 154     CPPUNIT_ASSERT_EQUAL(ScRangeList(ScRange(0,0,0,5,3,0)), rRange);
 155
 156     m_pDoc->DeleteTab(0);
 157 }
 158
 159 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatInsertRow)
 160 {
 161     m_pDoc->InsertTab(0, "Test");
 162     ScConditionalFormatList* pList = m_pDoc->GetCondFormList(0);
 163
 164     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 165     ScRangeList aRangeList(ScRange(0,0,0,3,3,0));
 166     pFormat->SetRange(aRangeList);
 167
 168     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 169     pFormat->AddEntry(pEntry);
 170
 171     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
 172     auto pFormatTmp = pFormat.get();
 173     pList->InsertNew(std::move(pFormat));
 174
 175     m_pDoc->InsertRow(0,0,m_pDoc->MaxCol(),0,4,2);
 176     const ScRangeList& rRange = pFormatTmp->GetRange();
 177     CPPUNIT_ASSERT_EQUAL(ScRangeList(ScRange(0,0,0,3,5,0)), rRange);
 178
 179     m_pDoc->DeleteTab(0);
 180 }
 181
 182 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatInsertDeleteSheets)
 183 {
 184     m_pDoc->InsertTab(0, "Test");
 185
 186     // Add a conditional format to B2:B4.
 187     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 188     pFormat->SetRange(ScRange(1,1,0,1,3,0));
 189
 190     auto pFormatTmp = pFormat.get();
 191     sal_uLong nKey = m_pDoc->AddCondFormat(std::move(pFormat), 0);
 192
 193     // Add condition in which if the value equals 2, set the "Result" style.
 194     ScCondFormatEntry* pEntry = new ScCondFormatEntry(
 195         ScConditionMode::Equal, "=2", "" , *m_pDoc, ScAddress(0,0,0), ScResId(STR_STYLENAME_RESULT));
 196     pFormatTmp->AddEntry(pEntry);
 197
 198     // Apply the format to the range.
 199     m_pDoc->AddCondFormatData(pFormatTmp->GetRange(), 0, nKey);
 200
 201     // Make sure this conditional format entry is really there.
 202     ScConditionalFormatList* pList = m_pDoc->GetCondFormList(0);
 203     CPPUNIT_ASSERT(pList);
 204     const ScConditionalFormat* pCheck = pList->GetFormat(nKey);
 205     CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong conditional format instance.", pCheck, const_cast<const ScConditionalFormat*>(pFormatTmp));
 206
 207     // ... and its range is B2:B4.
 208     ScRangeList aCheckRange = pCheck->GetRange();
 209     CPPUNIT_ASSERT_EQUAL_MESSAGE("This should be a single range.", size_t(1), aCheckRange.size());
 210     const ScRange* pRange = &aCheckRange[0];
 211     CPPUNIT_ASSERT(pRange);
 212     CPPUNIT_ASSERT_EQUAL_MESSAGE("Format should be applied to B2:B4.", ScRange(1,1,0,1,3,0), *pRange);
 213
 214     ScDocFunc& rFunc = m_xDocShell->GetDocFunc();
 215
 216     // Insert a new sheet at the left.
 217     bool bInserted = rFunc.InsertTable(0, "Inserted", true, true);
 218     CPPUNIT_ASSERT(bInserted);
 219
 220     pList = m_pDoc->GetCondFormList(1);
 221     CPPUNIT_ASSERT(pList);
 222     pCheck = pList->GetFormat(nKey);
 223     CPPUNIT_ASSERT(pCheck);
 224
 225     // Make sure the range also got shifted.
 226     aCheckRange = pCheck->GetRange();
 227     CPPUNIT_ASSERT_EQUAL_MESSAGE("This should be a single range.", size_t(1), aCheckRange.size());
 228     pRange = &aCheckRange[0];
 229     CPPUNIT_ASSERT(pRange);
 230     CPPUNIT_ASSERT_EQUAL_MESSAGE("Format should be applied to B2:B4 on the 2nd sheet after the sheet insertion.", ScRange(1,1,1,1,3,1), *pRange);
 231
 232     // Delete the sheet to the left.
 233     bool bDeleted = rFunc.DeleteTable(0, true);
 234     CPPUNIT_ASSERT(bDeleted);
 235
 236     pList = m_pDoc->GetCondFormList(0);
 237     CPPUNIT_ASSERT(pList);
 238     pCheck = pList->GetFormat(nKey);
 239     CPPUNIT_ASSERT(pCheck);
 240
 241     // Make sure the range got shifted back.
 242     aCheckRange = pCheck->GetRange();
 243     CPPUNIT_ASSERT_EQUAL_MESSAGE("This should be a single range.", size_t(1), aCheckRange.size());
 244     pRange = &aCheckRange[0];
 245     CPPUNIT_ASSERT(pRange);
 246     CPPUNIT_ASSERT_EQUAL_MESSAGE("Format should be applied to B2:B4 on the 1st sheet after the sheet removal.", ScRange(1,1,0,1,3,0), *pRange);
 247
 248     SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
 249     CPPUNIT_ASSERT(pUndoMgr);
 250
 251     // Undo and re-check.
 252     pUndoMgr->Undo();
 253
 254     pList = m_pDoc->GetCondFormList(1);
 255     CPPUNIT_ASSERT(pList);
 256     pCheck = pList->GetFormat(nKey);
 257     CPPUNIT_ASSERT(pCheck);
 258
 259     aCheckRange = pCheck->GetRange();
 260     CPPUNIT_ASSERT_EQUAL_MESSAGE("This should be a single range.", size_t(1), aCheckRange.size());
 261     pRange = &aCheckRange[0];
 262     CPPUNIT_ASSERT(pRange);
 263     CPPUNIT_ASSERT_EQUAL_MESSAGE("Format should be applied to B2:B4 on the 2nd sheet after the undo of the sheet removal.", ScRange(1,1,1,1,3,1), *pRange);
 264
 265 #if 0 // TODO : Undo of sheet insertion currently depends on the presence of
 266       // view shell, and crashes when executed during cppunit run.
 267
 268     // Undo again and re-check.
 269     pUndoMgr->Undo();
 270
 271     pList = m_pDoc->GetCondFormList(0);
 272     CPPUNIT_ASSERT(pList);
 273     pCheck = pList->GetFormat(nKey);
 274     CPPUNIT_ASSERT(pCheck);
 275
 276     // Make sure the range got shifted back.
 277     aCheckRange = pCheck->GetRange();
 278     CPPUNIT_ASSERT_MESSAGE("This should be a single range.", aCheckRange.size() == 1);
 279     pRange = aCheckRange[0];
 280     CPPUNIT_ASSERT(pRange);
 281     CPPUNIT_ASSERT_MESSAGE("Format should be applied to B2:B4 on the 1st sheet after the undo of sheet insertion.", *pRange == ScRange(1,1,0,1,3,0));
 282 #else
 283     m_pDoc->DeleteTab(1);
 284 #endif
 285
 286     m_pDoc->DeleteTab(0);
 287 }
 288
 289 CPPUNIT_TEST_FIXTURE(TestCondformat, testDataBarCondCopyPaste)
 290 {
 291     m_pDoc->InsertTab(0, "Test");
 292
 293     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 294     ScRange aCondFormatRange(0, 0, 0, 2, 0, 0);
 295     ScRangeList aRangeList(aCondFormatRange);
 296     pFormat->SetRange(aRangeList);
 297
 298     ScDataBarFormat* pDatabar = new ScDataBarFormat(m_pDoc);
 299     ScDataBarFormatData* pFormatData = new ScDataBarFormatData();
 300     pFormatData->meAxisPosition = databar::AUTOMATIC;
 301     pFormatData->maPositiveColor = COL_BLUE;
 302     pFormatData->mxNegativeColor = COL_GREEN;
 303     pFormatData->mbGradient = true;
 304
 305     pDatabar->SetDataBarData(pFormatData);
 306     pFormat->AddEntry(pDatabar);
 307
 308     sal_uLong nIndex = m_pDoc->AddCondFormat(std::move(pFormat), 0);
 309
 310     ScDocument aClipDoc(SCDOCMODE_CLIP);
 311     copyToClip(m_pDoc, aCondFormatRange, &aClipDoc);
 312
 313     ScRange aTargetRange(0, 3, 0, 2, 3, 0);
 314     pasteFromClip(m_pDoc, aTargetRange, &aClipDoc);
 315
 316     // Pasting the same conditional format must modify existing format, making its range
 317     // combined of previous range and newly pasted range having the conditional format.
 318     // No new conditional formats must be created.
 319     CPPUNIT_ASSERT_EQUAL(size_t(1), m_pDoc->GetCondFormList(0)->size());
 320     aRangeList.Join(aTargetRange);
 321     for (SCCOL nCol = 0; nCol < 3; ++nCol)
 322     {
 323         ScConditionalFormat* pPastedFormat = m_pDoc->GetCondFormat(nCol, 3, 0);
 324         CPPUNIT_ASSERT(pPastedFormat);
 325         CPPUNIT_ASSERT_EQUAL(aRangeList, pPastedFormat->GetRange());
 326
 327         sal_uLong nPastedKey = pPastedFormat->GetKey();
 328         CPPUNIT_ASSERT_EQUAL(nIndex, nPastedKey);
 329
 330         const SfxPoolItem* pItem = m_pDoc->GetAttr(nCol, 3, 0, ATTR_CONDITIONAL);
 331         const ScCondFormatItem* pCondFormatItem = static_cast<const ScCondFormatItem*>(pItem);
 332         CPPUNIT_ASSERT(pCondFormatItem);
 333         CPPUNIT_ASSERT_EQUAL(size_t(1), pCondFormatItem->GetCondFormatData().size());
 334         CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pCondFormatItem->GetCondFormatData().front());
 335     }
 336
 337     m_pDoc->DeleteTab(0);
 338 }
 339
 340 CPPUNIT_TEST_FIXTURE(TestCondformat, testColorScaleInMergedCell)
 341 {
 342     m_pDoc->InsertTab(0, "Test");
 343     m_pDoc->SetValue(ScAddress(0, 0, 0), 1.0);
 344
 345     // Add a conditional format to A1.
 346     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 347     pFormat->SetRange(ScRange(0, 0, 0, 0, 0, 0));
 348     auto pFormatTmp = pFormat.get();
 349     sal_uLong nKey = m_pDoc->AddCondFormat(std::move(pFormat), 0);
 350
 351     // Add color scale entries.
 352     // The coloring is based on the value. (BLUE (x <= 0), GREEN (x == 1), RED (x >= 2))
 353     ScColorScaleFormat* pColorScaleFormat = new ScColorScaleFormat(m_pDoc);
 354     ScColorScaleEntry* pEntryBlue = new ScColorScaleEntry(0, COL_BLUE);
 355     ScColorScaleEntry* pEntryGreen = new ScColorScaleEntry(1, COL_GREEN);
 356     ScColorScaleEntry* pEntryRed = new ScColorScaleEntry(2, COL_RED);
 357     pColorScaleFormat->AddEntry(pEntryBlue);
 358     pColorScaleFormat->AddEntry(pEntryGreen);
 359     pColorScaleFormat->AddEntry(pEntryRed);
 360
 361     pFormatTmp->AddEntry(pColorScaleFormat);
 362
 363     // Apply the format to the range.
 364     m_pDoc->AddCondFormatData(pFormatTmp->GetRange(), 0, nKey);
 365
 366     m_pDoc->DoMerge(0, 0, 0, 1, 0);  // A1:A2
 367     CPPUNIT_ASSERT(m_pDoc->IsMerged(ScAddress(0, 0, 0)));
 368
 369     ScTableInfo aTabInfo(0, 2, false);
 370     m_pDoc->FillInfo(aTabInfo, 0, 0, 0, 1, 0, 1, 1, false, false);
 371     RowInfo* pRowInfo = aTabInfo.mpRowInfo.get();
 372
 373     RowInfo* pRowInfoA1 = &pRowInfo[1];
 374     ScCellInfo* pCellInfoA1 = &pRowInfoA1->cellInfo(0);
 375     // Check if there is a color scale in A1.
 376     CPPUNIT_ASSERT_EQUAL_MESSAGE("There is no color scale in cell A1!", true,
 377                                  pCellInfoA1->mxColorScale.has_value());
 378
 379     RowInfo* pRowInfoA2 = &pRowInfo[2];
 380     ScCellInfo* pCellInfoA2 = &pRowInfoA2->cellInfo(0);
 381     // Check if there is a color scale in A2.
 382     CPPUNIT_ASSERT_EQUAL_MESSAGE("There is no color scale in cell A2!", true,
 383                                  pCellInfoA2->mxColorScale.has_value());
 384
 385     // Check that cells A1 and A2 have the same color scale. (GREEN)
 386     CPPUNIT_ASSERT(pCellInfoA1->mxColorScale.value().IsRGBEqual(pCellInfoA2->mxColorScale.value()));
 387
 388     m_pDoc->DeleteTab(0);
 389 }
 390
 391
 392 CPPUNIT_TEST_FIXTURE(TestCondformat, testColorScaleCondCopyPaste)
 393 {
 394     m_pDoc->InsertTab(0, "Test");
 395
 396     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 397     ScRange aCondFormatRange(0, 0, 0, 2, 0, 0);
 398     ScRangeList aRangeList(aCondFormatRange);
 399     pFormat->SetRange(aRangeList);
 400
 401     ScColorScaleFormat* pColorScaleFormat = new ScColorScaleFormat(m_pDoc);
 402     ScColorScaleEntry* pEntryBlue = new ScColorScaleEntry(0, COL_BLUE);
 403     ScColorScaleEntry* pEntryGreen = new ScColorScaleEntry(1, COL_GREEN);
 404     ScColorScaleEntry* pEntryRed = new ScColorScaleEntry(2, COL_RED);
 405     pColorScaleFormat->AddEntry(pEntryBlue);
 406     pColorScaleFormat->AddEntry(pEntryGreen);
 407     pColorScaleFormat->AddEntry(pEntryRed);
 408
 409     pFormat->AddEntry(pColorScaleFormat);
 410     sal_uLong nIndex = m_pDoc->AddCondFormat(std::move(pFormat), 0);
 411
 412     ScDocument aClipDoc(SCDOCMODE_CLIP);
 413     copyToClip(m_pDoc, aCondFormatRange, &aClipDoc);
 414
 415     ScRange aTargetRange(0, 3, 0, 2, 3, 0);
 416     pasteFromClip(m_pDoc, aTargetRange, &aClipDoc);
 417
 418     // Pasting the same conditional format must modify existing format, making its range
 419     // combined of previous range and newly pasted range having the conditional format.
 420     // No new conditional formats must be created.
 421     CPPUNIT_ASSERT_EQUAL(size_t(1), m_pDoc->GetCondFormList(0)->size());
 422     aRangeList.Join(aTargetRange);
 423     for (SCCOL nCol = 0; nCol < 3; ++nCol)
 424     {
 425         ScConditionalFormat* pPastedFormat = m_pDoc->GetCondFormat(nCol, 3, 0);
 426         CPPUNIT_ASSERT(pPastedFormat);
 427         CPPUNIT_ASSERT_EQUAL(aRangeList, pPastedFormat->GetRange());
 428
 429         sal_uLong nPastedKey = pPastedFormat->GetKey();
 430         CPPUNIT_ASSERT_EQUAL(nIndex, nPastedKey);
 431
 432         const SfxPoolItem* pItem = m_pDoc->GetAttr(nCol, 3, 0, ATTR_CONDITIONAL);
 433         const ScCondFormatItem* pCondFormatItem = static_cast<const ScCondFormatItem*>(pItem);
 434         CPPUNIT_ASSERT(pCondFormatItem);
 435         CPPUNIT_ASSERT_EQUAL(size_t(1), pCondFormatItem->GetCondFormatData().size());
 436         CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pCondFormatItem->GetCondFormatData().front());
 437     }
 438
 439     m_pDoc->DeleteTab(0);
 440 }
 441
 442 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondCopyPaste)
 443 {
 444     m_pDoc->InsertTab(0, "Test");
 445
 446     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 447     ScRange aCondFormatRange(0,0,0,3,3,0);
 448     ScRangeList aRangeList(aCondFormatRange);
 449     pFormat->SetRange(aRangeList);
 450
 451     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 452     pFormat->AddEntry(pEntry);
 453     sal_uLong nIndex = m_pDoc->AddCondFormat(std::move(pFormat), 0);
 454
 455     ScDocument aClipDoc(SCDOCMODE_CLIP);
 456     copyToClip(m_pDoc, aCondFormatRange, &aClipDoc);
 457
 458     ScRange aTargetRange(4,4,0,7,7,0);
 459     pasteFromClip(m_pDoc, aTargetRange, &aClipDoc);
 460
 461     ScConditionalFormat* pPastedFormat = m_pDoc->GetCondFormat(7,7,0);
 462     CPPUNIT_ASSERT(pPastedFormat);
 463
 464     // Pasting the same conditional format must modify existing format, making its range
 465     // combined of previous range and newly pasted range having the conditional format.
 466     // No new conditional formats must be created.
 467     CPPUNIT_ASSERT_EQUAL(size_t(1), m_pDoc->GetCondFormList(0)->size());
 468     aRangeList.Join(aTargetRange);
 469     CPPUNIT_ASSERT_EQUAL(aRangeList, pPastedFormat->GetRange());
 470     CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pPastedFormat->GetKey());
 471     const SfxPoolItem* pItem = m_pDoc->GetAttr( 7, 7, 0, ATTR_CONDITIONAL );
 472     const ScCondFormatItem* pCondFormatItem = static_cast<const ScCondFormatItem*>(pItem);
 473
 474     CPPUNIT_ASSERT(pCondFormatItem);
 475     CPPUNIT_ASSERT_EQUAL(size_t(1), pCondFormatItem->GetCondFormatData().size());
 476     CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pCondFormatItem->GetCondFormatData().front());
 477
 478     m_pDoc->DeleteTab(0);
 479 }
 480
 481 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondCopyPasteSingleCell)
 482 {
 483     //e.g. fdo#82503
 484     m_pDoc->InsertTab(0, "Test");
 485
 486     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 487     ScRange aCondFormatRange(0,0,0,3,3,0);
 488     ScRangeList aRangeList(aCondFormatRange);
 489     pFormat->SetRange(aRangeList);
 490
 491     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 492     pFormat->AddEntry(pEntry);
 493     sal_uLong nIndex = m_pDoc->AddCondFormat(std::move(pFormat), 0);
 494
 495     ScDocument aClipDoc(SCDOCMODE_CLIP);
 496     copyToClip(m_pDoc, ScRange(0,0,0,0,0,0), &aClipDoc);
 497
 498     ScRange aTargetRange(4,4,0,4,4,0);
 499     pasteOneCellFromClip(m_pDoc, aTargetRange, &aClipDoc);
 500
 501     ScConditionalFormat* pPastedFormat = m_pDoc->GetCondFormat(4,4,0);
 502     CPPUNIT_ASSERT(pPastedFormat);
 503
 504     // Pasting the same conditional format must modify existing format, making its range
 505     // combined of previous range and newly pasted range having the conditional format.
 506     // No new conditional formats must be created.
 507     CPPUNIT_ASSERT_EQUAL(size_t(1), m_pDoc->GetCondFormList(0)->size());
 508     aRangeList.Join(aTargetRange);
 509     CPPUNIT_ASSERT_EQUAL(aRangeList, pPastedFormat->GetRange());
 510     CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pPastedFormat->GetKey());
 511     const SfxPoolItem* pItem = m_pDoc->GetAttr( 4, 4, 0, ATTR_CONDITIONAL );
 512     const ScCondFormatItem* pCondFormatItem = static_cast<const ScCondFormatItem*>(pItem);
 513
 514     CPPUNIT_ASSERT(pCondFormatItem);
 515     CPPUNIT_ASSERT_EQUAL(size_t(1), pCondFormatItem->GetCondFormatData().size());
 516     CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pCondFormatItem->GetCondFormatData().front() );
 517
 518     m_pDoc->DeleteTab(0);
 519 }
 520
 521 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondCopyPasteSingleCellToRange)
 522 {
 523     //e.g. fdo#82503
 524     m_pDoc->InsertTab(0, "Test");
 525
 526     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 527     ScRange aCondFormatRange(0,0,0,3,3,0);
 528     ScRangeList aRangeList(aCondFormatRange);
 529     pFormat->SetRange(aRangeList);
 530
 531     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 532     pFormat->AddEntry(pEntry);
 533     sal_uLong nIndex = m_pDoc->AddCondFormat(std::move(pFormat), 0);
 534
 535     ScDocument aClipDoc(SCDOCMODE_CLIP);
 536     copyToClip(m_pDoc, ScRange(0,0,0,0,0,0), &aClipDoc);
 537     ScRange aTargetRange(4,4,0,5,8,0);
 538     pasteOneCellFromClip(m_pDoc, aTargetRange, &aClipDoc);
 539
 540     // Pasting the same conditional format must modify existing format, making its range
 541     // combined of previous range and newly pasted range having the conditional format.
 542     // No new conditional formats must be created.
 543     CPPUNIT_ASSERT_EQUAL(size_t(1), m_pDoc->GetCondFormList(0)->size());
 544     aRangeList.Join(aTargetRange);
 545     for(SCROW nRow = 4; nRow <= 8; ++nRow)
 546     {
 547         for (SCCOL nCol = 4; nCol <= 5; ++nCol)
 548         {
 549             ScConditionalFormat* pPastedFormat = m_pDoc->GetCondFormat(nCol, nRow, 0);
 550             CPPUNIT_ASSERT(pPastedFormat);
 551
 552             CPPUNIT_ASSERT_EQUAL(aRangeList, pPastedFormat->GetRange());
 553             sal_uLong nPastedKey = pPastedFormat->GetKey();
 554             CPPUNIT_ASSERT_EQUAL(nIndex, nPastedKey);
 555             const SfxPoolItem* pItem = m_pDoc->GetAttr( nCol, nRow, 0, ATTR_CONDITIONAL );
 556             const ScCondFormatItem* pCondFormatItem = static_cast<const ScCondFormatItem*>(pItem);
 557
 558             CPPUNIT_ASSERT(pCondFormatItem);
 559             CPPUNIT_ASSERT_EQUAL(size_t(1), pCondFormatItem->GetCondFormatData().size());
 560             CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pCondFormatItem->GetCondFormatData().front() );
 561         }
 562     }
 563
 564     m_pDoc->DeleteTab(0);
 565 }
 566
 567 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondCopyPasteSingleCellIntoSameFormatRange)
 568 {
 569     // e.g., tdf#95295
 570     m_pDoc->InsertTab(0, "Test");
 571
 572     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 573     ScRange aCondFormatRange(0, 0, 0, 3, 3, 0);
 574     ScRangeList aRangeList(aCondFormatRange);
 575     pFormat->SetRange(aRangeList);
 576
 577     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct, "=B2", "", *m_pDoc, ScAddress(0, 0, 0), ScResId(STR_STYLENAME_RESULT));
 578     pFormat->AddEntry(pEntry);
 579     sal_uLong nIndex = m_pDoc->AddCondFormat(std::move(pFormat), 0);
 580
 581     ScDocument aClipDoc(SCDOCMODE_CLIP);
 582     copyToClip(m_pDoc, ScRange(1, 1, 0, 1, 1, 0), &aClipDoc);
 583
 584     ScRange aTargetRange(2, 2, 0, 2, 2, 0);
 585     pasteFromClip(m_pDoc, aTargetRange, &aClipDoc);
 586
 587     ScConditionalFormat* pPastedFormat = m_pDoc->GetCondFormat(2, 2, 0);
 588     CPPUNIT_ASSERT(pPastedFormat);
 589
 590     // Pasting the same conditional format into the same range must not modify existing format,
 591     // since it already covers the pasted range. No new conditional formats must be created.
 592     CPPUNIT_ASSERT_EQUAL(size_t(1), m_pDoc->GetCondFormList(0)->size());
 593     CPPUNIT_ASSERT_EQUAL(aRangeList, pPastedFormat->GetRange());
 594     CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pPastedFormat->GetKey());
 595     const SfxPoolItem* pItem = m_pDoc->GetAttr(2, 2, 0, ATTR_CONDITIONAL);
 596     const ScCondFormatItem* pCondFormatItem = static_cast<const ScCondFormatItem*>(pItem);
 597
 598     CPPUNIT_ASSERT(pCondFormatItem);
 599     CPPUNIT_ASSERT_EQUAL(size_t(1), pCondFormatItem->GetCondFormatData().size());
 600     CPPUNIT_ASSERT_EQUAL(sal_uInt32(nIndex), pCondFormatItem->GetCondFormatData().front());
 601
 602     m_pDoc->DeleteTab(0);
 603 }
 604
 605 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondCopyPasteSingleRowToRange)
 606 {
 607     //e.g. tdf#106242
 608     m_pDoc->InsertTab(0, "Test");
 609
 610     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 611     ScRange aCondFormatRange(0,0,0,0,0,0);
 612     ScRangeList aRangeList(aCondFormatRange);
 613     pFormat->SetRange(aRangeList);
 614
 615     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 616     pFormat->AddEntry(pEntry);
 617     auto pFormatTmp = pFormat.get();
 618     m_pDoc->AddCondFormat(std::move(pFormat), 0);
 619
 620     ScDocument aClipDoc(SCDOCMODE_CLIP);
 621     copyToClip(m_pDoc, ScRange(0,0,0,m_pDoc->MaxCol(),0,0), &aClipDoc);
 622     ScRange aTargetRange(0,4,0,m_pDoc->MaxCol(),4,0);
 623     pasteOneCellFromClip(m_pDoc, aTargetRange, &aClipDoc);
 624
 625     ScConditionalFormat* pNewFormat = m_pDoc->GetCondFormat(0, 4, 0);
 626     CPPUNIT_ASSERT(pNewFormat);
 627     CPPUNIT_ASSERT_EQUAL(pNewFormat->GetKey(), pFormatTmp->GetKey());
 628
 629     for (SCCOL nCol = 1; nCol <= m_pDoc->MaxCol(); ++nCol)
 630     {
 631         ScConditionalFormat* pNewFormat2 = m_pDoc->GetCondFormat(nCol, 4, 0);
 632         CPPUNIT_ASSERT(!pNewFormat2);
 633     }
 634
 635     m_pDoc->DeleteTab(0);
 636 }
 637
 638 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondCopyPasteSingleRowToRange2)
 639 {
 640     m_pDoc->InsertTab(0, "Test");
 641
 642     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 643     ScRange aCondFormatRange(0,0,0,0,0,0);
 644     ScRangeList aRangeList(aCondFormatRange);
 645     pFormat->SetRange(aRangeList);
 646
 647     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 648     pFormat->AddEntry(pEntry);
 649     m_pDoc->AddCondFormat(std::move(pFormat), 0);
 650
 651     ScDocument aClipDoc(SCDOCMODE_CLIP);
 652     copyToClip(m_pDoc, ScRange(0,0,0,3,0,0), &aClipDoc);
 653     ScRange aTargetRange(0,4,0,m_pDoc->MaxCol(),4,0);
 654     pasteOneCellFromClip(m_pDoc, aTargetRange, &aClipDoc);
 655
 656     for (SCCOL nCol = 0; nCol <= m_pDoc->MaxCol(); ++nCol)
 657     {
 658         ScConditionalFormat* pNewFormat = m_pDoc->GetCondFormat(nCol, 4, 0);
 659         if (nCol % 4 == 0)
 660             CPPUNIT_ASSERT(pNewFormat);
 661         else
 662             CPPUNIT_ASSERT(!pNewFormat);
 663     }
 664
 665     m_pDoc->DeleteTab(0);
 666 }
 667
 668 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondCopyPasteSheetBetweenDoc)
 669 {
 670     m_pDoc->InsertTab(0, "Test");
 671
 672     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 673     ScRange aCondFormatRange(0,0,0,3,3,0);
 674     ScRangeList aRangeList(aCondFormatRange);
 675     pFormat->SetRange(aRangeList);
 676
 677     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 678     pFormat->AddEntry(pEntry);
 679     m_pDoc->AddCondFormat(std::move(pFormat), 0);
 680
 681     ScDocument aDoc;
 682     aDoc.TransferTab(*m_pDoc, 0, 0);
 683
 684     ScConditionalFormatList* pList = aDoc.GetCondFormList(0);
 685     CPPUNIT_ASSERT_EQUAL(size_t(1), pList->size());
 686
 687     m_pDoc->DeleteTab(0);
 688 }
 689
 690 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondCopyPasteSheet)
 691 {
 692     m_pDoc->InsertTab(0, "Test");
 693
 694     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 695     ScRange aCondFormatRange(0,0,0,3,3,0);
 696     ScRangeList aRangeList(aCondFormatRange);
 697     pFormat->SetRange(aRangeList);
 698
 699     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Direct,"=B2","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
 700     pFormat->AddEntry(pEntry);
 701     m_pDoc->AddCondFormat(std::move(pFormat), 0);
 702
 703     m_pDoc->CopyTab(0, SC_TAB_APPEND);
 704
 705     ScConditionalFormatList* pList = m_pDoc->GetCondFormList(1);
 706     CPPUNIT_ASSERT_EQUAL(size_t(1), pList->size());
 707
 708     ScConditionalFormat& rFormat = **pList->begin();
 709     const ScRangeList& rRange = rFormat.GetRange();
 710     CPPUNIT_ASSERT_EQUAL(ScRangeList(ScRange(0,0,1,3,3,1)), rRange);
 711     sal_uInt32 nKey = rFormat.GetKey();
 712     const SfxPoolItem* pItem = m_pDoc->GetAttr( 2, 2, 1, ATTR_CONDITIONAL );
 713     const ScCondFormatItem* pCondFormatItem = static_cast<const ScCondFormatItem*>(pItem);
 714
 715     CPPUNIT_ASSERT(pCondFormatItem);
 716     CPPUNIT_ASSERT_EQUAL(size_t(1), pCondFormatItem->GetCondFormatData().size());
 717     CPPUNIT_ASSERT_EQUAL( nKey, pCondFormatItem->GetCondFormatData().front() );
 718
 719     m_pDoc->DeleteTab(1);
 720     m_pDoc->DeleteTab(0);
 721 }
 722
 723 CPPUNIT_TEST_FIXTURE(TestCondformat, testIconSet)
 724 {
 725     m_pDoc->InsertTab(0, "Test");
 726     ScConditionalFormatList* pList = m_pDoc->GetCondFormList(0);
 727
 728     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
 729     ScRangeList aRangeList(ScRange(0,0,0,0,0,0));
 730     pFormat->SetRange(aRangeList);
 731
 732     ScIconSetFormat* pEntry = new ScIconSetFormat(m_pDoc);
 733     ScIconSetFormatData* pData = new ScIconSetFormatData;
 734     pData->m_Entries.emplace_back(new ScColorScaleEntry(0, COL_BLUE));
 735     pData->m_Entries.emplace_back(new ScColorScaleEntry(1, COL_GREEN));
 736     pData->m_Entries.emplace_back(new ScColorScaleEntry(2, COL_RED));
 737     pEntry->SetIconSetData(pData);
 738
 739     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
 740     pList->InsertNew(std::move(pFormat));
 741
 742     static struct {
 743         double nVal; sal_Int32 nIndex;
 744     } const aTests[] = {
 745         { -1.0, 0 },
 746         { 0.0, 0 },
 747         { 1.0, 1 },
 748         { 2.0, 2 },
 749         { 3.0, 2 }
 750     };
 751     for(size_t i = 0; i < SAL_N_ELEMENTS(aTests); ++i)
 752     {
 753         m_pDoc->SetValue(0,0,0,aTests[i].nVal);
 754         std::unique_ptr<ScIconSetInfo> pInfo = pEntry->GetIconSetInfo(ScAddress(0,0,0));
 755         CPPUNIT_ASSERT_EQUAL(aTests[i].nIndex, pInfo->nIconIndex);
 756     }
 757
 758     delete pEntry;
 759     m_pDoc->DeleteTab(0);
 760 }
 761
 762 CPPUNIT_TEST_FIXTURE(TestCondformat, testDataBarLengthAutomaticAxis)
 763 {
 764     m_pDoc->InsertTab(0, "Test");
 765
 766     static const ScDataBarLengthData aValues[] = {
 767         { 2, 0 },
 768         { 3, 0 },
 769         { 4, 25.0 },
 770         { 5, 50.0 },
 771         { 6, 75.0 },
 772         { 7, 100.0 },
 773         { 8, 100.0 },
 774         { 9, 100.0 },
 775         { 0, -200 }
 776     };
 777
 778     testDataBarLengthImpl(m_pDoc, aValues, ScRange(0,0,0,0,7,0),
 779             3, COLORSCALE_VALUE, 7, COLORSCALE_VALUE, 0.0, databar::AUTOMATIC);
 780
 781     static const ScDataBarLengthData aValues2[] = {
 782         { -6, -100 },
 783         { -5, -100 },
 784         { -4, -100 },
 785         { -3, -75.0 },
 786         { -2, -50.0 },
 787         { -1, -25.0 },
 788         { 0, 0.0 },
 789         { 1, 12.5 },
 790         { 2, 25.0 },
 791         { 3, 37.5 },
 792         { 4, 50.0 },
 793         { 5, 62.5 },
 794         { 6, 75.0 },
 795         { 7, 87.5 },
 796         { 8, 100.0 },
 797         { 9, 100.0 },
 798         { 0, -200 }
 799     };
 800     testDataBarLengthImpl(m_pDoc, aValues2, ScRange(1,0,0,1,15,0),
 801             -4, COLORSCALE_VALUE, 8, COLORSCALE_VALUE, 1.0/3.0 * 100, databar::AUTOMATIC);
 802
 803     static const ScDataBarLengthData aValues3[] = {
 804         { 2, 0.0 },
 805         { 3, 25.0 },
 806         { 4, 50.0 },
 807         { 6, 100.0 },
 808         { 0, -200 }
 809     };
 810     testDataBarLengthImpl(m_pDoc, aValues3, ScRange(2,0,0,2,3,0),
 811             0, COLORSCALE_MIN, 0, COLORSCALE_MAX, 0, databar::AUTOMATIC);
 812
 813     static const ScDataBarLengthData aValues4[] = {
 814         { 2, 40.0 },
 815         { 3, 60.0 },
 816         { 4, 80.0 },
 817         { 5, 100.0 },
 818         { 0, -200 }
 819     };
 820     testDataBarLengthImpl(m_pDoc, aValues4, ScRange(3,0,0,3,3,0),
 821             0, COLORSCALE_AUTO, 0, COLORSCALE_AUTO, 0, databar::AUTOMATIC);
 822
 823     m_pDoc->DeleteTab(0);
 824 }
 825
 826 CPPUNIT_TEST_FIXTURE(TestCondformat, testDataBarLengthMiddleAxis)
 827 {
 828     m_pDoc->InsertTab(0, "Test");
 829
 830     static const ScDataBarLengthData aValues[] = {
 831         { 1, 25.0 },
 832         { 2, 25.0 },
 833         { 3, 37.5 },
 834         { 4, 50.0 },
 835         { 5, 62.5 },
 836         { 6, 75.0 },
 837         { 7, 87.5 },
 838         { 8, 100.0 },
 839         { 9, 100.0 },
 840         { 0, -200 }
 841     };
 842
 843     testDataBarLengthImpl(m_pDoc, aValues, ScRange(0,0,0,0,8,0),
 844             2, COLORSCALE_VALUE, 8, COLORSCALE_VALUE, 50.0, databar::MIDDLE);
 845
 846     static const ScDataBarLengthData aValues2[] = {
 847         { -6, -50 },
 848         { -5, -50 },
 849         { -4, -50 },
 850         { -3, -37.5 },
 851         { -2, -25.0 },
 852         { -1, -12.5 },
 853         { 0, 0.0 },
 854         { 1, 12.5 },
 855         { 2, 25.0 },
 856         { 3, 37.5 },
 857         { 4, 50.0 },
 858         { 5, 62.5 },
 859         { 6, 75.0 },
 860         { 7, 87.5 },
 861         { 8, 100.0 },
 862         { 9, 100.0 },
 863         { 0, -200 }
 864     };
 865     testDataBarLengthImpl(m_pDoc, aValues2, ScRange(1,0,0,1,15,0),
 866             -4, COLORSCALE_VALUE, 8, COLORSCALE_VALUE, 50.0, databar::MIDDLE);
 867
 868     m_pDoc->DeleteTab(0);
 869 }
 870
 871 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatEndsWithStr)
 872 {
 873     m_pDoc->InsertTab(0, "Test");
 874
 875     // case insensitive matching
 876     ScConditionEntry aEntry(ScConditionMode::EndsWith, "\"teststring\"", "", *m_pDoc, ScAddress(),
 877             "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 878
 879     svl::SharedStringPool& rStringPool = m_pDoc->GetSharedStringPool();
 880     svl::SharedString aStr = rStringPool.intern("SimpleTestString");
 881     ScRefCellValue aVal(&aStr);
 882     ScAddress aPos(0, 0, 0);
 883
 884     bool bValid = aEntry.IsCellValid(aVal, aPos);
 885     CPPUNIT_ASSERT(bValid);
 886
 887     m_pDoc->DeleteTab(0);
 888 }
 889
 890 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatEndsWithVal)
 891 {
 892     m_pDoc->InsertTab(0, "Test");
 893
 894     ScConditionEntry aEntry(ScConditionMode::EndsWith, "2", "", *m_pDoc, ScAddress(),
 895             "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
 896
 897     for (sal_Int32 i = 0; i < 15; ++i)
 898     {
 899         ScRefCellValue aVal(i);
 900         ScAddress aPos(0, 0, 0);
 901
 902         bool bValid = aEntry.IsCellValid(aVal, aPos);
 903         bool bShouldBeValid = (i % 10) == 2;
 904         CPPUNIT_ASSERT_EQUAL(bShouldBeValid, bValid);
 905     }
 906
 907     m_pDoc->DeleteTab(0);
 908 }
 909
 910 CPPUNIT_TEST_FIXTURE(TestCondformat, testFormulaListenerSingleCellToSingleCell)
 911 {
 912     m_pDoc->InsertTab(0, "test");
 913
 914     ScCompiler aCompiler(*m_pDoc, ScAddress(10, 10, 0), formula::FormulaGrammar::GRAM_ENGLISH);
 915
 916     std::unique_ptr<ScTokenArray> pTokenArray(aCompiler.CompileString("A1"));
 917
 918     ScFormulaListener aListener(*m_pDoc);
 919
 920     aListener.addTokenArray(pTokenArray.get(), ScAddress(10, 10, 0));
 921
 922     m_pDoc->SetValue(ScAddress(0, 0, 0), 1.0);
 923     CPPUNIT_ASSERT(aListener.NeedsRepaint());
 924
 925     m_pDoc->DeleteTab(0);
 926 }
 927
 928 CPPUNIT_TEST_FIXTURE(TestCondformat, testFormulaListenerSingleCellToMultipleCells)
 929 {
 930     m_pDoc->InsertTab(0, "test");
 931
 932     ScCompiler aCompiler(*m_pDoc, ScAddress(10, 10, 0), formula::FormulaGrammar::GRAM_ENGLISH);
 933
 934     std::unique_ptr<ScTokenArray> pTokenArray(aCompiler.CompileString("A1"));
 935
 936     ScFormulaListener aListener(*m_pDoc);
 937
 938     aListener.addTokenArray(pTokenArray.get(), ScAddress(10, 10, 0));
 939
 940     m_pDoc->SetValue(ScAddress(0, 0, 0), 1.0);
 941     CPPUNIT_ASSERT(aListener.NeedsRepaint());
 942
 943     m_pDoc->DeleteTab(0);
 944 }
 945
 946 CPPUNIT_TEST_FIXTURE(TestCondformat, testFormulaListenerMultipleCellsToSingleCell)
 947 {
 948     m_pDoc->InsertTab(0, "test");
 949
 950     ScCompiler aCompiler(*m_pDoc, ScAddress(10, 10, 0), formula::FormulaGrammar::GRAM_ENGLISH);
 951
 952     std::unique_ptr<ScTokenArray> pTokenArray(aCompiler.CompileString("A1"));
 953
 954     ScFormulaListener aListener(*m_pDoc);
 955
 956     aListener.addTokenArray(pTokenArray.get(), ScAddress(10, 10, 0));
 957
 958     m_pDoc->SetValue(ScAddress(0, 0, 0), 1.0);
 959     CPPUNIT_ASSERT(aListener.NeedsRepaint());
 960
 961     m_pDoc->DeleteTab(0);
 962 }
 963
 964 CPPUNIT_TEST_FIXTURE(TestCondformat, testFormulaListenerMultipleCellsToMultipleCells)
 965 {
 966     m_pDoc->InsertTab(0, "test");
 967
 968     ScCompiler aCompiler(*m_pDoc, ScAddress(10, 10, 0), formula::FormulaGrammar::GRAM_ENGLISH);
 969
 970     std::unique_ptr<ScTokenArray> pTokenArray(aCompiler.CompileString("A1"));
 971
 972     ScFormulaListener aListener(*m_pDoc);
 973
 974     aListener.addTokenArray(pTokenArray.get(), ScAddress(10, 10, 0));
 975
 976     m_pDoc->SetValue(ScAddress(0, 0, 0), 1.0);
 977     CPPUNIT_ASSERT(aListener.NeedsRepaint());
 978
 979     m_pDoc->DeleteTab(0);
 980 }
 981
 982 CPPUNIT_TEST_FIXTURE(TestCondformat, testFormulaListenerUpdateInsertTab)
 983 {
 984     m_pDoc->InsertTab(0, "test");
 985
 986     ScCompiler aCompiler(*m_pDoc, ScAddress(10, 10, 0), formula::FormulaGrammar::GRAM_ENGLISH);
 987     std::unique_ptr<ScTokenArray> pTokenArray(aCompiler.CompileString("A1"));
 988
 989     ScFormulaListener aListener(*m_pDoc);
 990     aListener.addTokenArray(pTokenArray.get(), ScAddress(10, 10, 0));
 991     CPPUNIT_ASSERT(!aListener.NeedsRepaint());
 992
 993     m_pDoc->InsertTab(0, "new_tab");
 994
 995     // check that the listener has moved to the new sheet
 996     m_pDoc->SetValue(ScAddress(0, 0, 1), 1.0);
 997     CPPUNIT_ASSERT(aListener.NeedsRepaint());
 998
 999     // check that we are not listening to the old sheet
1000     m_pDoc->SetValue(ScAddress(0, 0, 0), 1.0);
1001     CPPUNIT_ASSERT(!aListener.NeedsRepaint());
1002
1003     m_pDoc->DeleteTab(0);
1004 }
1005
1006 CPPUNIT_TEST_FIXTURE(TestCondformat, testFormulaListenerUpdateDeleteTab)
1007 {
1008     m_pDoc->InsertTab(0, "test");
1009     m_pDoc->InsertTab(0, "to_delete");
1010
1011     ScCompiler aCompiler(*m_pDoc, ScAddress(10, 10, 1), formula::FormulaGrammar::GRAM_ENGLISH);
1012     std::unique_ptr<ScTokenArray> pTokenArray(aCompiler.CompileString("A1"));
1013
1014     ScFormulaListener aListener(*m_pDoc);
1015     aListener.addTokenArray(pTokenArray.get(), ScAddress(10, 10, 1));
1016     CPPUNIT_ASSERT(!aListener.NeedsRepaint());
1017
1018     m_pDoc->DeleteTab(0);
1019
1020     // check that the listener has moved
1021     m_pDoc->SetValue(ScAddress(0, 0, 0), 1.0);
1022     CPPUNIT_ASSERT(aListener.NeedsRepaint());
1023
1024     m_pDoc->DeleteTab(0);
1025 }
1026
1027 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatUpdateMoveTab)
1028 {
1029     m_pDoc->InsertTab(0, "test");
1030     m_pDoc->InsertTab(1, "Test2");
1031
1032     ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "A1", "", *m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
1033
1034     auto pFormat = std::make_unique<ScConditionalFormat>(0, m_pDoc);
1035     pFormat->SetRange(ScRange(10, 10, 0, 10, 12, 0));
1036     auto pFormatTmp = pFormat.get();
1037     m_pDoc->AddCondFormat(std::move(pFormat), 0);
1038
1039     pFormatTmp->AddEntry(pEntry);
1040
1041     // the conditional format should listen to A1:A3
1042     for (SCROW nRow = 0; nRow < 3; ++nRow)
1043     {
1044         m_pDoc->SetValue(ScAddress(0, nRow, 0), 1.0);
1045         CPPUNIT_ASSERT(pEntry->NeedsRepaint());
1046     }
1047
1048     m_pDoc->MoveTab(0, 1);
1049
1050     // the conditional format should listen to A1:A3 on the second sheet
1051     for (SCROW nRow = 0; nRow < 3; ++nRow)
1052     {
1053         m_pDoc->SetValue(ScAddress(0, nRow, 1), 1.0);
1054         CPPUNIT_ASSERT(pEntry->NeedsRepaint());
1055
1056         m_pDoc->SetValue(ScAddress(0, nRow, 0), 1.0);
1057         CPPUNIT_ASSERT(!pEntry->NeedsRepaint());
1058     }
1059
1060     m_pDoc->DeleteTab(1);
1061     m_pDoc->DeleteTab(0);
1062 }
1063
1064 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatUpdateInsertTab)
1065 {
1066     m_pDoc->InsertTab(0, "test");
1067
1068     ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "A1", "", *m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
1069
1070     auto pFormat = std::make_unique<ScConditionalFormat>(0, m_pDoc);
1071     pFormat->SetRange(ScRange(10, 10, 0, 10, 12, 0));
1072     auto pFormatTmp = pFormat.get();
1073     m_pDoc->AddCondFormat(std::move(pFormat), 0);
1074
1075     pFormatTmp->AddEntry(pEntry);
1076
1077     // the conditional format should listen to A1:A3
1078     for (SCROW nRow = 0; nRow < 3; ++nRow)
1079     {
1080         m_pDoc->SetValue(ScAddress(0, nRow, 0), 1.0);
1081         CPPUNIT_ASSERT(pEntry->NeedsRepaint());
1082
1083         m_pDoc->SetValue(ScAddress(0, nRow, 1), 1.0);
1084         CPPUNIT_ASSERT(!pEntry->NeedsRepaint());
1085     }
1086
1087     m_pDoc->InsertTab(0, "test2");
1088
1089     // the conditional format should listen to A1:A3 on the second sheet
1090     for (SCROW nRow = 0; nRow < 3; ++nRow)
1091     {
1092         m_pDoc->SetValue(ScAddress(0, nRow, 1), 1.0);
1093         CPPUNIT_ASSERT(pEntry->NeedsRepaint());
1094
1095         m_pDoc->SetValue(ScAddress(0, nRow, 0), 1.0);
1096         CPPUNIT_ASSERT(!pEntry->NeedsRepaint());
1097     }
1098
1099     m_pDoc->DeleteTab(1);
1100     m_pDoc->DeleteTab(0);
1101 }
1102
1103 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatUpdateDeleteTab)
1104 {
1105     m_pDoc->InsertTab(0, "test");
1106     m_pDoc->InsertTab(1, "Test2");
1107
1108     ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "A1", "", *m_pDoc, ScAddress(10, 10, 1), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
1109
1110     auto pFormat = std::make_unique<ScConditionalFormat>(0, m_pDoc);
1111     pFormat->SetRange(ScRange(10, 10, 1, 10, 12, 1));
1112     auto pFormatTmp = pFormat.get();
1113     m_pDoc->AddCondFormat(std::move(pFormat), 1);
1114
1115     pFormatTmp->AddEntry(pEntry);
1116
1117     // the conditional format should listen to A1:A3 on the second sheet
1118     for (SCROW nRow = 0; nRow < 3; ++nRow)
1119     {
1120         m_pDoc->SetValue(ScAddress(0, nRow, 1), 1.0);
1121         CPPUNIT_ASSERT(pEntry->NeedsRepaint());
1122     }
1123
1124     m_pDoc->DeleteTab(0);
1125
1126     // the conditional format should listen to A1:A3 on the second sheet
1127     for (SCROW nRow = 0; nRow < 3; ++nRow)
1128     {
1129         m_pDoc->SetValue(ScAddress(0, nRow, 0), 1.0);
1130         CPPUNIT_ASSERT(pEntry->NeedsRepaint());
1131     }
1132
1133     m_pDoc->DeleteTab(0);
1134 }
1135
1136 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatUpdateReference)
1137 {
1138     m_pDoc->InsertTab(0, "test");
1139     m_pDoc->InsertTab(1, "Test2");
1140
1141     ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "A1", "", *m_pDoc, ScAddress(10, 10, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
1142
1143     auto pFormat = std::make_unique<ScConditionalFormat>(0, m_pDoc);
1144     pFormat->SetRange(ScRange(10, 10, 0, 10, 12, 0));
1145     auto pFormatTmp = pFormat.get();
1146     m_pDoc->AddCondFormat(std::move(pFormat), 0);
1147
1148     pFormatTmp->AddEntry(pEntry);
1149
1150     // the conditional format should listen to A1:A3
1151     for (SCROW nRow = 0; nRow < 3; ++nRow)
1152     {
1153         m_pDoc->SetValue(ScAddress(0, nRow, 0), 1.0);
1154         CPPUNIT_ASSERT(pEntry->NeedsRepaint());
1155     }
1156
1157     m_pDoc->DeleteTab(1);
1158     m_pDoc->DeleteTab(0);
1159 }
1160
1161 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatUpdateReferenceDelRow)
1162 {
1163     m_pDoc->InsertTab(0, "test");
1164
1165     ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "B6", "", *m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
1166
1167     auto pFormat = std::make_unique<ScConditionalFormat>(0, m_pDoc);
1168     pFormat->SetRange(ScRange(0, 5, 0, 0, 5, 0));
1169     auto pFormatTmp = pFormat.get();
1170     m_pDoc->AddCondFormat(std::move(pFormat), 0);
1171
1172     pFormatTmp->AddEntry(pEntry);
1173
1174     m_pDoc->DeleteRow(0, 0, m_pDoc->MaxCol(), 0, 4, 1);
1175
1176     OUString aStr = pEntry->GetExpression(ScAddress(0, 4, 0), 0);
1177     CPPUNIT_ASSERT_EQUAL(OUString("B5"), aStr);
1178
1179     m_pDoc->DeleteTab(0);
1180 }
1181
1182 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatUpdateReferenceInsRow)
1183 {
1184     m_pDoc->InsertTab(0, "test");
1185
1186     ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "B6", "", *m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
1187
1188     auto pFormat = std::make_unique<ScConditionalFormat>(0, m_pDoc);
1189     pFormat->SetRange(ScRange(0, 5, 0, 0, 5, 0));
1190     auto pFormatTmp = pFormat.get();
1191     m_pDoc->AddCondFormat(std::move(pFormat), 0);
1192
1193     pFormatTmp->AddEntry(pEntry);
1194
1195     m_pDoc->InsertRow(0, 0, m_pDoc->MaxCol(), 0, 4, 1);
1196
1197     OUString aStr = pEntry->GetExpression(ScAddress(0, 6, 0), 0);
1198     CPPUNIT_ASSERT_EQUAL(OUString("B7"), aStr);
1199
1200     m_pDoc->DeleteTab(0);
1201 }
1202
1203 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatUndoList)
1204 {
1205     m_pDoc->InsertTab(0, "test");
1206
1207     ScConditionEntry* pEntry = new ScConditionEntry(ScConditionMode::Equal, "B6", "", *m_pDoc, ScAddress(0, 5, 0), "", "", formula::FormulaGrammar::GRAM_DEFAULT, formula::FormulaGrammar::GRAM_DEFAULT);
1208
1209     auto pFormat = std::make_unique<ScConditionalFormat>(0, m_pDoc);
1210     pFormat->AddEntry(pEntry);
1211     pFormat->SetRange(ScRange(0, 0, 0, 0, 5, 0));
1212     auto pFormatTmp = pFormat.get();
1213     m_pDoc->AddCondFormat(std::move(pFormat), 0);
1214     m_pDoc->AddCondFormatData(pFormatTmp->GetRange(), 0, pFormatTmp->GetKey());
1215
1216     ScDocFunc& rFunc = m_xDocShell->GetDocFunc();
1217
1218     CPPUNIT_ASSERT_EQUAL(size_t(1), m_pDoc->GetCondFormList(0)->size());
1219     for (SCROW nRow = 0; nRow <= 5; ++nRow)
1220         CPPUNIT_ASSERT(m_pDoc->GetCondFormat(0, nRow, 0));
1221
1222     ScConditionalFormatList* pNewList = new ScConditionalFormatList();
1223
1224     rFunc.SetConditionalFormatList(pNewList, 0);
1225
1226     CPPUNIT_ASSERT_EQUAL(size_t(0), m_pDoc->GetCondFormList(0)->size());
1227     for (SCROW nRow = 0; nRow <= 5; ++nRow)
1228         CPPUNIT_ASSERT(!m_pDoc->GetCondFormat(0, nRow, 0));
1229
1230     m_pDoc->GetUndoManager()->Undo();
1231
1232     CPPUNIT_ASSERT_EQUAL(size_t(1), m_pDoc->GetCondFormList(0)->size());
1233     for (SCROW nRow = 0; nRow <= 5; ++nRow)
1234         CPPUNIT_ASSERT(m_pDoc->GetCondFormat(0, nRow, 0));
1235
1236     m_pDoc->GetUndoManager()->Redo();
1237
1238     CPPUNIT_ASSERT_EQUAL(size_t(0), m_pDoc->GetCondFormList(0)->size());
1239     for (SCROW nRow = 0; nRow <= 5; ++nRow)
1240         CPPUNIT_ASSERT(!m_pDoc->GetCondFormat(0, nRow, 0));
1241
1242     m_pDoc->DeleteTab(0);
1243 }
1244
1245 CPPUNIT_TEST_FIXTURE(TestCondformat, testMultipleSingleCellCondFormatCopyPaste)
1246 {
1247     m_pDoc->InsertTab(0, "Test");
1248
1249     sal_uInt32 nFirstCondFormatKey = addSingleCellCondFormat(m_pDoc, ScAddress(0, 0, 0), 1, "=A2");
1250     sal_uInt32 nSecondCondFormatKey = addSingleCellCondFormat(m_pDoc, ScAddress(1, 0, 0), 2, "=B3");
1251
1252     ScDocument aClipDoc(SCDOCMODE_CLIP);
1253     copyToClip(m_pDoc, ScRange(0,0,0,2,0,0), &aClipDoc);
1254     ScRange aTargetRange(2,4,0,7,4,0);
1255     pasteOneCellFromClip(m_pDoc, aTargetRange, &aClipDoc);
1256
1257     for (SCCOL nCol = 2; nCol <= 7; ++nCol)
1258     {
1259         ScConditionalFormat* pFormat = m_pDoc->GetCondFormat(nCol, 4, 0);
1260         if (((nCol - 2) % 3) == 0)
1261         {
1262             CPPUNIT_ASSERT_EQUAL(pFormat->GetKey(), nFirstCondFormatKey);
1263         }
1264         else if (((nCol - 2) % 3) == 1)
1265         {
1266             CPPUNIT_ASSERT_EQUAL(pFormat->GetKey(), nSecondCondFormatKey);
1267         }
1268         else
1269         {
1270             CPPUNIT_ASSERT(!pFormat);
1271         }
1272     }
1273
1274     m_pDoc->DeleteTab(0);
1275 }
1276
1277 CPPUNIT_TEST_FIXTURE(TestCondformat, testDeduplicateMultipleCondFormats)
1278 {
1279     m_pDoc->InsertTab(0, "Test");
1280
1281     sal_uInt32 nFirstCondFormatKey = addSingleCellCondFormat(m_pDoc, ScAddress(0, 0, 0), 1, "=B2");
1282     sal_uInt32 nSecondCondFormatKey = addSingleCellCondFormat(m_pDoc, ScAddress(1, 0, 0), 2, "=B2");
1283
1284     ScDocument aClipDoc(SCDOCMODE_CLIP);
1285     copyToClip(m_pDoc, ScRange(0,0,0,2,0,0), &aClipDoc);
1286     ScRange aTargetRange(2,4,0,7,4,0);
1287     pasteOneCellFromClip(m_pDoc, aTargetRange, &aClipDoc);
1288
1289     for (SCCOL nCol = 2; nCol <= 7; ++nCol)
1290     {
1291         ScConditionalFormat* pFormat = m_pDoc->GetCondFormat(nCol, 4, 0);
1292         if (((nCol - 2) % 3) == 0)
1293         {
1294             CPPUNIT_ASSERT_EQUAL(pFormat->GetKey(), nFirstCondFormatKey);
1295         }
1296         else if (((nCol - 2) % 3) == 1)
1297         {
1298             CPPUNIT_ASSERT_EQUAL(pFormat->GetKey(), nSecondCondFormatKey);
1299         }
1300         else
1301         {
1302             CPPUNIT_ASSERT(!pFormat);
1303         }
1304     }
1305
1306     m_pDoc->DeleteTab(0);
1307 }
1308
1309 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatListenToOwnRange)
1310 {
1311     m_pDoc->InsertTab(0, "Test");
1312
1313     ScConditionalFormatList* pList = m_pDoc->GetCondFormList(0);
1314
1315     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
1316     ScRangeList aRangeList(ScRange(0,0,0,10,0,0));
1317     pFormat->SetRange(aRangeList);
1318
1319     ScIconSetFormat* pEntry = new ScIconSetFormat(m_pDoc);
1320     ScIconSetFormatData* pData = new ScIconSetFormatData;
1321     pData->m_Entries.emplace_back(new ScColorScaleEntry(0, COL_BLUE));
1322     pData->m_Entries.emplace_back(new ScColorScaleEntry(1, COL_GREEN));
1323     pData->m_Entries.emplace_back(new ScColorScaleEntry(2, COL_RED));
1324     pEntry->SetIconSetData(pData);
1325     pEntry->SetParent(pFormat.get());
1326
1327     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
1328     pFormat->AddEntry(pEntry);
1329     pList->InsertNew(std::move(pFormat));
1330
1331     bool bFirstCallbackCalled = false;
1332     std::function<void()> aFirstCallback = [&]() {bFirstCallbackCalled = true;};
1333     pData->m_Entries[0]->SetType(COLORSCALE_PERCENT);
1334     pData->m_Entries[0]->SetRepaintCallback(aFirstCallback);
1335
1336     m_pDoc->SetValue(0, 0, 0, -1.0);
1337
1338     CPPUNIT_ASSERT(bFirstCallbackCalled);
1339
1340     m_pDoc->DeleteTab(0);
1341 }
1342
1343 CPPUNIT_TEST_FIXTURE(TestCondformat, testCondFormatVolatileFunctionRecalc)
1344 {
1345     m_pDoc->InsertTab(0, "Test");
1346
1347     m_pDoc->SetValue(0, 0, 0, 0.5);
1348
1349     ScConditionalFormatList* pList = m_pDoc->GetCondFormList(0);
1350
1351     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
1352     ScRangeList aRangeList(ScRange(0,0,0,10,0,0));
1353     pFormat->SetRange(aRangeList);
1354
1355     ScCondFormatEntry* pEntry = new ScCondFormatEntry(ScConditionMode::Greater,"RAND()","",*m_pDoc,ScAddress(0,0,0),ScResId(STR_STYLENAME_RESULT));
1356     pEntry->SetParent(pFormat.get());
1357
1358     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
1359     pFormat->AddEntry(pEntry);
1360     auto pFormatTmp = pFormat.get();
1361     pList->InsertNew(std::move(pFormat));
1362
1363     ScRefCellValue aCell(*m_pDoc, ScAddress(0, 0, 0));
1364     bool bValid = pEntry->IsCellValid(aCell, ScAddress(0, 0, 0));
1365
1366     bool bNewValid = bValid;
1367     // chance of a random failure is 0.5^100, anyone hitting that will get a beer from me
1368     for (size_t i = 0; i < 100; ++i)
1369     {
1370         pFormatTmp->CalcAll();
1371         bNewValid = pEntry->IsCellValid(aCell, ScAddress(0, 0, 0));
1372
1373         if (bValid != bNewValid)
1374             break;
1375     }
1376
1377     CPPUNIT_ASSERT(bValid != bNewValid);
1378
1379     m_pDoc->DeleteTab(0);
1380 }
1381
1382 CPPUNIT_TEST_FIXTURE(TestCondformat, testConditionStyleInMergedCell)
1383 {
1384     m_pDoc->InsertTab(0, "Test");
1385
1386     PaintListener aListener;
1387     aListener.StartListening(*m_xDocShell);
1388
1389     m_pDoc->DoMerge(0, 0, 0, 1, 0); // A1:A2
1390     CPPUNIT_ASSERT(m_pDoc->IsMerged(ScAddress(0, 0, 0)));
1391
1392     m_pDoc->SetValue(ScAddress(0, 0, 0), 1.0);
1393
1394     // Add a conditional format.
1395     auto pFormat = std::make_unique<ScConditionalFormat>(1, m_pDoc);
1396     pFormat->SetRange(ScRange(0, 0, 0, 0, 0, 0));
1397
1398     // Add condition in which if the value equals 1, set the "Good" style.
1399     ScCondFormatEntry* pEntry = new ScCondFormatEntry(
1400         ScConditionMode::Equal, "=1", "", *m_pDoc, ScAddress(0, 0, 0), ScResId(STR_STYLENAME_GOOD));
1401     pFormat->AddEntry(pEntry);
1402
1403     // Apply the format to the range.
1404     m_pDoc->AddCondFormatData(pFormat->GetRange(), 0, 1);
1405
1406     ScDocFunc& rFunc = m_xDocShell->GetDocFunc();
1407     sal_uInt32 nOldFormat = pFormat->GetKey();
1408     const ScRangeList& rRangeList = pFormat->GetRange();
1409     rFunc.ReplaceConditionalFormat(nOldFormat, std::move(pFormat), 0, rRangeList);
1410
1411     CPPUNIT_ASSERT_EQUAL(true, aListener.mbPaintAllMergedCell);
1412
1413     m_pDoc->DeleteTab(0);
1414 }
1415
1416 CPPUNIT_PLUGIN_IMPLEMENT();
1417
1418 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */