diff options
Diffstat (limited to '')
| -rw-r--r-- | sc/qa/unit/ucalc.cxx | 7151 |
1 files changed, 7151 insertions, 0 deletions
diff --git a/sc/qa/unit/ucalc.cxx b/sc/qa/unit/ucalc.cxx new file mode 100644 index 000000000..d3fa93c52 --- /dev/null +++ b/sc/qa/unit/ucalc.cxx @@ -0,0 +1,7151 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include "ucalc.hxx" +#include "helper/debughelper.hxx" +#include "helper/qahelper.hxx" + +#include <sal/config.h> +#include <test/bootstrapfixture.hxx> + +#include <svl/asiancfg.hxx> +#include <svl/gridprinter.hxx> + +#include <scdll.hxx> +#include <formulacell.hxx> +#include <simpleformulacalc.hxx> +#include <stringutil.hxx> +#include <scmatrix.hxx> +#include <drwlayer.hxx> +#include <scitems.hxx> +#include <reffind.hxx> +#include <markdata.hxx> +#include <clipparam.hxx> +#include <refundo.hxx> +#include <undoblk.hxx> +#include <undotab.hxx> +#include <queryentry.hxx> +#include <postit.hxx> +#include <attrib.hxx> +#include <dbdata.hxx> +#include <reftokenhelper.hxx> +#include <userdat.hxx> +#include <clipcontext.hxx> +#include <refdata.hxx> + +#include <docsh.hxx> +#include <docfunc.hxx> +#include <funcdesc.hxx> + +#include <calcconfig.hxx> +#include <columniterator.hxx> +#include <types.hxx> +#include <tokenarray.hxx> +#include <scopetools.hxx> +#include <dociter.hxx> +#include <queryparam.hxx> +#include <edittextiterator.hxx> +#include <editutil.hxx> +#include <cellform.hxx> +#include <asciiopt.hxx> +#include <impex.hxx> +#include <docoptio.hxx> +#include <patattr.hxx> +#include <docpool.hxx> +#include <globalnames.hxx> +#include <inputopt.hxx> +#include <columnspanset.hxx> + +#include <editable.hxx> +#include <bcaslot.hxx> +#include <sharedformula.hxx> +#include <tabprotection.hxx> +#include <scmod.hxx> + +#include <formula/IFunctionDescription.hxx> + +#include <basegfx/polygon/b2dpolygon.hxx> +#include <editeng/borderline.hxx> +#include <editeng/boxitem.hxx> +#include <editeng/brushitem.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/wghtitem.hxx> +#include <editeng/postitem.hxx> + +#include <svx/svdpage.hxx> +#include <svx/svdocirc.hxx> +#include <svx/svdopath.hxx> +#include <svx/svdocapt.hxx> +#include <svl/srchitem.hxx> +#include <svl/sharedstringpool.hxx> +#include <unotools/collatorwrapper.hxx> + +#include <sfx2/docfile.hxx> +#include <sfx2/sfxsids.hrc> + +#include <iostream> +#include <memory> +#include <vector> + +struct TestImpl +{ + ScDocShellRef m_xDocShell; +}; + +FormulaGrammarSwitch::FormulaGrammarSwitch(ScDocument* pDoc, formula::FormulaGrammar::Grammar eGrammar) : + mpDoc(pDoc), meOldGrammar(pDoc->GetGrammar()) +{ + mpDoc->SetGrammar(eGrammar); +} + +FormulaGrammarSwitch::~FormulaGrammarSwitch() +{ + mpDoc->SetGrammar(meOldGrammar); +} + +Test::Test() : + m_pImpl(new TestImpl), + m_pDoc(nullptr) +{ +} + +Test::~Test() +{ +} + +ScDocShell& Test::getDocShell() +{ + return *m_pImpl->m_xDocShell; +} + +void Test::getNewDocShell( ScDocShellRef& rDocShellRef ) +{ + rDocShellRef = new ScDocShell( + SfxModelFlags::EMBEDDED_OBJECT | + SfxModelFlags::DISABLE_EMBEDDED_SCRIPTS | + SfxModelFlags::DISABLE_DOCUMENT_RECOVERY); + + rDocShellRef->SetIsInUcalc(); + rDocShellRef->DoInitUnitTest(); +} + +void Test::closeDocShell( ScDocShellRef& rDocShellRef ) +{ + rDocShellRef->DoClose(); + rDocShellRef.clear(); +} + +void Test::setUp() +{ + BootstrapFixture::setUp(); + + ScDLL::Init(); + + getNewDocShell(m_pImpl->m_xDocShell); + m_pDoc = &m_pImpl->m_xDocShell->GetDocument(); +} + +void Test::tearDown() +{ + closeDocShell(m_pImpl->m_xDocShell); + BootstrapFixture::tearDown(); +} + +void Test::testCollator() +{ + CollatorWrapper* p = ScGlobal::GetCollator(); + sal_Int32 nRes = p->compareString("A", "B"); + CPPUNIT_ASSERT_MESSAGE("these strings are supposed to be different!", nRes != 0); +} + +void Test::testSharedStringPool() +{ + m_pDoc->InsertTab(0, "foo"); + + // Strings that are identical. + m_pDoc->SetString(ScAddress(0,0,0), "Andy"); // A1 + m_pDoc->SetString(ScAddress(0,1,0), "Andy"); // A2 + m_pDoc->SetString(ScAddress(0,2,0), "Bruce"); // A3 + m_pDoc->SetString(ScAddress(0,3,0), "andy"); // A4 + m_pDoc->SetString(ScAddress(0,4,0), "BRUCE"); // A5 + + { + // These two shared string objects must go out of scope before the purge test. + svl::SharedString aSS1 = m_pDoc->GetSharedString(ScAddress(0,0,0)); + svl::SharedString aSS2 = m_pDoc->GetSharedString(ScAddress(0,1,0)); + CPPUNIT_ASSERT_MESSAGE("Failed to get a valid shared string.", aSS1.isValid()); + CPPUNIT_ASSERT_MESSAGE("Failed to get a valid shared string.", aSS2.isValid()); + CPPUNIT_ASSERT_EQUAL(aSS1.getData(), aSS2.getData()); + + aSS2 = m_pDoc->GetSharedString(ScAddress(0,2,0)); + CPPUNIT_ASSERT_MESSAGE("They must differ", aSS1.getData() != aSS2.getData()); + + aSS2 = m_pDoc->GetSharedString(ScAddress(0,3,0)); + CPPUNIT_ASSERT_MESSAGE("They must differ", aSS1.getData() != aSS2.getData()); + + aSS2 = m_pDoc->GetSharedString(ScAddress(0,4,0)); + CPPUNIT_ASSERT_MESSAGE("They must differ", aSS1.getData() != aSS2.getData()); + + // A3 and A5 should differ but should be equal case-insensitively. + aSS1 = m_pDoc->GetSharedString(ScAddress(0,2,0)); + aSS2 = m_pDoc->GetSharedString(ScAddress(0,4,0)); + CPPUNIT_ASSERT_MESSAGE("They must differ", aSS1.getData() != aSS2.getData()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("They must be equal when cases are ignored.", aSS1.getDataIgnoreCase(), aSS2.getDataIgnoreCase()); + + // A2 and A4 should be equal when ignoring cases. + aSS1 = m_pDoc->GetSharedString(ScAddress(0,1,0)); + aSS2 = m_pDoc->GetSharedString(ScAddress(0,3,0)); + CPPUNIT_ASSERT_EQUAL_MESSAGE("They must be equal when cases are ignored.", aSS1.getDataIgnoreCase(), aSS2.getDataIgnoreCase()); + } + + // Check the string counts after purging. Purging shouldn't remove any strings in this case. + svl::SharedStringPool& rPool = m_pDoc->GetSharedStringPool(); + rPool.purge(); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(5), rPool.getCount()); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), rPool.getCountIgnoreCase()); + + // Clear A1 and purge again. + clearRange(m_pDoc, ScAddress(0,0,0)); + rPool.purge(); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(5), rPool.getCount()); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), rPool.getCountIgnoreCase()); + + // Clear A2 and purge again. + clearRange(m_pDoc, ScAddress(0,1,0)); + rPool.purge(); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(4), rPool.getCount()); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), rPool.getCountIgnoreCase()); + + // Clear A3 and purge again. + clearRange(m_pDoc, ScAddress(0,2,0)); + rPool.purge(); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), rPool.getCount()); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), rPool.getCountIgnoreCase()); + + // Clear A4 and purge again. + clearRange(m_pDoc, ScAddress(0,3,0)); + rPool.purge(); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), rPool.getCount()); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), rPool.getCountIgnoreCase()); + + // Clear A5 and the pool should be completely empty. + clearRange(m_pDoc, ScAddress(0,4,0)); + rPool.purge(); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(0), rPool.getCount()); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(0), rPool.getCountIgnoreCase()); + + // Now, compare string and edit text cells. + m_pDoc->SetString(ScAddress(0,0,0), "Andy and Bruce"); // A1 + ScFieldEditEngine& rEE = m_pDoc->GetEditEngine(); + rEE.SetTextCurrentDefaults("Andy and Bruce"); + + ESelection aSel; + aSel.nStartPara = aSel.nEndPara = 0; + + { + // Set 'Andy' bold. + SfxItemSet aItemSet = rEE.GetEmptyItemSet(); + aSel.nStartPos = 0; + aSel.nEndPos = 4; + SvxWeightItem aWeight(WEIGHT_BOLD, EE_CHAR_WEIGHT); + aItemSet.Put(aWeight); + rEE.QuickSetAttribs(aItemSet, aSel); + } + + { + // Set 'Bruce' italic. + SfxItemSet aItemSet = rEE.GetEmptyItemSet(); + SvxPostureItem aItalic(ITALIC_NORMAL, EE_CHAR_ITALIC); + aItemSet.Put(aItalic); + aSel.nStartPos = 9; + aSel.nEndPos = 14; + rEE.QuickSetAttribs(aItemSet, aSel); + } + + m_pDoc->SetEditText(ScAddress(1,0,0), rEE.CreateTextObject()); // B1 + + // These two should be equal. + svl::SharedString aSS1 = m_pDoc->GetSharedString(ScAddress(0,0,0)); + svl::SharedString aSS2 = m_pDoc->GetSharedString(ScAddress(1,0,0)); + CPPUNIT_ASSERT_MESSAGE("Failed to get a valid string ID.", aSS1.isValid()); + CPPUNIT_ASSERT_MESSAGE("Failed to get a valid string ID.", aSS2.isValid()); + CPPUNIT_ASSERT_EQUAL(aSS1.getData(), aSS2.getData()); + + rEE.SetTextCurrentDefaults("ANDY and BRUCE"); + m_pDoc->SetEditText(ScAddress(2,0,0), rEE.CreateTextObject()); // C1 + aSS2 = m_pDoc->GetSharedString(ScAddress(2,0,0)); + CPPUNIT_ASSERT_MESSAGE("Failed to get a valid string ID.", aSS2.isValid()); + CPPUNIT_ASSERT_MESSAGE("These two should be different when cases are considered.", aSS1.getData() != aSS2.getData()); + + // But they should be considered equal when cases are ignored. + aSS1 = m_pDoc->GetSharedString(ScAddress(0,0,0)); + aSS2 = m_pDoc->GetSharedString(ScAddress(2,0,0)); + CPPUNIT_ASSERT_MESSAGE("Failed to get a valid string ID.", aSS1.isValid()); + CPPUNIT_ASSERT_MESSAGE("Failed to get a valid string ID.", aSS2.isValid()); + CPPUNIT_ASSERT_EQUAL(aSS1.getDataIgnoreCase(), aSS2.getDataIgnoreCase()); + + m_pDoc->DeleteTab(0); +} + +void Test::testSharedStringPoolUndoDoc() +{ + struct + { + bool check( const ScDocument& rSrcDoc, ScDocument& rCopyDoc ) + { + // Copy A1:A4 to the undo document. + for (SCROW i = 0; i <= 4; ++i) + { + ScAddress aPos(0,i,0); + rCopyDoc.SetString(aPos, rSrcDoc.GetString(aPos)); + } + + // String values in A1:A4 should have identical hash. + for (SCROW i = 0; i <= 4; ++i) + { + ScAddress aPos(0,i,0); + svl::SharedString aSS1 = rSrcDoc.GetSharedString(aPos); + svl::SharedString aSS2 = rCopyDoc.GetSharedString(aPos); + if (aSS1.getDataIgnoreCase() != aSS2.getDataIgnoreCase()) + { + cerr << "String hash values are not equal at row " << (i+1) + << " for string '" << aSS1.getString() << "'" << endl; + return false; + } + } + + return true; + } + + } aTest; + + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetString(ScAddress(0,0,0), "Header"); + m_pDoc->SetString(ScAddress(0,1,0), "A1"); + m_pDoc->SetString(ScAddress(0,2,0), "A2"); + m_pDoc->SetString(ScAddress(0,3,0), "A3"); + + ScDocument aUndoDoc(SCDOCMODE_UNDO); + aUndoDoc.InitUndo(m_pDoc, 0, 0); + + bool bSuccess = aTest.check(*m_pDoc, aUndoDoc); + CPPUNIT_ASSERT_MESSAGE("Check failed with undo document.", bSuccess); + + // Test the clip document as well. + ScDocument aClipDoc(SCDOCMODE_CLIP); + aClipDoc.ResetClip(m_pDoc, static_cast<SCTAB>(0)); + + bSuccess = aTest.check(*m_pDoc, aClipDoc); + CPPUNIT_ASSERT_MESSAGE("Check failed with clip document.", bSuccess); + + m_pDoc->DeleteTab(0); +} + +void Test::testRangeList() +{ + m_pDoc->InsertTab(0, "foo"); + + ScRangeList aRL; + aRL.push_back(ScRange(1,1,0,3,10,0)); + CPPUNIT_ASSERT_EQUAL_MESSAGE("List should have one range.", size_t(1), aRL.size()); + const ScRange* p = &aRL[0]; + CPPUNIT_ASSERT_MESSAGE("Failed to get the range object.", p); + CPPUNIT_ASSERT_MESSAGE("Wrong range.", p->aStart == ScAddress(1,1,0) && p->aEnd == ScAddress(3,10,0)); + + // TODO: Add more tests here. + + m_pDoc->DeleteTab(0); +} + +void Test::testMarkData() +{ + ScMarkData aMarkData(MAXROW, MAXCOL); + + // Empty mark. Nothing is selected. + std::vector<sc::ColRowSpan> aSpans = aMarkData.GetMarkedRowSpans(); + CPPUNIT_ASSERT_MESSAGE("Span should be empty.", aSpans.empty()); + aSpans = aMarkData.GetMarkedColSpans(); + CPPUNIT_ASSERT_MESSAGE("Span should be empty.", aSpans.empty()); + + // Select B3:F7. + aMarkData.SetMarkArea(ScRange(1,2,0,5,6,0)); + aSpans = aMarkData.GetMarkedRowSpans(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be one selected row span.", size_t(1), aSpans.size()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(2), aSpans[0].mnStart); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(6), aSpans[0].mnEnd); + + aSpans = aMarkData.GetMarkedColSpans(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be one selected column span.", size_t(1), aSpans.size()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(1), aSpans[0].mnStart); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(5), aSpans[0].mnEnd); + + // Select A11:B13. + aMarkData.SetMultiMarkArea(ScRange(0,10,0,1,12,0)); + aSpans = aMarkData.GetMarkedRowSpans(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be 2 selected row spans.", size_t(2), aSpans.size()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(2), aSpans[0].mnStart); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(6), aSpans[0].mnEnd); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(10), aSpans[1].mnStart); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(12), aSpans[1].mnEnd); + + aSpans = aMarkData.GetMarkedColSpans(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be one selected column span.", size_t(1), aSpans.size()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(0), aSpans[0].mnStart); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(5), aSpans[0].mnEnd); + + // Select C8:C10. + aMarkData.SetMultiMarkArea(ScRange(2,7,0,2,9,0)); + aSpans = aMarkData.GetMarkedRowSpans(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be one selected row span.", size_t(1), aSpans.size()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(2), aSpans[0].mnStart); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(12), aSpans[0].mnEnd); + + aSpans = aMarkData.GetMarkedColSpans(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be one selected column span.", size_t(1), aSpans.size()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(0), aSpans[0].mnStart); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOLROW>(5), aSpans[0].mnEnd); +} + +void Test::testInput() +{ + + CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", + m_pDoc->InsertTab (0, "foo")); + OUString test; + + m_pDoc->SetString(0, 0, 0, "'10.5"); + test = m_pDoc->GetString(0, 0, 0); + bool bTest = test == "10.5"; + CPPUNIT_ASSERT_MESSAGE("String number should have the first apostrophe stripped.", bTest); + m_pDoc->SetString(0, 0, 0, "'apple'"); + test = m_pDoc->GetString(0, 0, 0); + bTest = test == "'apple'"; + CPPUNIT_ASSERT_MESSAGE("Text content should have retained the first apostrophe.", bTest); + + // Customized string handling policy. + ScSetStringParam aParam; + aParam.setTextInput(); + m_pDoc->SetString(0, 0, 0, "000123", &aParam); + test = m_pDoc->GetString(0, 0, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Text content should have been treated as string, not number.", OUString("000123"), test); + + m_pDoc->DeleteTab(0); +} + +void Test::testColumnIterator() // tdf#118620 +{ + CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", + m_pDoc->InsertTab (0, "foo")); + + m_pDoc->SetString(0, 0, 0, "'10.5"); + m_pDoc->SetString(0, MAXROW-5, 0, "42.0"); + std::unique_ptr<sc::ColumnIterator> it = m_pDoc->GetColumnIterator(0, 0, MAXROW - 10, MAXROW); + while (it->hasCell()) + { + it->getCell(); + it->next(); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testDocStatistics() +{ + SCTAB nStartTabs = m_pDoc->GetTableCount(); + m_pDoc->InsertTab(0, "Sheet1"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to increment sheet count.", + static_cast<SCTAB>(nStartTabs+1), m_pDoc->GetTableCount()); + m_pDoc->InsertTab(1, "Sheet2"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to increment sheet count.", + static_cast<SCTAB>(nStartTabs+2), m_pDoc->GetTableCount()); + + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(0), m_pDoc->GetCellCount()); + m_pDoc->SetValue(ScAddress(0,0,0), 2.0); + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(1), m_pDoc->GetCellCount()); + m_pDoc->SetValue(ScAddress(2,2,0), 2.5); + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(2), m_pDoc->GetCellCount()); + m_pDoc->SetString(ScAddress(1,1,1), "Test"); + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(3), m_pDoc->GetCellCount()); + + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(0), m_pDoc->GetFormulaGroupCount()); + m_pDoc->SetString(ScAddress(3,0,1), "=A1"); + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(1), m_pDoc->GetFormulaGroupCount()); + m_pDoc->SetString(ScAddress(3,1,1), "=A2"); + m_pDoc->SetString(ScAddress(3,2,1), "=A3"); + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(1), m_pDoc->GetFormulaGroupCount()); + m_pDoc->SetString(ScAddress(3,3,1), "=A5"); + m_pDoc->SetString(ScAddress(3,4,1), "=A6"); + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(2), m_pDoc->GetFormulaGroupCount()); + m_pDoc->SetString(ScAddress(3,1,1), "=A3"); + CPPUNIT_ASSERT_EQUAL(static_cast<sal_uLong>(4), m_pDoc->GetFormulaGroupCount()); + + m_pDoc->DeleteTab(1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to decrement sheet count.", + static_cast<SCTAB>(nStartTabs+1), m_pDoc->GetTableCount()); + m_pDoc->DeleteTab(0); // This may fail in case there is only one sheet in the document. +} + +void Test::testRowForHeight() +{ + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->SetRowHeightRange( 0, 9, 0, 100); + m_pDoc->SetRowHeightRange(10, 19, 0, 200); + m_pDoc->SetRowHeightRange(20, 29, 0, 300); + + // Hide some rows. + m_pDoc->SetRowHidden(3, 5, 0, true); + m_pDoc->SetRowHidden(8, 12, 0, true); + + struct Check + { + sal_uLong nHeight; + SCROW nRow; + }; + + std::vector<Check> aChecks = { + { 1, 1 }, + { 99, 1 }, + { 120, 2 }, + { 330, 7 }, + { 420, 13 }, + { 780, 15 }, + { 1860, 20 }, + { 4020, 28 }, + }; + + for (const Check& rCheck : aChecks) + { + SCROW nRow = m_pDoc->GetRowForHeight(0, rCheck.nHeight); + CPPUNIT_ASSERT_EQUAL(rCheck.nRow, nRow); + } +} + +void Test::testDataEntries() +{ + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetString(ScAddress(0,5,0), "Andy"); + m_pDoc->SetString(ScAddress(0,6,0), "Bruce"); + m_pDoc->SetString(ScAddress(0,7,0), "Charlie"); + m_pDoc->SetString(ScAddress(0,10,0), "Andy"); + + std::vector<ScTypedStrData> aEntries; + m_pDoc->GetDataEntries(0, 0, 0, aEntries); // Try at the very top. + + // Entries are supposed to be sorted in ascending order, and are all unique. + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), aEntries.size()); + std::vector<ScTypedStrData>::const_iterator it = aEntries.begin(); + CPPUNIT_ASSERT_EQUAL(OUString("Andy"), it->GetString()); + ++it; + CPPUNIT_ASSERT_EQUAL(OUString("Bruce"), it->GetString()); + ++it; + CPPUNIT_ASSERT_EQUAL(OUString("Charlie"), it->GetString()); + ++it; + CPPUNIT_ASSERT_MESSAGE("The entries should have ended here.", bool(it == aEntries.end())); + + aEntries.clear(); + m_pDoc->GetDataEntries(0, MAXROW, 0, aEntries); // Try at the very bottom. + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), aEntries.size()); + + // Make sure we get the same set of suggestions. + it = aEntries.begin(); + CPPUNIT_ASSERT_EQUAL(OUString("Andy"), it->GetString()); + ++it; + CPPUNIT_ASSERT_EQUAL(OUString("Bruce"), it->GetString()); + ++it; + CPPUNIT_ASSERT_EQUAL(OUString("Charlie"), it->GetString()); + ++it; + CPPUNIT_ASSERT_MESSAGE("The entries should have ended here.", bool(it == aEntries.end())); + + m_pDoc->DeleteTab(0); +} + +void Test::testSelectionFunction() +{ + m_pDoc->InsertTab(0, "Test"); + + // Insert values into B2:B4. + m_pDoc->SetString(ScAddress(1,1,0), "=1"); // formula + m_pDoc->SetValue(ScAddress(1,2,0), 2.0); + m_pDoc->SetValue(ScAddress(1,3,0), 3.0); + + // Insert strings into B5:B8. + m_pDoc->SetString(ScAddress(1,4,0), "A"); + m_pDoc->SetString(ScAddress(1,5,0), "B"); + m_pDoc->SetString(ScAddress(1,6,0), "=\"C\""); // formula + m_pDoc->SetString(ScAddress(1,7,0), "D"); + + // Insert values into D2:D4. + m_pDoc->SetValue(ScAddress(3,1,0), 4.0); + m_pDoc->SetValue(ScAddress(3,2,0), 5.0); + m_pDoc->SetValue(ScAddress(3,3,0), 6.0); + + // Insert edit text into D5. + ScFieldEditEngine& rEE = m_pDoc->GetEditEngine(); + rEE.SetTextCurrentDefaults("Rich Text"); + m_pDoc->SetEditText(ScAddress(3,4,0), rEE.CreateTextObject()); + + // Insert Another string into D6. + m_pDoc->SetString(ScAddress(3,5,0), "E"); + + // Select B2:B8 & D2:D8 disjoint region. + ScRangeList aRanges; + aRanges.push_back(ScRange(1,1,0,1,7,0)); // B2:B8 + aRanges.push_back(ScRange(3,1,0,3,7,0)); // D2:D8 + ScMarkData aMark(MAXROW, MAXCOL); + aMark.MarkFromRangeList(aRanges, true); + + struct Check + { + ScSubTotalFunc meFunc; + double mfExpected; + }; + + { + static const Check aChecks[] = + { + { SUBTOTAL_FUNC_AVE, 3.5 }, + { SUBTOTAL_FUNC_CNT2, 12.0 }, + { SUBTOTAL_FUNC_CNT, 6.0 }, + { SUBTOTAL_FUNC_MAX, 6.0 }, + { SUBTOTAL_FUNC_MIN, 1.0 }, + { SUBTOTAL_FUNC_SUM, 21.0 }, + { SUBTOTAL_FUNC_SELECTION_COUNT, 14.0 } + }; + + for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i) + { + double fRes = 0.0; + bool bRes = m_pDoc->GetSelectionFunction(aChecks[i].meFunc, ScAddress(), aMark, fRes); + CPPUNIT_ASSERT_MESSAGE("Failed to fetch selection function result.", bRes); + CPPUNIT_ASSERT_EQUAL(aChecks[i].mfExpected, fRes); + } + } + + // Hide rows 4 and 6 and check the results again. + + m_pDoc->SetRowHidden(3, 3, 0, true); + m_pDoc->SetRowHidden(5, 5, 0, true); + CPPUNIT_ASSERT_MESSAGE("This row should be hidden.", m_pDoc->RowHidden(3, 0)); + CPPUNIT_ASSERT_MESSAGE("This row should be hidden.", m_pDoc->RowHidden(5, 0)); + + { + static const Check aChecks[] = + { + { SUBTOTAL_FUNC_AVE, 3.0 }, + { SUBTOTAL_FUNC_CNT2, 8.0 }, + { SUBTOTAL_FUNC_CNT, 4.0 }, + { SUBTOTAL_FUNC_MAX, 5.0 }, + { SUBTOTAL_FUNC_MIN, 1.0 }, + { SUBTOTAL_FUNC_SUM, 12.0 }, + { SUBTOTAL_FUNC_SELECTION_COUNT, 10.0 } + }; + + for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i) + { + double fRes = 0.0; + bool bRes = m_pDoc->GetSelectionFunction(aChecks[i].meFunc, ScAddress(), aMark, fRes); + CPPUNIT_ASSERT_MESSAGE("Failed to fetch selection function result.", bRes); + CPPUNIT_ASSERT_EQUAL(aChecks[i].mfExpected, fRes); + } + } + + // Make sure that when no selection is present, use the current cursor position. + ScMarkData aEmpty(MAXROW, MAXCOL); + + { + // D3 (numeric cell containing 5.) + ScAddress aPos(3, 2, 0); + + static const Check aChecks[] = + { + { SUBTOTAL_FUNC_AVE, 5.0 }, + { SUBTOTAL_FUNC_CNT2, 1.0 }, + { SUBTOTAL_FUNC_CNT, 1.0 }, + { SUBTOTAL_FUNC_MAX, 5.0 }, + { SUBTOTAL_FUNC_MIN, 5.0 }, + { SUBTOTAL_FUNC_SUM, 5.0 }, + { SUBTOTAL_FUNC_SELECTION_COUNT, 1.0 } + }; + + for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i) + { + double fRes = 0.0; + bool bRes = m_pDoc->GetSelectionFunction(aChecks[i].meFunc, aPos, aEmpty, fRes); + CPPUNIT_ASSERT_MESSAGE("Failed to fetch selection function result.", bRes); + CPPUNIT_ASSERT_EQUAL(aChecks[i].mfExpected, fRes); + } + } + + { + // B7 (string formula cell containing ="C".) + ScAddress aPos(1, 6, 0); + + static const Check aChecks[] = + { + { SUBTOTAL_FUNC_CNT2, 1.0 }, + { SUBTOTAL_FUNC_SELECTION_COUNT, 1.0 } + }; + + for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i) + { + double fRes = 0.0; + bool bRes = m_pDoc->GetSelectionFunction(aChecks[i].meFunc, aPos, aEmpty, fRes); + CPPUNIT_ASSERT_MESSAGE("Failed to fetch selection function result.", bRes); + CPPUNIT_ASSERT_EQUAL(aChecks[i].mfExpected, fRes); + } + } + + // Calculate function across selected sheets. + clearSheet(m_pDoc, 0); + m_pDoc->InsertTab(1, "Test2"); + m_pDoc->InsertTab(2, "Test3"); + + // Set values at B2 and C3 on each sheet. + m_pDoc->SetValue(ScAddress(1,1,0), 1.0); + m_pDoc->SetValue(ScAddress(2,2,0), 2.0); + m_pDoc->SetValue(ScAddress(1,1,1), 4.0); + m_pDoc->SetValue(ScAddress(2,2,1), 8.0); + m_pDoc->SetValue(ScAddress(1,1,2), 16.0); + m_pDoc->SetValue(ScAddress(2,2,2), 32.0); + + // Mark B2 and C3 on first sheet. + aRanges.RemoveAll(); + aRanges.push_back(ScRange(1,1,0)); // B2 + aRanges.push_back(ScRange(2,2,0)); // C3 + aMark.MarkFromRangeList(aRanges, true); + // Additionally select third sheet. + aMark.SelectTable(2, true); + + { + double fRes = 0.0; + bool bRes = m_pDoc->GetSelectionFunction( SUBTOTAL_FUNC_SUM, ScAddress(), aMark, fRes); + CPPUNIT_ASSERT_MESSAGE("Failed to fetch selection function result.", bRes); + CPPUNIT_ASSERT_EQUAL_MESSAGE("1+2+16+32=", 51.0, fRes); + } + + m_pDoc->DeleteTab(2); + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testMarkedCellIteration() +{ + m_pDoc->InsertTab(0, "Test"); + + // Insert cells to A1, A5, B2 and C3. + m_pDoc->SetString(ScAddress(0,0,0), "California"); + m_pDoc->SetValue(ScAddress(0,4,0), 1.2); + m_pDoc->SetEditText(ScAddress(1,1,0), "Boston"); + m_pDoc->SetFormula(ScAddress(2,2,0), "=SUM(1,2,3)", m_pDoc->GetGrammar()); + + // Select A1:C5. + ScMarkData aMarkData(MAXROW, MAXCOL); + aMarkData.SetMarkArea(ScRange(0,0,0,2,4,0)); + aMarkData.MarkToMulti(); // TODO : we shouldn't have to do this. + + struct Check + { + SCCOL mnCol; + SCROW mnRow; + }; + + const std::vector<Check> aChecks = { + { 0, 0 }, // A1 + { 0, 4 }, // A5 + { 1, 1 }, // B2 + { 2, 2 }, // C3 + }; + + SCROW nRow = -1; // Start from the imaginary row before A1. + SCCOL nCol = 0; + + for (const Check& rCheck : aChecks) + { + bool bFound = m_pDoc->GetNextMarkedCell(nCol, nRow, 0, aMarkData); + if (!bFound) + { + std::ostringstream os; + os << ScAddress(rCheck.mnCol, rCheck.mnRow, 0).GetColRowString() << " was expected, but not found."; + CPPUNIT_FAIL(os.str()); + } + + CPPUNIT_ASSERT_EQUAL(rCheck.mnRow, nRow); + CPPUNIT_ASSERT_EQUAL(rCheck.mnCol, nCol); + } + + // No more marked cells on this sheet. + bool bFound = m_pDoc->GetNextMarkedCell(nCol, nRow, 0, aMarkData); + CPPUNIT_ASSERT(!bFound); + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyToDocument() +{ + CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", m_pDoc->InsertTab (0, "src")); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + m_pDoc->SetString(0, 0, 0, "Header"); + m_pDoc->SetString(0, 1, 0, "1"); + m_pDoc->SetString(0, 2, 0, "2"); + m_pDoc->SetString(0, 3, 0, "3"); + m_pDoc->SetString(0, 4, 0, "=4/2"); + m_pDoc->CalcAll(); + + //note on A1 + ScAddress aAdrA1 (0, 0, 0); // numerical cell content + ScPostIt* pNote = m_pDoc->GetOrCreateNote(aAdrA1); + pNote->SetText(aAdrA1, "Hello world in A1"); + + // Copy statically to another document. + + ScDocShellRef xDocSh2; + getNewDocShell(xDocSh2); + ScDocument* pDestDoc = &xDocSh2->GetDocument(); + pDestDoc->InsertTab(0, "src"); + pDestDoc->InitDrawLayer(xDocSh2.get()); // for note caption objects + + m_pDoc->CopyStaticToDocument(ScRange(0,1,0,0,3,0), 0, pDestDoc); // Copy A2:A4 + m_pDoc->CopyStaticToDocument(ScAddress(0,0,0), 0, pDestDoc); // Copy A1 + m_pDoc->CopyStaticToDocument(ScRange(0,4,0,0,7,0), 0, pDestDoc); // Copy A5:A8 + + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(0,0,0), pDestDoc->GetString(0,0,0)); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(0,1,0), pDestDoc->GetString(0,1,0)); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(0,2,0), pDestDoc->GetString(0,2,0)); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(0,3,0), pDestDoc->GetString(0,3,0)); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(0,4,0), pDestDoc->GetString(0,4,0)); + + // verify note + CPPUNIT_ASSERT_MESSAGE("There should be a note in A1 destDocument", pDestDoc->HasNote(ScAddress(0, 0, 0))); + CPPUNIT_ASSERT_EQUAL_MESSAGE("The notes content should be the same on both documents", + m_pDoc->GetNote(ScAddress(0, 0, 0))->GetText(), pDestDoc->GetNote(ScAddress(0, 0, 0))->GetText()); + + pDestDoc->DeleteTab(0); + closeDocShell(xDocSh2); + + m_pDoc->DeleteTab(0); +} + +namespace { + +struct HoriIterCheck +{ + SCCOL nCol; + SCROW nRow; + const char* pVal; +}; + +template<size_t Size> +bool checkHorizontalIterator(ScDocument* pDoc, const char* pData[][Size], size_t nDataCount, const HoriIterCheck* pChecks, size_t nCheckCount) +{ + ScAddress aPos(0,0,0); + Test::insertRangeData(pDoc, aPos, pData, nDataCount); + ScHorizontalCellIterator aIter(pDoc, 0, 0, 0, 1, nDataCount-1); + + SCCOL nCol; + SCROW nRow; + size_t i = 0; + for (ScRefCellValue* pCell = aIter.GetNext(nCol, nRow); pCell; pCell = aIter.GetNext(nCol, nRow), ++i) + { + if (i >= nCheckCount) + { + cerr << "hit invalid check " << i << " of " << nCheckCount << endl; + CPPUNIT_FAIL("Iterator claims there is more data than there should be."); + return false; + } + + if (pChecks[i].nCol != nCol) + { + cerr << "Column mismatch " << pChecks[i].nCol << " vs. " << nCol << endl; + return false; + } + + if (pChecks[i].nRow != nRow) + { + cerr << "Row mismatch " << pChecks[i].nRow << " vs. " << nRow << endl; + return false; + } + + if (OUString::createFromAscii(pChecks[i].pVal) != pCell->getString(pDoc)) + { + cerr << "String mismatch " << pChecks[i].pVal << " vs. " << + pCell->getString(pDoc) << endl; + return false; + } + } + + return true; +} + +} + +void Test::testHorizontalIterator() +{ + m_pDoc->InsertTab(0, "test"); + + { + // Raw data - mixed types + const char* aData[][2] = { + { "A", "B" }, + { "C", "1" }, + { "D", "2" }, + { "E", "3" } + }; + + static const HoriIterCheck aChecks[] = { + { 0, 0, "A" }, + { 1, 0, "B" }, + { 0, 1, "C" }, + { 1, 1, "1" }, + { 0, 2, "D" }, + { 1, 2, "2" }, + { 0, 3, "E" }, + { 1, 3, "3" }, + }; + + bool bRes = checkHorizontalIterator( + m_pDoc, aData, SAL_N_ELEMENTS(aData), aChecks, SAL_N_ELEMENTS(aChecks)); + + if (!bRes) + CPPUNIT_FAIL("Failed on test mixed."); + } + + { + // Raw data - 'hole' data + const char* aData[][2] = { + { "A", "B" }, + { "C", nullptr }, + { "D", "E" }, + }; + + static const HoriIterCheck aChecks[] = { + { 0, 0, "A" }, + { 1, 0, "B" }, + { 0, 1, "C" }, + { 0, 2, "D" }, + { 1, 2, "E" }, + }; + + bool bRes = checkHorizontalIterator( + m_pDoc, aData, SAL_N_ELEMENTS(aData), aChecks, SAL_N_ELEMENTS(aChecks)); + + if (!bRes) + CPPUNIT_FAIL("Failed on test hole."); + } + + { + // Very holy data + const char* aData[][2] = { + { nullptr, "A" }, + { nullptr, nullptr }, + { nullptr, "1" }, + { "B", nullptr }, + { "C", "2" }, + { "D", "3" }, + { "E", nullptr }, + { nullptr, "G" }, + { nullptr, nullptr }, + }; + + static const HoriIterCheck aChecks[] = { + { 1, 0, "A" }, + { 1, 2, "1" }, + { 0, 3, "B" }, + { 0, 4, "C" }, + { 1, 4, "2" }, + { 0, 5, "D" }, + { 1, 5, "3" }, + { 0, 6, "E" }, + { 1, 7, "G" }, + }; + + bool bRes = checkHorizontalIterator( + m_pDoc, aData, SAL_N_ELEMENTS(aData), aChecks, SAL_N_ELEMENTS(aChecks)); + + if (!bRes) + CPPUNIT_FAIL("Failed on test holy."); + } + + { + // Degenerate case + const char* aData[][2] = { + { nullptr, nullptr }, + { nullptr, nullptr }, + { nullptr, nullptr }, + }; + + bool bRes = checkHorizontalIterator( + m_pDoc, aData, SAL_N_ELEMENTS(aData), nullptr, 0); + + if (!bRes) + CPPUNIT_FAIL("Failed on test degenerate."); + } + + { + // Data at end + const char* aData[][2] = { + { nullptr, nullptr }, + { nullptr, nullptr }, + { nullptr, "A" }, + }; + + static const HoriIterCheck aChecks[] = { + { 1, 2, "A" }, + }; + + bool bRes = checkHorizontalIterator( + m_pDoc, aData, SAL_N_ELEMENTS(aData), aChecks, SAL_N_ELEMENTS(aChecks)); + + if (!bRes) + CPPUNIT_FAIL("Failed on test at end."); + } + + { + // Data in middle + const char* aData[][2] = { + { nullptr, nullptr }, + { nullptr, nullptr }, + { nullptr, "A" }, + { nullptr, "1" }, + { nullptr, nullptr }, + }; + + static const HoriIterCheck aChecks[] = { + { 1, 2, "A" }, + { 1, 3, "1" }, + }; + + bool bRes = checkHorizontalIterator( + m_pDoc, aData, SAL_N_ELEMENTS(aData), aChecks, SAL_N_ELEMENTS(aChecks)); + + if (!bRes) + CPPUNIT_FAIL("Failed on test in middle."); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testValueIterator() +{ + m_pDoc->InsertTab(0, "Test"); + + // Turn on "precision as shown" option. + ScDocOptions aOpt = m_pDoc->GetDocOptions(); + aOpt.SetCalcAsShown(true); + m_pDoc->SetDocOptions(aOpt); + + // Purely horizontal data layout with numeric data. + for (SCCOL i = 1; i <= 3; ++i) + m_pDoc->SetValue(ScAddress(i,2,0), i); + + { + const double aChecks[] = { 1.0, 2.0, 3.0 }; + size_t const nCheckLen = SAL_N_ELEMENTS(aChecks); + ScValueIterator aIter(m_pDoc, ScRange(1,2,0,3,2,0)); + bool bHas = false; + size_t nCheckPos = 0; + double fVal; + FormulaError nErr; + for (bHas = aIter.GetFirst(fVal, nErr); bHas; bHas = aIter.GetNext(fVal, nErr), ++nCheckPos) + { + CPPUNIT_ASSERT_MESSAGE("Iteration longer than expected.", nCheckPos < nCheckLen); + CPPUNIT_ASSERT_EQUAL(aChecks[nCheckPos], fVal); + CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(nErr)); + } + } + + m_pDoc->DeleteTab(0); +} + +void Test::testHorizontalAttrIterator() +{ + m_pDoc->InsertTab(0, "Test"); + + // Set the background color of B2:C3,D2,E3,C4:D4,B5:D5 to blue + ScPatternAttr aCellBackColor(m_pDoc->GetPool()); + aCellBackColor.GetItemSet().Put(SvxBrushItem(COL_BLUE, ATTR_BACKGROUND)); + m_pDoc->ApplyPatternAreaTab(1, 1, 2, 2, 0, aCellBackColor); + m_pDoc->ApplyPatternAreaTab(3, 1, 3, 1, 0, aCellBackColor); + m_pDoc->ApplyPatternAreaTab(4, 2, 4, 2, 0, aCellBackColor); + m_pDoc->ApplyPatternAreaTab(2, 3, 3, 3, 0, aCellBackColor); + m_pDoc->ApplyPatternAreaTab(1, 4, 4, 4, 0, aCellBackColor); + + // some numeric data + for (SCCOL i = 1; i <= 4; ++i) + for (SCROW j = 1; j <= 4; ++j) + m_pDoc->SetValue(ScAddress(i,j,0), i*10+j); + + { + const int aChecks[][3] = { {1, 3, 1}, {1, 2, 2}, {4, 4, 2}, {2, 3, 3}, {1, 4, 4} }; + const size_t nCheckLen = SAL_N_ELEMENTS(aChecks); + + ScHorizontalAttrIterator aIter(m_pDoc, 0, 0, 0, 5, 5); + SCCOL nCol1, nCol2; + SCROW nRow; + size_t nCheckPos = 0; + for (const ScPatternAttr* pAttr = aIter.GetNext(nCol1, nCol2, nRow); pAttr; pAttr = aIter.GetNext(nCol1, nCol2, nRow), ++nCheckPos) + { + CPPUNIT_ASSERT_MESSAGE("Iteration longer than expected.", nCheckPos < nCheckLen); + CPPUNIT_ASSERT_EQUAL(aChecks[nCheckPos][0], static_cast<int>(nCol1)); + CPPUNIT_ASSERT_EQUAL(aChecks[nCheckPos][1], static_cast<int>(nCol2)); + CPPUNIT_ASSERT_EQUAL(aChecks[nCheckPos][2], static_cast<int>(nRow)); + } + } + + m_pDoc->DeleteTab(0); +} + +namespace { + +bool broadcasterShifted(const ScDocument& rDoc, const ScAddress& rFrom, const ScAddress& rTo) +{ + const SvtBroadcaster* pBC = rDoc.GetBroadcaster(rFrom); + if (pBC) + { + cerr << "Broadcaster shouldn't be here." << endl; + return false; + } + + pBC = rDoc.GetBroadcaster(rTo); + if (!pBC) + { + cerr << "Broadcaster should be here." << endl; + return false; + } + return true; +} + +formula::FormulaToken* getSingleRefToken(ScDocument& rDoc, const ScAddress& rPos) +{ + ScFormulaCell* pFC = rDoc.GetFormulaCell(rPos); + if (!pFC) + { + cerr << "Formula cell expected, but not found." << endl; + return nullptr; + } + + ScTokenArray* pTokens = pFC->GetCode(); + if (!pTokens) + { + cerr << "Token array is not present." << endl; + return nullptr; + } + + formula::FormulaToken* pToken = pTokens->FirstToken(); + if (!pToken || pToken->GetType() != formula::svSingleRef) + { + cerr << "Not a single reference token." << endl; + return nullptr; + } + + return pToken; +} + +bool checkRelativeRefToken(ScDocument& rDoc, const ScAddress& rPos, SCCOL nRelCol, SCROW nRelRow) +{ + formula::FormulaToken* pToken = getSingleRefToken(rDoc, rPos); + if (!pToken) + return false; + + ScSingleRefData& rRef = *pToken->GetSingleRef(); + if (!rRef.IsColRel() || rRef.Col() != nRelCol) + { + cerr << "Unexpected relative column address." << endl; + return false; + } + + if (!rRef.IsRowRel() || rRef.Row() != nRelRow) + { + cerr << "Unexpected relative row address." << endl; + return false; + } + + return true; +} + +bool checkDeletedRefToken(ScDocument& rDoc, const ScAddress& rPos) +{ + formula::FormulaToken* pToken = getSingleRefToken(rDoc, rPos); + if (!pToken) + return false; + + ScSingleRefData& rRef = *pToken->GetSingleRef(); + if (!rRef.IsDeleted()) + { + cerr << "Deleted reference is expected, but it's still a valid reference." << endl; + return false; + } + + return true; +} + +} + +void Test::testCellBroadcaster() +{ + CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", m_pDoc->InsertTab (0, "foo")); + + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calculation. + m_pDoc->SetString(ScAddress(1,0,0), "=A1"); // B1 depends on A1. + double val = m_pDoc->GetValue(ScAddress(1,0,0)); // A1 is empty, so the result should be 0. + CPPUNIT_ASSERT_EQUAL(0.0, val); + + const SvtBroadcaster* pBC = m_pDoc->GetBroadcaster(ScAddress(0,0,0)); + CPPUNIT_ASSERT_MESSAGE("Cell A1 should have a broadcaster.", pBC); + + // Change the value of A1 and make sure that B1 follows. + m_pDoc->SetValue(ScAddress(0,0,0), 1.23); + val = m_pDoc->GetValue(ScAddress(1,0,0)); + CPPUNIT_ASSERT_EQUAL(1.23, val); + + // Move column A down 5 cells. Make sure B1 now references A6, not A1. + m_pDoc->InsertRow(0, 0, 0, 0, 0, 5); + CPPUNIT_ASSERT_MESSAGE("Relative reference check failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(1,0,0), -1, 5)); + + // Make sure the broadcaster has also moved. + CPPUNIT_ASSERT_MESSAGE("Broadcaster relocation failed.", + broadcasterShifted(*m_pDoc, ScAddress(0,0,0), ScAddress(0,5,0))); + + // Set new value to A6 and make sure B1 gets updated. + m_pDoc->SetValue(ScAddress(0,5,0), 45.6); + val = m_pDoc->GetValue(ScAddress(1,0,0)); + CPPUNIT_ASSERT_EQUAL(45.6, val); + + // Move column A up 3 cells, and make sure B1 now references A3, not A6. + m_pDoc->DeleteRow(0, 0, 0, 0, 0, 3); + CPPUNIT_ASSERT_MESSAGE("Relative reference check failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(1,0,0), -1, 2)); + + // The broadcaster should also have been relocated from A6 to A3. + CPPUNIT_ASSERT_MESSAGE("Broadcaster relocation failed.", + broadcasterShifted(*m_pDoc, ScAddress(0,5,0), ScAddress(0,2,0))); + + // Insert cells over A1:A10 and shift cells to right. + m_pDoc->InsertCol(ScRange(0, 0, 0, 0, 10, 0)); + CPPUNIT_ASSERT_MESSAGE("Relative reference check failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(2,0,0), -1, 2)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster relocation failed.", + broadcasterShifted(*m_pDoc, ScAddress(0,2,0), ScAddress(1,2,0))); + + // Delete formula in C2, which should remove the broadcaster in B3. + pBC = m_pDoc->GetBroadcaster(ScAddress(1,2,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster in B3 should still exist.", pBC); + clearRange(m_pDoc, ScAddress(2,0,0)); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(2,0,0))); // C2 should be empty. + pBC = m_pDoc->GetBroadcaster(ScAddress(1,2,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster in B3 should have been removed.", !pBC); + + // Clear everything and start over. + clearRange(m_pDoc, ScRange(0,0,0,10,100,0)); + + m_pDoc->SetString(ScAddress(1,0,0), "=A1"); // B1 depends on A1. + pBC = m_pDoc->GetBroadcaster(ScAddress(0,0,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist in A1.", pBC); + + // While column A is still empty, move column A down 2 cells. This should + // move the broadcaster from A1 to A3. + m_pDoc->InsertRow(0, 0, 0, 0, 0, 2); + CPPUNIT_ASSERT_MESSAGE("Broadcaster relocation failed.", + broadcasterShifted(*m_pDoc, ScAddress(0,0,0), ScAddress(0,2,0))); + + // Move it back while column A is still empty. + m_pDoc->DeleteRow(0, 0, 0, 0, 0, 2); + CPPUNIT_ASSERT_MESSAGE("Broadcaster relocation failed.", + broadcasterShifted(*m_pDoc, ScAddress(0,2,0), ScAddress(0,0,0))); + + // Clear everything again + clearRange(m_pDoc, ScRange(0,0,0,10,100,0)); + + // B1:B3 depends on A1:A3 + m_pDoc->SetString(ScAddress(1,0,0), "=A1"); + m_pDoc->SetString(ScAddress(1,1,0), "=A2"); + m_pDoc->SetString(ScAddress(1,2,0), "=A3"); + CPPUNIT_ASSERT_MESSAGE("Relative reference check in B1 failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(1,0,0), -1, 0)); + CPPUNIT_ASSERT_MESSAGE("Relative reference check in B2 failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(1,1,0), -1, 0)); + CPPUNIT_ASSERT_MESSAGE("Relative reference check in B3 failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(1,2,0), -1, 0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist in A1.", m_pDoc->GetBroadcaster(ScAddress(0,0,0))); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist in A2.", m_pDoc->GetBroadcaster(ScAddress(0,1,0))); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist in A3.", m_pDoc->GetBroadcaster(ScAddress(0,2,0))); + + // Insert Rows at row 2, down 5 rows. + m_pDoc->InsertRow(0, 0, 0, 0, 1, 5); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist in A1.", m_pDoc->GetBroadcaster(ScAddress(0,0,0))); + CPPUNIT_ASSERT_MESSAGE("Relative reference check in B1 failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(1,0,0), -1, 0)); + + // Broadcasters in A2 and A3 should shift down by 5 rows. + CPPUNIT_ASSERT_MESSAGE("Broadcaster relocation failed.", + broadcasterShifted(*m_pDoc, ScAddress(0,1,0), ScAddress(0,6,0))); + CPPUNIT_ASSERT_MESSAGE("Broadcaster relocation failed.", + broadcasterShifted(*m_pDoc, ScAddress(0,2,0), ScAddress(0,7,0))); + + // B2 and B3 should reference shifted cells. + CPPUNIT_ASSERT_MESSAGE("Relative reference check in B2 failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(1,1,0), -1, 5)); + CPPUNIT_ASSERT_MESSAGE("Relative reference check in B2 failed.", + checkRelativeRefToken(*m_pDoc, ScAddress(1,2,0), -1, 5)); + + // Delete cells with broadcasters. + m_pDoc->DeleteRow(0, 0, 0, 0, 4, 6); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should NOT exist in A7.", !m_pDoc->GetBroadcaster(ScAddress(0,6,0))); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should NOT exist in A8.", !m_pDoc->GetBroadcaster(ScAddress(0,7,0))); + + // References in B2 and B3 should be invalid. + CPPUNIT_ASSERT_MESSAGE("Deleted reference check in B2 failed.", + checkDeletedRefToken(*m_pDoc, ScAddress(1,1,0))); + CPPUNIT_ASSERT_MESSAGE("Deleted reference check in B3 failed.", + checkDeletedRefToken(*m_pDoc, ScAddress(1,2,0))); + + // Clear everything again + clearRange(m_pDoc, ScRange(0,0,0,10,100,0)); + + { + // Switch to R1C1 to make it easier to input relative references in multiple cells. + FormulaGrammarSwitch aFGSwitch(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH_XL_R1C1); + + // Have B1:B20 reference A1:A20. + val = 0.0; + for (SCROW i = 0; i < 20; ++i) + { + m_pDoc->SetValue(ScAddress(0,i,0), val++); + m_pDoc->SetString(ScAddress(1,i,0), "=RC[-1]"); + } + } + + // Ensure that the formula cells show correct values, and the referenced + // cells have broadcasters. + val = 0.0; + for (SCROW i = 0; i < 20; ++i, ++val) + { + CPPUNIT_ASSERT_EQUAL(val, m_pDoc->GetValue(ScAddress(1,i,0))); + pBC = m_pDoc->GetBroadcaster(ScAddress(0,i,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcast should exist here.", pBC); + } + + // Delete formula cells in B2:B19. + clearRange(m_pDoc, ScRange(1,1,0,1,18,0)); + // Ensure that A2:A19 no longer have broadcasters, but A1 and A20 still do. + CPPUNIT_ASSERT_MESSAGE("A1 should still have broadcaster.", m_pDoc->GetBroadcaster(ScAddress(0,0,0))); + CPPUNIT_ASSERT_MESSAGE("A20 should still have broadcaster.", m_pDoc->GetBroadcaster(ScAddress(0,19,0))); + for (SCROW i = 1; i <= 18; ++i) + { + pBC = m_pDoc->GetBroadcaster(ScAddress(0,i,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should have been deleted.", !pBC); + } + + // Clear everything again + clearRange(m_pDoc, ScRange(0,0,0,10,100,0)); + + m_pDoc->SetValue(ScAddress(0,0,0), 2.0); + m_pDoc->SetString(ScAddress(1,0,0), "=A1"); + m_pDoc->SetString(ScAddress(2,0,0), "=B1"); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(0,0,0)); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(1,0,0)); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(2,0,0)); + + pBC = m_pDoc->GetBroadcaster(ScAddress(0,0,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist here.", pBC); + pBC = m_pDoc->GetBroadcaster(ScAddress(1,0,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist here.", pBC); + + // Change the value of A1 and make sure everyone follows suit. + m_pDoc->SetValue(ScAddress(0,0,0), 3.5); + CPPUNIT_ASSERT_EQUAL(3.5, m_pDoc->GetValue(0,0,0)); + CPPUNIT_ASSERT_EQUAL(3.5, m_pDoc->GetValue(1,0,0)); + CPPUNIT_ASSERT_EQUAL(3.5, m_pDoc->GetValue(2,0,0)); + + // Insert a column at column B. + m_pDoc->InsertCol(ScRange(1,0,0,1,MAXROW,0)); + pBC = m_pDoc->GetBroadcaster(ScAddress(0,0,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist here.", pBC); + pBC = m_pDoc->GetBroadcaster(ScAddress(2,0,0)); + CPPUNIT_ASSERT_MESSAGE("Broadcaster should exist here.", pBC); + + // Change the value of A1 again. + m_pDoc->SetValue(ScAddress(0,0,0), 5.5); + CPPUNIT_ASSERT_EQUAL(5.5, m_pDoc->GetValue(0,0,0)); + CPPUNIT_ASSERT_EQUAL(5.5, m_pDoc->GetValue(2,0,0)); + CPPUNIT_ASSERT_EQUAL(5.5, m_pDoc->GetValue(3,0,0)); + + m_pDoc->DeleteTab(0); +} + +void Test::testFuncParam() +{ + + CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", + m_pDoc->InsertTab (0, "foo")); + + // First, the normal case, with no missing parameters. + m_pDoc->SetString(0, 0, 0, "=AVERAGE(1;2;3)"); + m_pDoc->CalcFormulaTree(false, false); + double val; + m_pDoc->GetValue(0, 0, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 2.0, val); + + // Now function with missing parameters. Missing values should be treated + // as zeros. + m_pDoc->SetString(0, 0, 0, "=AVERAGE(1;;;)"); + m_pDoc->CalcFormulaTree(false, false); + m_pDoc->GetValue(0, 0, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 0.25, val); + + // Conversion of string to numeric argument. + m_pDoc->SetString(0, 0, 0, "=\"\"+3"); // empty string + m_pDoc->SetString(0, 1, 0, "=\" \"+3"); // only blank + m_pDoc->SetString(0, 2, 0, "=\" 4 \"+3"); // number in blanks + m_pDoc->SetString(0, 3, 0, "=\" x \"+3"); // non-numeric + m_pDoc->SetString(0, 4, 0, "=\"4.4\"+3"); // locale dependent + + OUString aVal; + ScCalcConfig aConfig; + + // With "Convert also locale dependent" and "Empty string as zero"=True option. + aConfig.meStringConversion = ScCalcConfig::StringConversion::LOCALE; + aConfig.mbEmptyStringAsZero = true; + m_pDoc->SetCalcConfig(aConfig); + m_pDoc->CalcAll(); + m_pDoc->GetValue(0, 0, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + m_pDoc->GetValue(0, 1, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + m_pDoc->GetValue(0, 2, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 7.0, val); + aVal = m_pDoc->GetString( 0, 3, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + m_pDoc->GetValue(0, 4, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 7.4, val); + + // With "Convert also locale dependent" and "Empty string as zero"=False option. + aConfig.meStringConversion = ScCalcConfig::StringConversion::LOCALE; + aConfig.mbEmptyStringAsZero = false; + m_pDoc->SetCalcConfig(aConfig); + m_pDoc->CalcAll(); + aVal = m_pDoc->GetString( 0, 0, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + aVal = m_pDoc->GetString( 0, 1, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + m_pDoc->GetValue(0, 2, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 7.0, val); + aVal = m_pDoc->GetString( 0, 3, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + m_pDoc->GetValue(0, 4, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 7.4, val); + + // With "Convert only unambiguous" and "Empty string as zero"=True option. + aConfig.meStringConversion = ScCalcConfig::StringConversion::UNAMBIGUOUS; + aConfig.mbEmptyStringAsZero = true; + m_pDoc->SetCalcConfig(aConfig); + m_pDoc->CalcAll(); + m_pDoc->GetValue(0, 0, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + m_pDoc->GetValue(0, 1, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + m_pDoc->GetValue(0, 2, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 7.0, val); + aVal = m_pDoc->GetString( 0, 3, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + aVal = m_pDoc->GetString( 0, 4, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + + // With "Convert only unambiguous" and "Empty string as zero"=False option. + aConfig.meStringConversion = ScCalcConfig::StringConversion::UNAMBIGUOUS; + aConfig.mbEmptyStringAsZero = false; + m_pDoc->SetCalcConfig(aConfig); + m_pDoc->CalcAll(); + aVal = m_pDoc->GetString( 0, 0, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + aVal = m_pDoc->GetString( 0, 1, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + m_pDoc->GetValue(0, 2, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 7.0, val); + aVal = m_pDoc->GetString( 0, 3, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + aVal = m_pDoc->GetString( 0, 4, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + + // With "Treat as zero" ("Empty string as zero" is ignored). + aConfig.meStringConversion = ScCalcConfig::StringConversion::ZERO; + aConfig.mbEmptyStringAsZero = true; + m_pDoc->SetCalcConfig(aConfig); + m_pDoc->CalcAll(); + m_pDoc->GetValue(0, 0, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + m_pDoc->GetValue(0, 1, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + m_pDoc->GetValue(0, 2, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + m_pDoc->GetValue(0, 3, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + m_pDoc->GetValue(0, 4, 0, val); + ASSERT_DOUBLES_EQUAL_MESSAGE("incorrect result", 3.0, val); + + // With "Generate #VALUE! error" ("Empty string as zero" is ignored). + aConfig.meStringConversion = ScCalcConfig::StringConversion::ILLEGAL; + aConfig.mbEmptyStringAsZero = false; + m_pDoc->SetCalcConfig(aConfig); + m_pDoc->CalcAll(); + aVal = m_pDoc->GetString( 0, 0, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + aVal = m_pDoc->GetString( 0, 1, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + aVal = m_pDoc->GetString( 0, 2, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + aVal = m_pDoc->GetString( 0, 3, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + aVal = m_pDoc->GetString( 0, 4, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("incorrect result", OUString("#VALUE!"), aVal); + + m_pDoc->DeleteTab(0); +} + +void Test::testNamedRange() +{ + static const RangeNameDef aNames[] = { + { "Divisor", "$Sheet1.$A$1:$A$1048576", 1 }, + { "MyRange1", "$Sheet1.$A$1:$A$100", 2 }, + { "MyRange2", "$Sheet1.$B$1:$B$100", 3 }, + { "MyRange3", "$Sheet1.$C$1:$C$100", 4 } + }; + + CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", m_pDoc->InsertTab (0, "Sheet1")); + + m_pDoc->SetValue (0, 0, 0, 101); + + std::unique_ptr<ScRangeName> pNames(new ScRangeName); + bool bSuccess = insertRangeNames(m_pDoc, pNames.get(), aNames, aNames + SAL_N_ELEMENTS(aNames)); + CPPUNIT_ASSERT_MESSAGE("Failed to insert range names.", bSuccess); + m_pDoc->SetRangeName(std::move(pNames)); + + ScRangeName* pNewRanges = m_pDoc->GetRangeName(); + CPPUNIT_ASSERT(pNewRanges); + + // Make sure the index lookup does the right thing. + for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i) + { + const ScRangeData* p = pNewRanges->findByIndex(aNames[i].mnIndex); + CPPUNIT_ASSERT_MESSAGE("lookup of range name by index failed.", p); + OUString aName = p->GetName(); + CPPUNIT_ASSERT_MESSAGE("wrong range name is retrieved.", aName.equalsAscii(aNames[i].mpName)); + } + + // Test usage in formula expression. + m_pDoc->SetString (1, 0, 0, "=A1/Divisor"); + m_pDoc->CalcAll(); + + double result; + m_pDoc->GetValue (1, 0, 0, result); + ASSERT_DOUBLES_EQUAL_MESSAGE ("calculation failed", 1.0, result); + + // Test copy-ability of range names. + std::unique_ptr<ScRangeName> pCopiedRanges(new ScRangeName(*pNewRanges)); + m_pDoc->SetRangeName(std::move(pCopiedRanges)); + // Make sure the index lookup still works. + for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i) + { + const ScRangeData* p = m_pDoc->GetRangeName()->findByIndex(aNames[i].mnIndex); + CPPUNIT_ASSERT_MESSAGE("lookup of range name by index failed with the copied instance.", p); + OUString aName = p->GetName(); + CPPUNIT_ASSERT_MESSAGE("wrong range name is retrieved with the copied instance.", aName.equalsAscii(aNames[i].mpName)); + } + + // Test using another-sheet-local name, scope Sheet1. + ScRangeData* pLocal1 = new ScRangeData( m_pDoc, "local1", ScAddress(0,0,0)); + ScRangeData* pLocal2 = new ScRangeData( m_pDoc, "local2", "$Sheet1.$A$1"); + ScRangeData* pLocal3 = new ScRangeData( m_pDoc, "local3", "Sheet1.$A$1"); + ScRangeData* pLocal4 = new ScRangeData( m_pDoc, "local4", "$A$1"); // implicit relative sheet reference + std::unique_ptr<ScRangeName> pLocalRangeName1(new ScRangeName); + pLocalRangeName1->insert(pLocal1); + pLocalRangeName1->insert(pLocal2); + pLocalRangeName1->insert(pLocal3); + pLocalRangeName1->insert(pLocal4); + m_pDoc->SetRangeName(0, std::move(pLocalRangeName1)); + + CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", m_pDoc->InsertTab (1, "Sheet2")); + + // Use other-sheet-local name of Sheet1 on Sheet2. + ScAddress aPos(1,0,1); + OUString aFormula("=Sheet1.local1+Sheet1.local2+Sheet1.local3+Sheet1.local4"); + m_pDoc->SetString(aPos, aFormula); + OUString aString; + m_pDoc->GetFormula(1,0,1, aString); + CPPUNIT_ASSERT_EQUAL_MESSAGE("formula string should be equal", aFormula, aString); + double fValue = m_pDoc->GetValue(aPos); + ASSERT_DOUBLES_EQUAL_MESSAGE("value should be 4 times Sheet1.A1", 404.0, fValue); + + m_pDoc->DeleteTab(1); + m_pDoc->SetRangeName(0,nullptr); // Delete the names. + m_pDoc->SetRangeName(nullptr); // Delete the names. + m_pDoc->DeleteTab(0); +} + +void Test::testInsertNameList() +{ + m_pDoc->InsertTab(0, "Test"); + + static const RangeNameDef aNames[] = { + { "MyRange1", "$Test.$A$1:$A$100", 1 }, + { "MyRange2", "$Test.$B$1:$B$100", 2 }, + { "MyRange3", "$Test.$C$1:$C$100", 3 } + }; + + std::unique_ptr<ScRangeName> pNames(new ScRangeName); + bool bSuccess = insertRangeNames(m_pDoc, pNames.get(), aNames, aNames + SAL_N_ELEMENTS(aNames)); + CPPUNIT_ASSERT_MESSAGE("Failed to insert range names.", bSuccess); + m_pDoc->SetRangeName(std::move(pNames)); + + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + ScAddress aPos(1,1,0); + rDocFunc.InsertNameList(aPos, true); + + for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i, aPos.IncRow()) + { + OUString aName = m_pDoc->GetString(aPos); + CPPUNIT_ASSERT_EQUAL(OUString::createFromAscii(aNames[i].mpName), aName); + ScAddress aExprPos = aPos; + aExprPos.IncCol(); + OUString aExpr = m_pDoc->GetString(aExprPos); + OUString aExpected = "=" + OUString::createFromAscii(aNames[i].mpExpr); + CPPUNIT_ASSERT_EQUAL(aExpected, aExpr); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testCSV() +{ + const int English = 0, European = 1; + struct { + const char *pStr; int eSep; bool bResult; double nValue; + } aTests[] = { + { "foo", English, false, 0.0 }, + { "1.0", English, true, 1.0 }, + { "1,0", English, false, 0.0 }, + { "1.0", European, false, 0.0 }, + { "1.000", European, true, 1000.0 }, + { "1,000", European, true, 1.0 }, + { "1.000", English, true, 1.0 }, + { "1,000", English, true, 1000.0 }, + { " 1.0", English, true, 1.0 }, + { " 1.0 ", English, true, 1.0 }, + { "1.0 ", European, false, 0.0 }, + { "1.000", European, true, 1000.0 }, + { "1137.999", English, true, 1137.999 }, + { "1.000.00", European, false, 0.0 }, + { "+,123", English, false, 0.0 }, + { "-,123", English, false, 0.0 } + }; + for (size_t i = 0; i < SAL_N_ELEMENTS(aTests); i++) { + OUString aStr(aTests[i].pStr, strlen (aTests[i].pStr), RTL_TEXTENCODING_UTF8); + double nValue = 0.0; + bool bResult = ScStringUtil::parseSimpleNumber + (aStr, aTests[i].eSep == English ? '.' : ',', + aTests[i].eSep == English ? ',' : '.', + 0, + nValue); + CPPUNIT_ASSERT_EQUAL_MESSAGE ("CSV numeric detection failure", aTests[i].bResult, bResult); + CPPUNIT_ASSERT_EQUAL_MESSAGE ("CSV numeric value failure", aTests[i].nValue, nValue); + } +} + +template<typename Evaluator> +static void checkMatrixElements(const ScMatrix& rMat) +{ + SCSIZE nC, nR; + rMat.GetDimensions(nC, nR); + Evaluator aEval; + for (SCSIZE i = 0; i < nC; ++i) + { + for (SCSIZE j = 0; j < nR; ++j) + { + aEval(i, j, rMat.Get(i, j)); + } + } +} + +namespace { + +struct AllZeroMatrix +{ + void operator() (SCSIZE /*nCol*/, SCSIZE /*nRow*/, const ScMatrixValue& rVal) const + { + CPPUNIT_ASSERT_EQUAL_MESSAGE("element is not of numeric type", int(ScMatValType::Value), static_cast<int>(rVal.nType)); + ASSERT_DOUBLES_EQUAL_MESSAGE("element value must be zero", 0.0, rVal.fVal); + } +}; + +struct PartiallyFilledZeroMatrix +{ + void operator() (SCSIZE nCol, SCSIZE nRow, const ScMatrixValue& rVal) const + { + CPPUNIT_ASSERT_EQUAL_MESSAGE("element is not of numeric type", int(ScMatValType::Value), static_cast<int>(rVal.nType)); + if (1 <= nCol && nCol <= 2 && 2 <= nRow && nRow <= 8) + { + ASSERT_DOUBLES_EQUAL_MESSAGE("element value must be 3.0", 3.0, rVal.fVal); + } + else + { + ASSERT_DOUBLES_EQUAL_MESSAGE("element value must be zero", 0.0, rVal.fVal); + } + } +}; + +struct AllEmptyMatrix +{ + void operator() (SCSIZE /*nCol*/, SCSIZE /*nRow*/, const ScMatrixValue& rVal) const + { + CPPUNIT_ASSERT_EQUAL_MESSAGE("element is not of empty type", int(ScMatValType::Empty), static_cast<int>(rVal.nType)); + ASSERT_DOUBLES_EQUAL_MESSAGE("value of \"empty\" element is expected to be zero", 0.0, rVal.fVal); + } +}; + +struct PartiallyFilledEmptyMatrix +{ + void operator() (SCSIZE nCol, SCSIZE nRow, const ScMatrixValue& rVal) const + { + if (nCol == 1 && nRow == 1) + { + CPPUNIT_ASSERT_EQUAL_MESSAGE("element is not of boolean type", int(ScMatValType::Boolean), static_cast<int>(rVal.nType)); + ASSERT_DOUBLES_EQUAL_MESSAGE("element value is not what is expected", 1.0, rVal.fVal); + } + else if (nCol == 4 && nRow == 5) + { + CPPUNIT_ASSERT_EQUAL_MESSAGE("element is not of value type", int(ScMatValType::Value), static_cast<int>(rVal.nType)); + ASSERT_DOUBLES_EQUAL_MESSAGE("element value is not what is expected", -12.5, rVal.fVal); + } + else if (nCol == 8 && nRow == 2) + { + CPPUNIT_ASSERT_EQUAL_MESSAGE("element is not of value type", int(ScMatValType::String), static_cast<int>(rVal.nType)); + CPPUNIT_ASSERT_EQUAL_MESSAGE("element value is not what is expected", OUString("Test"), rVal.aStr.getString()); + } + else if (nCol == 8 && nRow == 11) + { + CPPUNIT_ASSERT_EQUAL_MESSAGE("element is not of empty path type", int(ScMatValType::EmptyPath), static_cast<int>(rVal.nType)); + ASSERT_DOUBLES_EQUAL_MESSAGE("value of \"empty\" element is expected to be zero", 0.0, rVal.fVal); + } + else + { + CPPUNIT_ASSERT_EQUAL_MESSAGE("element is not of empty type", int(ScMatValType::Empty), static_cast<int>(rVal.nType)); + ASSERT_DOUBLES_EQUAL_MESSAGE("value of \"empty\" element is expected to be zero", 0.0, rVal.fVal); + } + } +}; + +} + +void Test::testMatrix() +{ + svl::SharedStringPool& rPool = m_pDoc->GetSharedStringPool(); + ScMatrixRef pMat, pMat2; + + // First, test the zero matrix type. + pMat = new ScMatrix(0, 0, 0.0); + SCSIZE nC, nR; + pMat->GetDimensions(nC, nR); + CPPUNIT_ASSERT_MESSAGE("matrix is not empty", nC == 0 && nR == 0); + pMat->Resize(4, 10, 0.0); + pMat->GetDimensions(nC, nR); + CPPUNIT_ASSERT_MESSAGE("matrix size is not as expected", nC == 4 && nR == 10); + CPPUNIT_ASSERT_MESSAGE("both 'and' and 'or' should evaluate to false", + !pMat->And() && !pMat->Or()); + + // Resizing into a larger matrix should fill the void space with zeros. + checkMatrixElements<AllZeroMatrix>(*pMat); + + pMat->FillDouble(3.0, 1, 2, 2, 8); + checkMatrixElements<PartiallyFilledZeroMatrix>(*pMat); + CPPUNIT_ASSERT_MESSAGE("matrix is expected to be numeric", pMat->IsNumeric()); + CPPUNIT_ASSERT_MESSAGE("partially non-zero matrix should evaluate false on 'and' and true on 'or", + !pMat->And() && pMat->Or()); + pMat->FillDouble(5.0, 0, 0, nC-1, nR-1); + CPPUNIT_ASSERT_MESSAGE("fully non-zero matrix should evaluate true both on 'and' and 'or", + pMat->And() && pMat->Or()); + + // Test the AND and OR evaluations. + pMat = new ScMatrix(2, 2, 0.0); + + // Only some of the elements are non-zero. + pMat->PutBoolean(true, 0, 0); + pMat->PutDouble(1.0, 1, 1); + CPPUNIT_ASSERT_MESSAGE("incorrect OR result", pMat->Or()); + CPPUNIT_ASSERT_MESSAGE("incorrect AND result", !pMat->And()); + + // All of the elements are non-zero. + pMat->PutBoolean(true, 0, 1); + pMat->PutDouble(2.3, 1, 0); + CPPUNIT_ASSERT_MESSAGE("incorrect OR result", pMat->Or()); + CPPUNIT_ASSERT_MESSAGE("incorrect AND result", pMat->And()); + + // Now test the empty matrix type. + pMat = new ScMatrix(10, 20); + pMat->GetDimensions(nC, nR); + CPPUNIT_ASSERT_MESSAGE("matrix size is not as expected", nC == 10 && nR == 20); + checkMatrixElements<AllEmptyMatrix>(*pMat); + + pMat->PutBoolean(true, 1, 1); + pMat->PutDouble(-12.5, 4, 5); + pMat->PutString(rPool.intern("Test"), 8, 2); + pMat->PutEmptyPath(8, 11); + checkMatrixElements<PartiallyFilledEmptyMatrix>(*pMat); + + // Test resizing. + pMat = new ScMatrix(0, 0); + pMat->Resize(2, 2, 1.5); + pMat->PutEmpty(1, 1); + + CPPUNIT_ASSERT_EQUAL(1.5, pMat->GetDouble(0, 0)); + CPPUNIT_ASSERT_EQUAL(1.5, pMat->GetDouble(0, 1)); + CPPUNIT_ASSERT_EQUAL(1.5, pMat->GetDouble(1, 0)); + CPPUNIT_ASSERT_MESSAGE("PutEmpty() call failed.", pMat->IsEmpty(1, 1)); + + // Max and min values. + pMat = new ScMatrix(2, 2, 0.0); + pMat->PutDouble(-10, 0, 0); + pMat->PutDouble(-12, 0, 1); + pMat->PutDouble(-8, 1, 0); + pMat->PutDouble(-25, 1, 1); + CPPUNIT_ASSERT_EQUAL(-25.0, pMat->GetMinValue(false)); + CPPUNIT_ASSERT_EQUAL(-8.0, pMat->GetMaxValue(false)); + pMat->PutString(rPool.intern("Test"), 0, 0); + CPPUNIT_ASSERT_EQUAL(0.0, pMat->GetMaxValue(true)); // text as zero. + CPPUNIT_ASSERT_EQUAL(-8.0, pMat->GetMaxValue(false)); // ignore text. + pMat->PutBoolean(true, 0, 0); + CPPUNIT_ASSERT_EQUAL(1.0, pMat->GetMaxValue(false)); + pMat = new ScMatrix(2, 2, 10.0); + pMat->PutBoolean(false, 0, 0); + pMat->PutDouble(12.5, 1, 1); + CPPUNIT_ASSERT_EQUAL(0.0, pMat->GetMinValue(false)); + CPPUNIT_ASSERT_EQUAL(12.5, pMat->GetMaxValue(false)); + + // Convert matrix into a linear double array. String elements become NaN + // and empty elements become 0. + pMat = new ScMatrix(3, 3); + pMat->PutDouble(2.5, 0, 0); + pMat->PutDouble(1.2, 0, 1); + pMat->PutString(rPool.intern("A"), 1, 1); + pMat->PutDouble(2.3, 2, 1); + pMat->PutDouble(-20, 2, 2); + + double fNaN; + rtl::math::setNan(&fNaN); + + std::vector<double> aDoubles; + pMat->GetDoubleArray(aDoubles); + + { + const double pChecks[] = { 2.5, 1.2, 0, 0, fNaN, 0, 0, 2.3, -20 }; + CPPUNIT_ASSERT_EQUAL(SAL_N_ELEMENTS(pChecks), aDoubles.size()); + for (size_t i = 0, n = aDoubles.size(); i < n; ++i) + { + if (std::isnan(pChecks[i])) + CPPUNIT_ASSERT_MESSAGE("NaN is expected, but it's not.", std::isnan(aDoubles[i])); + else + CPPUNIT_ASSERT_EQUAL(pChecks[i], aDoubles[i]); + } + } + + pMat2 = new ScMatrix(3, 3, 10.0); + pMat2->PutString(rPool.intern("B"), 1, 0); + pMat2->MergeDoubleArrayMultiply(aDoubles); + + { + const double pChecks[] = { 25, 12, 0, fNaN, fNaN, 0, 0, 23, -200 }; + CPPUNIT_ASSERT_EQUAL(SAL_N_ELEMENTS(pChecks), aDoubles.size()); + for (size_t i = 0, n = aDoubles.size(); i < n; ++i) + { + if (std::isnan(pChecks[i])) + CPPUNIT_ASSERT_MESSAGE("NaN is expected, but it's not.", std::isnan(aDoubles[i])); + else + CPPUNIT_ASSERT_EQUAL(pChecks[i], aDoubles[i]); + } + } +} + +void Test::testMatrixComparisonWithErrors() +{ + m_pDoc->InsertTab(0, "foo"); + + // Insert the source values in A1:A2. + m_pDoc->SetString(0, 0, 0, "=1/0"); + m_pDoc->SetValue( 0, 1, 0, 1.0); + + // Create a matrix formula in B3:B4 referencing A1:A2 and doing a greater + // than comparison on it's values. Error value must be propagated. + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + m_pDoc->InsertMatrixFormula(1, 2, 1, 3, aMark, "=A1:A2>0"); + + CPPUNIT_ASSERT_EQUAL(OUString("#DIV/0!"), m_pDoc->GetString(0,0,0)); + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue( 0,1,0)); + CPPUNIT_ASSERT_EQUAL(OUString("#DIV/0!"), m_pDoc->GetString(1,2,0)); + CPPUNIT_ASSERT_EQUAL(OUString("TRUE"), m_pDoc->GetString(1,3,0)); + + m_pDoc->DeleteTab(0); +} + +void Test::testMatrixConditionalBooleanResult() +{ + m_pDoc->InsertTab(0, "foo"); + + // Create matrix formulas in A1:B1,A2:B2,A3:B3,A4:B4 producing mixed + // boolean and numeric results in an unformatted area. + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + m_pDoc->InsertMatrixFormula( 0,0, 1,0, aMark, "=IF({1,0};TRUE();42)"); // {TRUE,42} + m_pDoc->InsertMatrixFormula( 0,1, 1,1, aMark, "=IF({0,1};TRUE();42)"); // {42,1} aim for {42,TRUE} + m_pDoc->InsertMatrixFormula( 0,2, 1,2, aMark, "=IF({1,0};42;FALSE())"); // {42,0} aim for {42,FALSE} + m_pDoc->InsertMatrixFormula( 0,3, 1,3, aMark, "=IF({0,1};42;FALSE())"); // {FALSE,42} + + CPPUNIT_ASSERT_EQUAL( OUString("TRUE"), m_pDoc->GetString(0,0,0)); + CPPUNIT_ASSERT_EQUAL( OUString("42"), m_pDoc->GetString(1,0,0)); + CPPUNIT_ASSERT_EQUAL( OUString("42"), m_pDoc->GetString(0,1,0)); + //CPPUNIT_ASSERT_EQUAL( OUString("TRUE"), m_pDoc->GetString(1,1,0)); // not yet + CPPUNIT_ASSERT_EQUAL( OUString("42"), m_pDoc->GetString(0,2,0)); + //CPPUNIT_ASSERT_EQUAL( OUString("FALSE"), m_pDoc->GetString(1,2,0)); // not yet + CPPUNIT_ASSERT_EQUAL( OUString("FALSE"), m_pDoc->GetString(0,3,0)); + CPPUNIT_ASSERT_EQUAL( OUString("42"), m_pDoc->GetString(1,3,0)); + + m_pDoc->DeleteTab(0); +} + +void Test::testEnterMixedMatrix() +{ + m_pDoc->InsertTab(0, "foo"); + + // Insert the source values in A1:B2. + m_pDoc->SetString(0, 0, 0, "A"); + m_pDoc->SetString(1, 0, 0, "B"); + double val = 1.0; + m_pDoc->SetValue(0, 1, 0, val); + val = 2.0; + m_pDoc->SetValue(1, 1, 0, val); + + // Create a matrix range in A4:B5 referencing A1:B2. + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + m_pDoc->InsertMatrixFormula(0, 3, 1, 4, aMark, "=A1:B2"); + + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(0,0,0), m_pDoc->GetString(0,3,0)); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(1,0,0), m_pDoc->GetString(1,3,0)); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetValue(0,1,0), m_pDoc->GetValue(0,4,0)); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetValue(1,1,0), m_pDoc->GetValue(1,4,0)); + + m_pDoc->DeleteTab(0); +} + +void Test::testMatrixEditable() +{ + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on. + + m_pDoc->InsertTab(0, "Test"); + + // Values in A1:B1. + m_pDoc->SetValue(ScAddress(0,0,0), 1.0); + m_pDoc->SetValue(ScAddress(1,0,0), 2.0); + + // A2 is a normal formula. + m_pDoc->SetString(ScAddress(0,1,0), "=5"); + + // A3:A4 is a matrix. + ScRange aMatRange(0,2,0,0,3,0); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aMatRange); + m_pDoc->InsertMatrixFormula(0, 2, 0, 3, aMark, "=TRANSPOSE(A1:B1)"); + + // Check their values. + CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(ScAddress(0,1,0))); + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,2,0))); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(0,3,0))); + + // Make sure A3:A4 is a matrix. + ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(0,2,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT_EQUAL_MESSAGE("A3 should be matrix origin.", + ScMatrixMode::Formula, pFC->GetMatrixFlag()); + + pFC = m_pDoc->GetFormulaCell(ScAddress(0,3,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT_EQUAL_MESSAGE("A4 should be matrix reference.", + ScMatrixMode::Reference, pFC->GetMatrixFlag()); + + // Check to make sure A3:A4 combined is editable. + ScEditableTester aTester; + aTester.TestSelection(m_pDoc, aMark); + CPPUNIT_ASSERT(aTester.IsEditable()); + + m_pDoc->DeleteTab(0); +} + +void Test::testCellCopy() +{ + m_pDoc->InsertTab(0, "TestTab"); + ScAddress aSrc(0,0,0); + ScAddress aDest(0,1,0); + OUString aStr("please copy me"); + m_pDoc->SetString(aSrc, "please copy me"); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(aSrc), aStr); + // copy to self - why not ? + m_pDoc->CopyCellToDocument(aSrc,aDest,*m_pDoc); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(aDest), aStr); +} + +void Test::testSheetCopy() +{ + m_pDoc->InsertTab(0, "TestTab"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("document should have one sheet to begin with.", + static_cast<SCTAB>(1), m_pDoc->GetTableCount()); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + // Insert text in A1. + m_pDoc->SetString(ScAddress(0,0,0), "copy me"); + + // Insert edit cells in B1:B3. + ScFieldEditEngine& rEE = m_pDoc->GetEditEngine(); + rEE.SetTextCurrentDefaults("Edit 1"); + m_pDoc->SetEditText(ScAddress(1,0,0), rEE.CreateTextObject()); + rEE.SetTextCurrentDefaults("Edit 2"); + m_pDoc->SetEditText(ScAddress(1,1,0), rEE.CreateTextObject()); + rEE.SetTextCurrentDefaults("Edit 3"); + m_pDoc->SetEditText(ScAddress(1,2,0), rEE.CreateTextObject()); + + SCROW nRow1, nRow2; + bool bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("new sheet should have all rows visible", !bHidden && nRow1 == 0 && nRow2 == MAXROW); + + // insert a note + ScAddress aAdrA1 (0,2,0); // empty cell content. + ScPostIt *pNoteA1 = m_pDoc->GetOrCreateNote(aAdrA1); + pNoteA1->SetText(aAdrA1, "Hello world in A3"); + + // Copy and test the result. + m_pDoc->CopyTab(0, 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("document now should have two sheets.", + static_cast<SCTAB>(2), m_pDoc->GetTableCount()); + + bHidden = m_pDoc->RowHidden(0, 1, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("copied sheet should also have all rows visible as the original.", !bHidden && nRow1 == 0 && nRow2 == MAXROW); + CPPUNIT_ASSERT_MESSAGE("There should be note on A3 in new sheet", m_pDoc->HasNote(ScAddress(0,2,1))); + CPPUNIT_ASSERT_EQUAL(OUString("copy me"), m_pDoc->GetString(ScAddress(0,0,1))); + + // Check the copied edit cells. + const EditTextObject* pEditObj = m_pDoc->GetEditText(ScAddress(1,0,1)); + CPPUNIT_ASSERT_MESSAGE("There should be an edit cell in B1.", pEditObj); + CPPUNIT_ASSERT_EQUAL(OUString("Edit 1"), pEditObj->GetText(0)); + pEditObj = m_pDoc->GetEditText(ScAddress(1,1,1)); + CPPUNIT_ASSERT_MESSAGE("There should be an edit cell in B2.", pEditObj); + CPPUNIT_ASSERT_EQUAL(OUString("Edit 2"), pEditObj->GetText(0)); + pEditObj = m_pDoc->GetEditText(ScAddress(1,2,1)); + CPPUNIT_ASSERT_MESSAGE("There should be an edit cell in B3.", pEditObj); + CPPUNIT_ASSERT_EQUAL(OUString("Edit 3"), pEditObj->GetText(0)); + + m_pDoc->DeleteTab(1); + + m_pDoc->SetRowHidden(5, 10, 0, true); + bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 0 - 4 should be visible", !bHidden && nRow1 == 0 && nRow2 == 4); + bHidden = m_pDoc->RowHidden(5, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 5 - 10 should be hidden", bHidden && nRow1 == 5 && nRow2 == 10); + bHidden = m_pDoc->RowHidden(11, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 11 - maxrow should be visible", !bHidden && nRow1 == 11 && nRow2 == MAXROW); + + // Copy the sheet once again. + m_pDoc->CopyTab(0, 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("document now should have two sheets.", + static_cast<SCTAB>(2), m_pDoc->GetTableCount()); + bHidden = m_pDoc->RowHidden(0, 1, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 0 - 4 should be visible", !bHidden && nRow1 == 0 && nRow2 == 4); + bHidden = m_pDoc->RowHidden(5, 1, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 5 - 10 should be hidden", bHidden && nRow1 == 5 && nRow2 == 10); + bHidden = m_pDoc->RowHidden(11, 1, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 11 - maxrow should be visible", !bHidden && nRow1 == 11 && nRow2 == MAXROW); + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testSheetMove() +{ + m_pDoc->InsertTab(0, "TestTab1"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("document should have one sheet to begin with.", static_cast<SCTAB>(1), m_pDoc->GetTableCount()); + SCROW nRow1, nRow2; + bool bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("new sheet should have all rows visible", !bHidden && nRow1 == 0 && nRow2 == MAXROW); + + //test if inserting before another sheet works + m_pDoc->InsertTab(0, "TestTab2"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("document should have two sheets", static_cast<SCTAB>(2), m_pDoc->GetTableCount()); + bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("new sheet should have all rows visible", !bHidden && nRow1 == 0 && nRow2 == MAXROW); + + // Move and test the result. + m_pDoc->MoveTab(0, 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("document now should have two sheets.", static_cast<SCTAB>(2), m_pDoc->GetTableCount()); + bHidden = m_pDoc->RowHidden(0, 1, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("copied sheet should also have all rows visible as the original.", !bHidden && nRow1 == 0 && nRow2 == MAXROW); + OUString aName; + m_pDoc->GetName(0, aName); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "sheets should have changed places", OUString("TestTab1"), aName); + + m_pDoc->SetRowHidden(5, 10, 0, true); + bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 0 - 4 should be visible", !bHidden && nRow1 == 0 && nRow2 == 4); + bHidden = m_pDoc->RowHidden(5, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 5 - 10 should be hidden", bHidden && nRow1 == 5 && nRow2 == 10); + bHidden = m_pDoc->RowHidden(11, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 11 - maxrow should be visible", !bHidden && nRow1 == 11 && nRow2 == MAXROW); + + // Move the sheet once again. + m_pDoc->MoveTab(1, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("document now should have two sheets.", static_cast<SCTAB>(2), m_pDoc->GetTableCount()); + bHidden = m_pDoc->RowHidden(0, 1, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 0 - 4 should be visible", !bHidden && nRow1 == 0 && nRow2 == 4); + bHidden = m_pDoc->RowHidden(5, 1, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 5 - 10 should be hidden", bHidden && nRow1 == 5 && nRow2 == 10); + bHidden = m_pDoc->RowHidden(11, 1, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 11 - maxrow should be visible", !bHidden && nRow1 == 11 && nRow2 == MAXROW); + m_pDoc->GetName(0, aName); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "sheets should have changed places", OUString("TestTab2"), aName); + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testDataArea() +{ + m_pDoc->InsertTab(0, "Data"); + + // Totally empty sheet should be rightfully considered empty in all accounts. + CPPUNIT_ASSERT_MESSAGE("Sheet is expected to be empty.", m_pDoc->IsPrintEmpty(0, 0, 0, 100, 100)); + CPPUNIT_ASSERT_MESSAGE("Sheet is expected to be empty.", m_pDoc->IsBlockEmpty(0, 0, 0, 100, 100)); + + // Now, set borders in some cells... + ::editeng::SvxBorderLine aLine(nullptr, 50, SvxBorderLineStyle::SOLID); + SvxBoxItem aBorderItem(ATTR_BORDER); + aBorderItem.SetLine(&aLine, SvxBoxItemLine::LEFT); + aBorderItem.SetLine(&aLine, SvxBoxItemLine::RIGHT); + for (SCROW i = 0; i < 100; ++i) + // Set borders from row 1 to 100. + m_pDoc->ApplyAttr(0, i, 0, aBorderItem); + + // Now the sheet is considered non-empty for printing purposes, but still + // be empty in all the other cases. + CPPUNIT_ASSERT_MESSAGE("Empty sheet with borders should be printable.", + !m_pDoc->IsPrintEmpty(0, 0, 0, 100, 100)); + CPPUNIT_ASSERT_MESSAGE("But it should still be considered empty in all the other cases.", + m_pDoc->IsBlockEmpty(0, 0, 0, 100, 100)); + + // Adding a real cell content should turn the block non-empty. + m_pDoc->SetString(0, 0, 0, "Some text"); + CPPUNIT_ASSERT_MESSAGE("Now the block should not be empty with a real cell content.", + !m_pDoc->IsBlockEmpty(0, 0, 0, 100, 100)); + + // TODO: Add more tests for normal data area calculation. + + m_pDoc->DeleteTab(0); +} + +void Test::testStreamValid() +{ + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + m_pDoc->InsertTab(2, "Sheet3"); + m_pDoc->InsertTab(3, "Sheet4"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("We should have 4 sheet instances.", static_cast<SCTAB>(4), m_pDoc->GetTableCount()); + + OUString a1("A1"); + OUString a2("A2"); + OUString test; + + // Put values into Sheet1. + m_pDoc->SetString(0, 0, 0, a1); + m_pDoc->SetString(0, 1, 0, a2); + test = m_pDoc->GetString(0, 0, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected value in Sheet1.A1", test, a1); + test = m_pDoc->GetString(0, 1, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected value in Sheet1.A2", test, a2); + + // Put formulas into Sheet2 to Sheet4 to reference values from Sheet1. + m_pDoc->SetString(0, 0, 1, "=Sheet1.A1"); + m_pDoc->SetString(0, 1, 1, "=Sheet1.A2"); + m_pDoc->SetString(0, 0, 2, "=Sheet1.A1"); + m_pDoc->SetString(0, 0, 3, "=Sheet1.A2"); + + test = m_pDoc->GetString(0, 0, 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected value in Sheet2.A1", test, a1); + test = m_pDoc->GetString(0, 1, 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected value in Sheet2.A2", test, a2); + test = m_pDoc->GetString(0, 0, 2); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected value in Sheet3.A1", test, a1); + test = m_pDoc->GetString(0, 0, 3); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected value in Sheet3.A1", test, a2); + + // Set all sheet streams valid after all the initial cell values are in + // place. In reality we need to have real XML streams stored in order to + // claim they are valid, but we are just testing the flag values here. + m_pDoc->SetStreamValid(0, true); + m_pDoc->SetStreamValid(1, true); + m_pDoc->SetStreamValid(2, true); + m_pDoc->SetStreamValid(3, true); + CPPUNIT_ASSERT_MESSAGE("Stream is expected to be valid.", m_pDoc->IsStreamValid(0)); + CPPUNIT_ASSERT_MESSAGE("Stream is expected to be valid.", m_pDoc->IsStreamValid(1)); + CPPUNIT_ASSERT_MESSAGE("Stream is expected to be valid.", m_pDoc->IsStreamValid(2)); + CPPUNIT_ASSERT_MESSAGE("Stream is expected to be valid.", m_pDoc->IsStreamValid(3)); + + // Now, insert a new row at row 2 position on Sheet1. This will move cell + // A2 downward but cell A1 remains unmoved. + m_pDoc->InsertRow(0, 0, MAXCOL, 0, 1, 2); + test = m_pDoc->GetString(0, 0, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Cell A1 should not have moved.", test, a1); + test = m_pDoc->GetString(0, 3, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("the old cell A2 should now be at A4.", test, a2); + ScRefCellValue aCell; + aCell.assign(*m_pDoc, ScAddress(0,1,0)); + CPPUNIT_ASSERT_MESSAGE("Cell A2 should be empty.", aCell.isEmpty()); + aCell.assign(*m_pDoc, ScAddress(0,2,0)); + CPPUNIT_ASSERT_MESSAGE("Cell A3 should be empty.", aCell.isEmpty()); + + // After the move, Sheet1, Sheet2, and Sheet4 should have their stream + // invalidated, whereas Sheet3's stream should still be valid. + CPPUNIT_ASSERT_MESSAGE("Stream should have been invalidated.", !m_pDoc->IsStreamValid(0)); + CPPUNIT_ASSERT_MESSAGE("Stream should have been invalidated.", !m_pDoc->IsStreamValid(1)); + CPPUNIT_ASSERT_MESSAGE("Stream should have been invalidated.", !m_pDoc->IsStreamValid(3)); + CPPUNIT_ASSERT_MESSAGE("Stream should still be valid.", m_pDoc->IsStreamValid(2)); + + m_pDoc->DeleteTab(3); + m_pDoc->DeleteTab(2); + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testFunctionLists() +{ + const char* aDataBase[] = { + "DAVERAGE", + "DCOUNT", + "DCOUNTA", + "DGET", + "DMAX", + "DMIN", + "DPRODUCT", + "DSTDEV", + "DSTDEVP", + "DSUM", + "DVAR", + "DVARP", + nullptr + }; + + const char* aDateTime[] = { + "DATE", + "DATEDIF", + "DATEVALUE", + "DAY", + "DAYS", + "DAYS360", + "DAYSINMONTH", + "DAYSINYEAR", + "EASTERSUNDAY", + "HOUR", + "ISLEAPYEAR", + "ISOWEEKNUM", + "MINUTE", + "MONTH", + "MONTHS", + "NETWORKDAYS", + "NETWORKDAYS.INTL", + "NOW", + "SECOND", + "TIME", + "TIMEVALUE", + "TODAY", + "WEEKDAY", + "WEEKNUM", + "WEEKNUM_OOO", + "WEEKS", + "WEEKSINYEAR", + "WORKDAY.INTL", + "YEAR", + "YEARS", + nullptr + }; + + const char* aFinancial[] = { + "CUMIPMT", + "CUMPRINC", + "DB", + "DDB", + "EFFECT", + "FV", + "IPMT", + "IRR", + "ISPMT", + "MIRR", + "NOMINAL", + "NPER", + "NPV", + "OPT_BARRIER", + "OPT_PROB_HIT", + "OPT_PROB_INMONEY", + "OPT_TOUCH", + "PDURATION", + "PMT", + "PPMT", + "PV", + "RATE", + "RRI", + "SLN", + "SYD", + "VDB", + nullptr + }; + + const char* aInformation[] = { + "CELL", + "CURRENT", + "FORMULA", + "INFO", + "ISBLANK", + "ISERR", + "ISERROR", + "ISEVEN", + "ISFORMULA", + "ISLOGICAL", + "ISNA", + "ISNONTEXT", + "ISNUMBER", + "ISODD", + "ISREF", + "ISTEXT", + "N", + "NA", + "TYPE", + nullptr + }; + + const char* aLogical[] = { + "AND", + "FALSE", + "IF", + "IFERROR", + "IFNA", + "IFS", + "NOT", + "OR", + "SWITCH", + "TRUE", + "XOR", + nullptr + }; + + const char* aMathematical[] = { + "ABS", + "ACOS", + "ACOSH", + "ACOT", + "ACOTH", + "AGGREGATE", + "ASIN", + "ASINH", + "ATAN", + "ATAN2", + "ATANH", + "BITAND", + "BITLSHIFT", + "BITOR", + "BITRSHIFT", + "BITXOR", + "CEILING", + "CEILING.MATH", + "CEILING.PRECISE", + "CEILING.XCL", + "COLOR", + "COMBIN", + "COMBINA", + "CONVERT_OOO", + "COS", + "COSH", + "COT", + "COTH", + "CSC", + "CSCH", + "DEGREES", + "EUROCONVERT", + "EVEN", + "EXP", + "FACT", + "FLOOR", + "FLOOR.MATH", + "FLOOR.PRECISE", + "FLOOR.XCL", + "GCD", + "INT", + "ISO.CEILING", + "LCM", + "LN", + "LOG", + "LOG10", + "MOD", + "ODD", + "PI", + "POWER", + "PRODUCT", + "RADIANS", + "RAND", + "RAND.NV", + "RANDBETWEEN.NV", + "RAWSUBTRACT", + "ROUND", + "ROUNDDOWN", + "ROUNDSIG", + "ROUNDUP", + "SEC", + "SECH", + "SIGN", + "SIN", + "SINH", + "SQRT", + "SUBTOTAL", + "SUM", + "SUMIF", + "SUMIFS", + "SUMSQ", + "TAN", + "TANH", + "TRUNC", + nullptr + }; + + const char* aArray[] = { + "FOURIER", + "FREQUENCY", + "GROWTH", + "LINEST", + "LOGEST", + "MDETERM", + "MINVERSE", + "MMULT", + "MUNIT", + "SUMPRODUCT", + "SUMX2MY2", + "SUMX2PY2", + "SUMXMY2", + "TRANSPOSE", + "TREND", + nullptr + }; + + const char* aStatistical[] = { + "AVEDEV", + "AVERAGE", + "AVERAGEA", + "AVERAGEIF", + "AVERAGEIFS", + "B", + "BETA.DIST", + "BETA.INV", + "BETADIST", + "BETAINV", + "BINOM.DIST", + "BINOM.INV", + "BINOMDIST", + "CHIDIST", + "CHIINV", + "CHISQ.DIST", + "CHISQ.DIST.RT", + "CHISQ.INV", + "CHISQ.INV.RT", + "CHISQ.TEST", + "CHISQDIST", + "CHISQINV", + "CHITEST", + "CONFIDENCE", + "CONFIDENCE.NORM", + "CONFIDENCE.T", + "CORREL", + "COUNT", + "COUNTA", + "COUNTBLANK", + "COUNTIF", + "COUNTIFS", + "COVAR", + "COVARIANCE.P", + "COVARIANCE.S", + "CRITBINOM", + "DEVSQ", + "ERF.PRECISE", + "ERFC.PRECISE", + "EXPON.DIST", + "EXPONDIST", + "F.DIST", + "F.DIST.RT", + "F.INV", + "F.INV.RT", + "F.TEST", + "FDIST", + "FINV", + "FISHER", + "FISHERINV", + "FORECAST", + "FORECAST.ETS.ADD", + "FORECAST.ETS.MULT", + "FORECAST.ETS.PI.ADD", + "FORECAST.ETS.PI.MULT", + "FORECAST.ETS.SEASONALITY", + "FORECAST.ETS.STAT.ADD", + "FORECAST.ETS.STAT.MULT", + "FORECAST.LINEAR", + "FTEST", + "GAMMA", + "GAMMA.DIST", + "GAMMA.INV", + "GAMMADIST", + "GAMMAINV", + "GAMMALN", + "GAMMALN.PRECISE", + "GAUSS", + "GEOMEAN", + "HARMEAN", + "HYPGEOM.DIST", + "HYPGEOMDIST", + "INTERCEPT", + "KURT", + "LARGE", + "LOGINV", + "LOGNORM.DIST", + "LOGNORM.INV", + "LOGNORMDIST", + "MAX", + "MAXA", + "MAXIFS", + "MEDIAN", + "MIN", + "MINA", + "MINIFS", + "MODE", + "MODE.MULT", + "MODE.SNGL", + "NEGBINOM.DIST", + "NEGBINOMDIST", + "NORM.DIST", + "NORM.INV", + "NORM.S.DIST", + "NORM.S.INV", + "NORMDIST", + "NORMINV", + "NORMSDIST", + "NORMSINV", + "PEARSON", + "PERCENTILE", + "PERCENTILE.EXC", + "PERCENTILE.INC", + "PERCENTRANK", + "PERCENTRANK.EXC", + "PERCENTRANK.INC", + "PERMUT", + "PERMUTATIONA", + "PHI", + "POISSON", + "POISSON.DIST", + "PROB", + "QUARTILE", + "QUARTILE.EXC", + "QUARTILE.INC", + "RANK", + "RANK.AVG", + "RANK.EQ", + "RSQ", + "SKEW", + "SKEWP", + "SLOPE", + "SMALL", + "STANDARDIZE", + "STDEV", + "STDEV.P", + "STDEV.S", + "STDEVA", + "STDEVP", + "STDEVPA", + "STEYX", + "T.DIST", + "T.DIST.2T", + "T.DIST.RT", + "T.INV", + "T.INV.2T", + "T.TEST", + "TDIST", + "TINV", + "TRIMMEAN", + "TTEST", + "VAR", + "VAR.P", + "VAR.S", + "VARA", + "VARP", + "VARPA", + "WEIBULL", + "WEIBULL.DIST", + "Z.TEST", + "ZTEST", + nullptr + }; + + const char* aSpreadsheet[] = { + "ADDRESS", + "AREAS", + "CHOOSE", + "COLUMN", + "COLUMNS", + "DDE", + "ERROR.TYPE", + "ERRORTYPE", + "GETPIVOTDATA", + "HLOOKUP", + "HYPERLINK", + "INDEX", + "INDIRECT", + "LOOKUP", + "MATCH", + "OFFSET", + "ROW", + "ROWS", + "SHEET", + "SHEETS", + "STYLE", + "VLOOKUP", + nullptr + }; + + const char* aText[] = { + "ARABIC", + "ASC", + "BAHTTEXT", + "BASE", + "CHAR", + "CLEAN", + "CODE", + "CONCAT", + "CONCATENATE", + "DECIMAL", + "DOLLAR", + "ENCODEURL", + "EXACT", + "FILTERXML", + "FIND", + "FINDB", + "FIXED", + "JIS", + "LEFT", + "LEFTB", + "LEN", + "LENB", + "LOWER", + "MID", + "MIDB", + "NUMBERVALUE", + "PROPER", + "REGEX", + "REPLACE", + "REPLACEB", + "REPT", + "RIGHT", + "RIGHTB", + "ROMAN", + "ROT13", + "SEARCH", + "SEARCHB", + "SUBSTITUTE", + "T", + "TEXT", + "TEXTJOIN", + "TRIM", + "UNICHAR", + "UNICODE", + "UPPER", + "VALUE", + "WEBSERVICE", + nullptr + }; + + struct { + const char* Category; const char** Functions; + } aTests[] = { + { "Database", aDataBase }, + { "Date&Time", aDateTime }, + { "Financial", aFinancial }, + { "Information", aInformation }, + { "Logical", aLogical }, + { "Mathematical", aMathematical }, + { "Array", aArray }, + { "Statistical", aStatistical }, + { "Spreadsheet", aSpreadsheet }, + { "Text", aText }, + { "Add-in", nullptr }, + { nullptr, nullptr } + }; + + ScFunctionMgr* pFuncMgr = ScGlobal::GetStarCalcFunctionMgr(); + sal_uInt32 n = pFuncMgr->getCount(); + for (sal_uInt32 i = 0; i < n; ++i) + { + const formula::IFunctionCategory* pCat = pFuncMgr->getCategory(i); + CPPUNIT_ASSERT_MESSAGE("Unexpected category name", pCat->getName().equalsAscii(aTests[i].Category)); + sal_uInt32 nFuncCount = pCat->getCount(); + for (sal_uInt32 j = 0; j < nFuncCount; ++j) + { + const formula::IFunctionDescription* pFunc = pCat->getFunction(j); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected function name", OUString::createFromAscii(aTests[i].Functions[j]), pFunc->getFunctionName()); + } + } +} + +void Test::testGraphicsInGroup() +{ + m_pDoc->InsertTab(0, "TestTab"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("document should have one sheet to begin with.", + static_cast<SCTAB>(1), m_pDoc->GetTableCount()); + SCROW nRow1, nRow2; + bool bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("new sheet should have all rows visible", !bHidden && nRow1 == 0 && nRow2 == MAXROW); + + m_pDoc->InitDrawLayer(); + ScDrawLayer *pDrawLayer = m_pDoc->GetDrawLayer(); + CPPUNIT_ASSERT_MESSAGE("must have a draw layer", pDrawLayer != nullptr); + SdrPage* pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("must have a draw page", pPage != nullptr); + + { + //Add a square + tools::Rectangle aOrigRect(2,2,100,100); + SdrRectObj *pObj = new SdrRectObj(*pDrawLayer, aOrigRect); + pPage->InsertObject(pObj); + const tools::Rectangle &rNewRect = pObj->GetLogicRect(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("must have equal position and size", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + + ScDrawLayer::SetPageAnchored(*pObj); + + //Use a range of rows guaranteed to include all of the square + m_pDoc->ShowRows(0, 100, 0, false); + m_pDoc->SetDrawPageSize(0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Should not change when page anchored", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + m_pDoc->ShowRows(0, 100, 0, true); + m_pDoc->SetDrawPageSize(0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Should not change when page anchored", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + + ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *m_pDoc, 0, true); + CPPUNIT_ASSERT_EQUAL_MESSAGE("That shouldn't change size or positioning", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + + m_pDoc->ShowRows(0, 100, 0, false); + m_pDoc->SetDrawPageSize(0); + + const long TOLERANCE = 30; //30 hmm + + CPPUNIT_ASSERT_MESSAGE("Left and Right should be unchanged", + testEqualsWithTolerance(aOrigRect.Left(), rNewRect.Left(), TOLERANCE) && + testEqualsWithTolerance(aOrigRect.Right(), rNewRect.Right(), TOLERANCE)); + CPPUNIT_ASSERT_MESSAGE("Height should be minimum allowed height", + (rNewRect.Bottom() - rNewRect.Top()) <= 1); + m_pDoc->ShowRows(0, 100, 0, true); + m_pDoc->SetDrawPageSize(0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Should not change when cell anchored", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + } + + { + // Add a circle. + tools::Rectangle aOrigRect(10,10,210,210); // 200 x 200 + SdrCircObj* pObj = new SdrCircObj(*pDrawLayer, SdrCircKind::Full, aOrigRect); + pPage->InsertObject(pObj); + const tools::Rectangle& rNewRect = pObj->GetLogicRect(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Position and size of the circle shouldn't change when inserted into the page.", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + + ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *m_pDoc, 0, false); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Size changed when cell anchored. Not good.", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + + // Insert 2 rows at the top. This should push the circle object down. + m_pDoc->InsertRow(0, 0, MAXCOL, 0, 0, 2); + m_pDoc->SetDrawPageSize(0); + + // Make sure the size of the circle is still identical. + CPPUNIT_ASSERT_EQUAL_MESSAGE("Size of the circle has changed, but shouldn't!", + aOrigRect.GetSize(), rNewRect.GetSize()); + + // Delete 2 rows at the top. This should bring the circle object to its original position. + m_pDoc->DeleteRow(0, 0, MAXCOL, 0, 0, 2); + m_pDoc->SetDrawPageSize(0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to move back to its original position.", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + } + + { + // Add a line. + basegfx::B2DPolygon aTempPoly; + Point aStartPos(10,300), aEndPos(110,200); // bottom-left to top-right. + tools::Rectangle aOrigRect(10,200,110,300); // 100 x 100 + aTempPoly.append(basegfx::B2DPoint(aStartPos.X(), aStartPos.Y())); + aTempPoly.append(basegfx::B2DPoint(aEndPos.X(), aEndPos.Y())); + SdrPathObj* pObj = new SdrPathObj(*pDrawLayer, OBJ_LINE, basegfx::B2DPolyPolygon(aTempPoly)); + pObj->NbcSetLogicRect(aOrigRect); + pPage->InsertObject(pObj); + const tools::Rectangle& rNewRect = pObj->GetLogicRect(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Size differ.", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + + ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *m_pDoc, 0, false); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Size changed when cell-anchored. Not good.", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + + // Insert 2 rows at the top and delete them immediately. + m_pDoc->InsertRow(0, 0, MAXCOL, 0, 0, 2); + m_pDoc->DeleteRow(0, 0, MAXCOL, 0, 0, 2); + m_pDoc->SetDrawPageSize(0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Size of a line object changed after row insertion and removal.", + const_cast<const tools::Rectangle &>(aOrigRect), rNewRect); + + sal_Int32 n = pObj->GetPointCount(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be exactly 2 points in a line object.", static_cast<sal_Int32>(2), n); + CPPUNIT_ASSERT_MESSAGE("Line shape has changed.", + aStartPos == pObj->GetPoint(0) && aEndPos == pObj->GetPoint(1)); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testGraphicsOnSheetMove() +{ + m_pDoc->InsertTab(0, "Tab1"); + m_pDoc->InsertTab(1, "Tab2"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be only 2 sheets to begin with", static_cast<SCTAB>(2), m_pDoc->GetTableCount()); + + m_pDoc->InitDrawLayer(); + ScDrawLayer* pDrawLayer = m_pDoc->GetDrawLayer(); + CPPUNIT_ASSERT_MESSAGE("No drawing layer.", pDrawLayer); + SdrPage* pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("No page instance for the 1st sheet.", pPage); + + // Insert an object. + tools::Rectangle aObjRect(2,2,100,100); + SdrObject* pObj = new SdrRectObj(*pDrawLayer, aObjRect); + pPage->InsertObject(pObj); + ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *m_pDoc, 0, false); + + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be one object on the 1st sheet.", static_cast<size_t>(1), pPage->GetObjCount()); + + const ScDrawObjData* pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Object meta-data doesn't exist.", pData); + CPPUNIT_ASSERT_MESSAGE("Wrong sheet ID in cell anchor data!", pData->maStart.Tab() == 0 && pData->maEnd.Tab() == 0); + + pPage = pDrawLayer->GetPage(1); + CPPUNIT_ASSERT_MESSAGE("No page instance for the 2nd sheet.", pPage); + CPPUNIT_ASSERT_EQUAL_MESSAGE("2nd sheet shouldn't have any object.", static_cast<size_t>(0), pPage->GetObjCount()); + + // Insert a new sheet at left-end, and make sure the object has moved to + // the 2nd page. + m_pDoc->InsertTab(0, "NewTab"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be 3 sheets.", static_cast<SCTAB>(3), m_pDoc->GetTableCount()); + pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("1st sheet should have no object.", pPage && pPage->GetObjCount() == 0); + pPage = pDrawLayer->GetPage(1); + CPPUNIT_ASSERT_MESSAGE("2nd sheet should have one object.", pPage && pPage->GetObjCount() == 1); + pPage = pDrawLayer->GetPage(2); + CPPUNIT_ASSERT_MESSAGE("3rd sheet should have no object.", pPage && pPage->GetObjCount() == 0); + + CPPUNIT_ASSERT_MESSAGE("Wrong sheet ID in cell anchor data!", pData->maStart.Tab() == 1 && pData->maEnd.Tab() == 1); + + // Now, delete the sheet that just got inserted. The object should be back + // on the 1st sheet. + m_pDoc->DeleteTab(0); + pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("1st sheet should have one object.", pPage && pPage->GetObjCount() == 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Size and position of the object shouldn't change.", + aObjRect, pObj->GetLogicRect()); + + CPPUNIT_ASSERT_MESSAGE("Wrong sheet ID in cell anchor data!", pData->maStart.Tab() == 0 && pData->maEnd.Tab() == 0); + + // Move the 1st sheet to the last position. + m_pDoc->MoveTab(0, 1); + pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("1st sheet should have no object.", pPage && pPage->GetObjCount() == 0); + pPage = pDrawLayer->GetPage(1); + CPPUNIT_ASSERT_MESSAGE("2nd sheet should have one object.", pPage && pPage->GetObjCount() == 1); + CPPUNIT_ASSERT_MESSAGE("Wrong sheet ID in cell anchor data!", pData->maStart.Tab() == 1 && pData->maEnd.Tab() == 1); + + // Copy the 2nd sheet, which has one drawing object to the last position. + m_pDoc->CopyTab(1, 2); + pPage = pDrawLayer->GetPage(2); + CPPUNIT_ASSERT_MESSAGE("Copied sheet should have one object.", pPage && pPage->GetObjCount() == 1); + pObj = pPage->GetObj(0); + CPPUNIT_ASSERT_MESSAGE("Failed to get drawing object.", pObj); + pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to get drawing object meta-data.", pData); + CPPUNIT_ASSERT_MESSAGE("Wrong sheet ID in cell anchor data!", pData->maStart.Tab() == 2 && pData->maEnd.Tab() == 2); + + m_pDoc->DeleteTab(2); + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testToggleRefFlag() +{ + // In this test, there is no need to insert formula string into a cell in + // the document, as ScRefFinder does not depend on the content of the + // document except for the sheet names. + + m_pDoc->InsertTab(0, "Test"); + + { + // Calc A1: basic 2D reference + + OUString aFormula("=B100"); + ScAddress aPos(1, 5, 0); + ScRefFinder aFinder(aFormula, aPos, m_pDoc, formula::FormulaGrammar::CONV_OOO); + + // Original + CPPUNIT_ASSERT_EQUAL_MESSAGE("Does not equal the original text.", aFormula, aFinder.GetText()); + + // column relative / row relative -> column absolute / row absolute + aFinder.ToggleRel(0, aFormula.getLength()); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "Wrong conversion.", OUString("=$B$100"), aFormula ); + + // column absolute / row absolute -> column relative / row absolute + aFinder.ToggleRel(0, aFormula.getLength()); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "Wrong conversion.", OUString("=B$100"), aFormula ); + + // column relative / row absolute -> column absolute / row relative + aFinder.ToggleRel(0, aFormula.getLength()); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "Wrong conversion.", OUString("=$B100"), aFormula ); + + // column absolute / row relative -> column relative / row relative + aFinder.ToggleRel(0, aFormula.getLength()); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "Wrong conversion.", OUString("=B100"), aFormula ); + } + + { + // Excel R1C1: basic 2D reference + + OUString aFormula("=R2C1"); + ScAddress aPos(3, 5, 0); + ScRefFinder aFinder(aFormula, aPos, m_pDoc, formula::FormulaGrammar::CONV_XL_R1C1); + + // Original + CPPUNIT_ASSERT_EQUAL_MESSAGE("Does not equal the original text.", aFormula, aFinder.GetText()); + + // column absolute / row absolute -> column relative / row absolute + aFinder.ToggleRel(0, aFormula.getLength()); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=R2C[-3]"), aFormula); + + // column relative / row absolute - > column absolute / row relative + aFinder.ToggleRel(0, aFormula.getLength()); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=R[-4]C1"), aFormula); + + // column absolute / row relative -> column relative / row relative + aFinder.ToggleRel(0, aFormula.getLength()); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=R[-4]C[-3]"), aFormula); + + // column relative / row relative -> column absolute / row absolute + aFinder.ToggleRel(0, aFormula.getLength()); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=R2C1"), aFormula); + } + + { + // Excel R1C1: Selection at the end of the formula string and does not + // overlap the formula string at all (inspired by fdo#39135). + OUString aFormula("=R1C1"); + ScAddress aPos(1, 1, 0); + ScRefFinder aFinder(aFormula, aPos, m_pDoc, formula::FormulaGrammar::CONV_XL_R1C1); + + // Original + CPPUNIT_ASSERT_EQUAL(aFormula, aFinder.GetText()); + + // Make the column relative. + sal_Int32 n = aFormula.getLength(); + aFinder.ToggleRel(n, n); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=R1C[-1]"), aFormula); + + // Make the row relative. + n = aFormula.getLength(); + aFinder.ToggleRel(n, n); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=R[-1]C1"), aFormula); + + // Make both relative. + n = aFormula.getLength(); + aFinder.ToggleRel(n, n); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=R[-1]C[-1]"), aFormula); + + // Back to the original. + n = aFormula.getLength(); + aFinder.ToggleRel(n, n); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=R1C1"), aFormula); + } + + { + // Calc A1: + OUString aFormula("=A1+4"); + ScAddress aPos(1, 1, 0); + ScRefFinder aFinder(aFormula, aPos, m_pDoc, formula::FormulaGrammar::CONV_OOO); + + // Original + CPPUNIT_ASSERT_EQUAL(aFormula, aFinder.GetText()); + + // Set the cursor over the 'A1' part and toggle. + aFinder.ToggleRel(2, 2); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=$A$1+4"), aFormula); + + aFinder.ToggleRel(2, 2); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=A$1+4"), aFormula); + + aFinder.ToggleRel(2, 2); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=$A1+4"), aFormula); + + aFinder.ToggleRel(2, 2); + aFormula = aFinder.GetText(); + CPPUNIT_ASSERT_EQUAL(OUString("=A1+4"), aFormula); + } + + // TODO: Add more test cases esp. for 3D references, Excel A1 syntax, and + // partial selection within formula string. + + m_pDoc->DeleteTab(0); +} + +void Test::testAutofilter() +{ + OUString const aDBName("NONAME"); + + m_pDoc->InsertTab( 0, "Test" ); + + // cell contents (0 = empty cell) + const char* aData[][3] = { + { "C1", "C2", "C3" }, + { "0", "1", "A" }, + { "1", "2", nullptr }, + { "1", "2", "B" }, + { "0", "2", "B" } + }; + + SCCOL nCols = SAL_N_ELEMENTS(aData[0]); + SCROW nRows = SAL_N_ELEMENTS(aData); + + // Populate cells. + for (SCROW i = 0; i < nRows; ++i) + for (SCCOL j = 0; j < nCols; ++j) + if (aData[i][j]) + m_pDoc->SetString(j, i, 0, OUString::createFromAscii(aData[i][j])); + + ScDBData* pDBData = new ScDBData(aDBName, 0, 0, 0, nCols-1, nRows-1); + m_pDoc->SetAnonymousDBData(0, std::unique_ptr<ScDBData>(pDBData)); + + pDBData->SetAutoFilter(true); + ScRange aRange; + pDBData->GetArea(aRange); + m_pDoc->ApplyFlagsTab( aRange.aStart.Col(), aRange.aStart.Row(), + aRange.aEnd.Col(), aRange.aStart.Row(), + aRange.aStart.Tab(), ScMF::Auto); + + //create the query param + ScQueryParam aParam; + pDBData->GetQueryParam(aParam); + ScQueryEntry& rEntry = aParam.GetEntry(0); + rEntry.bDoQuery = true; + rEntry.nField = 0; + rEntry.eOp = SC_EQUAL; + rEntry.GetQueryItem().mfVal = 0; + // add queryParam to database range. + pDBData->SetQueryParam(aParam); + + // perform the query. + m_pDoc->Query(0, aParam, true); + + //control output + SCROW nRow1, nRow2; + bool bHidden = m_pDoc->RowHidden(2, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 2 & 3 should be hidden", bHidden && nRow1 == 2 && nRow2 == 3); + + // Remove filtering. + rEntry.Clear(); + m_pDoc->Query(0, aParam, true); + bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("All rows should be shown.", !bHidden && nRow1 == 0 && nRow2 == MAXROW); + + // Filter for non-empty cells by column C. + rEntry.bDoQuery = true; + rEntry.nField = 2; + rEntry.SetQueryByNonEmpty(); + m_pDoc->Query(0, aParam, true); + + // only row 3 should be hidden. The rest should be visible. + bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 1 & 2 should be visible.", !bHidden && nRow1 == 0 && nRow2 == 1); + bHidden = m_pDoc->RowHidden(2, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("row 3 should be hidden.", bHidden && nRow1 == 2 && nRow2 == 2); + bHidden = m_pDoc->RowHidden(3, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("row 4 and down should be visible.", !bHidden && nRow1 == 3 && nRow2 == MAXROW); + + // Now, filter for empty cells by column C. + rEntry.SetQueryByEmpty(); + m_pDoc->Query(0, aParam, true); + + // Now, only row 1 and 3, and 6 and down should be visible. + bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("row 1 should be visible.", !bHidden && nRow1 == 0 && nRow2 == 0); + bHidden = m_pDoc->RowHidden(1, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("row 2 should be hidden.", bHidden && nRow1 == 1 && nRow2 == 1); + bHidden = m_pDoc->RowHidden(2, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("row 3 should be visible.", !bHidden && nRow1 == 2 && nRow2 == 2); + bHidden = m_pDoc->RowHidden(3, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 4 & 5 should be hidden.", bHidden && nRow1 == 3 && nRow2 == 4); + bHidden = m_pDoc->RowHidden(5, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 6 and down should be all visible.", !bHidden && nRow1 == 5 && nRow2 == MAXROW); + + m_pDoc->DeleteTab(0); +} + +void Test::testAutoFilterTimeValue() +{ + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetString(ScAddress(0,0,0), "Hours"); + m_pDoc->SetValue(ScAddress(0,1,0), 72.3604166666671); + m_pDoc->SetValue(ScAddress(0,2,0), 265); + + ScDBData* pDBData = new ScDBData(STR_DB_GLOBAL_NONAME, 0, 0, 0, 0, 2); + m_pDoc->SetAnonymousDBData(0, std::unique_ptr<ScDBData>(pDBData)); + + // Apply the "hour:minute:second" format to A2:A3. + SvNumberFormatter* pFormatter = m_pDoc->GetFormatTable(); + sal_uInt32 nFormat = pFormatter->GetFormatIndex(NF_TIME_HH_MMSS, LANGUAGE_ENGLISH_US); + ScPatternAttr aNewAttrs(m_pDoc->GetPool()); + SfxItemSet& rSet = aNewAttrs.GetItemSet(); + rSet.Put(SfxUInt32Item(ATTR_VALUE_FORMAT, nFormat)); + + m_pDoc->ApplyPatternAreaTab(0, 1, 0, 2, 0, aNewAttrs); // apply it to A2:A3. + + printRange(m_pDoc, ScRange(0,0,0,0,2,0), "Data"); // A1:A3 + + // Make sure the hour:minute:second format is really applied. + CPPUNIT_ASSERT_EQUAL(OUString("1736:39:00"), m_pDoc->GetString(ScAddress(0,1,0))); // A2 + CPPUNIT_ASSERT_EQUAL(OUString("6360:00:00"), m_pDoc->GetString(ScAddress(0,2,0))); // A3 + + // Filter by the A2 value. Only A1 and A2 should be visible. + ScQueryParam aParam; + pDBData->GetQueryParam(aParam); + ScQueryEntry& rEntry = aParam.GetEntry(0); + rEntry.bDoQuery = true; + rEntry.nField = 0; + rEntry.eOp = SC_EQUAL; + rEntry.GetQueryItem().maString = m_pDoc->GetSharedStringPool().intern("1736:39:00"); + rEntry.GetQueryItem().meType = ScQueryEntry::ByString; + + pDBData->SetQueryParam(aParam); + + // perform the query. + m_pDoc->Query(0, aParam, true); + + // A1:A2 should be visible while A3 should be filtered out. + CPPUNIT_ASSERT_MESSAGE("A1 should be visible.", !m_pDoc->RowFiltered(0,0)); + CPPUNIT_ASSERT_MESSAGE("A2 should be visible.", !m_pDoc->RowFiltered(1,0)); + CPPUNIT_ASSERT_MESSAGE("A3 should be filtered out.", m_pDoc->RowFiltered(2,0)); + + m_pDoc->DeleteTab(0); +} + +void Test::testAdvancedFilter() +{ + m_pDoc->InsertTab(0, "Test"); + + // cell contents (nullptr = empty cell) + std::vector<std::vector<const char*>> aData = { + { "Value", "Tag" }, // A1:B11 + { "1", "R" }, + { "2", "R" }, + { "3", "R" }, + { "4", "C" }, + { "5", "C" }, + { "6", "C" }, + { "7", "R" }, + { "8", "R" }, + { "9", "R" }, + { "10", "C" }, + { nullptr }, + { "Value", "Tag" }, // A13:B14 + { "> 5", "R" }, + }; + + // Populate cells. + for (size_t nRow = 0; nRow < aData.size(); ++nRow) + { + const std::vector<const char*>& rRowData = aData[nRow]; + for (size_t nCol = 0; nCol < rRowData.size(); ++nCol) + { + const char* pCell = rRowData[nCol]; + if (pCell) + m_pDoc->SetString(nCol, nRow, 0, OUString::createFromAscii(pCell)); + } + } + + ScDBData* pDBData = new ScDBData(STR_DB_GLOBAL_NONAME, 0, 0, 0, 1, 10); + m_pDoc->SetAnonymousDBData(0, std::unique_ptr<ScDBData>(pDBData)); + + ScRange aDataRange(0,0,0,1,10,0); + ScRange aFilterRuleRange(0,12,0,1,13,0); + + printRange(m_pDoc, aDataRange, "Data"); + printRange(m_pDoc, aFilterRuleRange, "Filter Rule"); + + ScQueryParam aQueryParam; + aQueryParam.bHasHeader = true; + aQueryParam.nCol1 = aDataRange.aStart.Col(); + aQueryParam.nRow1 = aDataRange.aStart.Row(); + aQueryParam.nCol2 = aDataRange.aEnd.Col(); + aQueryParam.nRow2 = aDataRange.aEnd.Row(); + aQueryParam.nTab = aDataRange.aStart.Tab(); + + bool bGood = m_pDoc->CreateQueryParam(aFilterRuleRange, aQueryParam); + CPPUNIT_ASSERT_MESSAGE("failed to create query param.", bGood); + + // First entry is for the 'Value' field, and is greater than 5. + ScQueryEntry aEntry = aQueryParam.GetEntry(0); + CPPUNIT_ASSERT(aEntry.bDoQuery); + CPPUNIT_ASSERT_EQUAL(SCCOLROW(0), aEntry.nField); + CPPUNIT_ASSERT_EQUAL(SC_GREATER, aEntry.eOp); + + ScQueryEntry::QueryItemsType aItems = aEntry.GetQueryItems(); + CPPUNIT_ASSERT_EQUAL(size_t(1), aItems.size()); + CPPUNIT_ASSERT_EQUAL(ScQueryEntry::ByValue, aItems[0].meType); + CPPUNIT_ASSERT_EQUAL(5.0, aItems[0].mfVal); + + // Second entry is for the 'Tag' field, and is == 'R'. + aEntry = aQueryParam.GetEntry(1); + CPPUNIT_ASSERT(aEntry.bDoQuery); + CPPUNIT_ASSERT_EQUAL(SCCOLROW(1), aEntry.nField); + CPPUNIT_ASSERT_EQUAL(SC_EQUAL, aEntry.eOp); + + aItems = aEntry.GetQueryItems(); + CPPUNIT_ASSERT_EQUAL(size_t(1), aItems.size()); + CPPUNIT_ASSERT_EQUAL(ScQueryEntry::ByString, aItems[0].meType); + CPPUNIT_ASSERT_EQUAL(OUString("R"), aItems[0].maString.getString()); + + // perform the query. + m_pDoc->Query(0, aQueryParam, true); + + // Only rows 1,8-10 should be visible. + bool bFiltered = m_pDoc->RowFiltered(0, 0); + CPPUNIT_ASSERT_MESSAGE("row 1 (header row) should be visible", !bFiltered); + + SCROW nRow1 = -1, nRow2 = -1; + bFiltered = m_pDoc->RowFiltered(1, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 2-7 should be filtered out.", bFiltered && nRow1 == 1 && nRow2 == 6); + + bFiltered = m_pDoc->RowFiltered(7, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("rows 8-10 should be visible.", !bFiltered && nRow1 == 7 && nRow2 == 9); + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPaste() +{ + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + //test copy&paste + ScUndoPaste + //copy local and global range names in formulas + //string cells and value cells + m_pDoc->SetValue(0, 0, 0, 1); + m_pDoc->SetValue(3, 0, 0, 0); + m_pDoc->SetValue(3, 1, 0, 1); + m_pDoc->SetValue(3, 2, 0, 2); + m_pDoc->SetValue(3, 3, 0, 3); + m_pDoc->SetString(2, 0, 0, "test"); + ScAddress aAdr (0, 0, 0); + + //create some range names, local and global + ScRangeData* pLocal1 = new ScRangeData( m_pDoc, "local1", aAdr); + ScRangeData* pLocal2 = new ScRangeData( m_pDoc, "local2", aAdr); + ScRangeData* pLocal3 = new ScRangeData( m_pDoc, "local3", "$Sheet1.$A$1"); + ScRangeData* pLocal4 = new ScRangeData( m_pDoc, "local4", "Sheet1.$A$1"); + ScRangeData* pLocal5 = new ScRangeData( m_pDoc, "local5", "$A$1"); // implicit relative sheet reference + ScRangeData* pGlobal = new ScRangeData( m_pDoc, "global", aAdr); + const OUString aGlobal2Symbol("$Sheet1.$A$1:$A$23"); + ScRangeData* pGlobal2 = new ScRangeData( m_pDoc, "global2", aGlobal2Symbol); + std::unique_ptr<ScRangeName> pGlobalRangeName(new ScRangeName()); + pGlobalRangeName->insert(pGlobal); + pGlobalRangeName->insert(pGlobal2); + std::unique_ptr<ScRangeName> pLocalRangeName1(new ScRangeName()); + pLocalRangeName1->insert(pLocal1); + pLocalRangeName1->insert(pLocal2); + pLocalRangeName1->insert(pLocal3); + pLocalRangeName1->insert(pLocal4); + pLocalRangeName1->insert(pLocal5); + m_pDoc->SetRangeName(std::move(pGlobalRangeName)); + m_pDoc->SetRangeName(0, std::move(pLocalRangeName1)); + + // Add formula to B1. + OUString aFormulaString("=local1+global+SUM($C$1:$D$4)+local3+local4+local5"); + m_pDoc->SetString(1, 0, 0, aFormulaString); + + double fValue = m_pDoc->GetValue(ScAddress(1,0,0)); + ASSERT_DOUBLES_EQUAL_MESSAGE("formula should return 11", fValue, 11); + + // add notes to A1:C1 + ScAddress aAdrA1 (0, 0, 0); // empty cell content + OUString const aHelloA1("Hello world in A1"); + ScPostIt* pNoteA1 = m_pDoc->GetOrCreateNote(aAdrA1); + pNoteA1->SetText(aAdrA1, aHelloA1); + ScAddress aAdrB1 (1, 0, 0); // formula cell content + OUString const aHelloB1("Hello world in B1"); + ScPostIt* pNoteB1 = m_pDoc->GetOrCreateNote(aAdrB1); + pNoteB1->SetText(aAdrB1, aHelloB1); + ScAddress aAdrC1 (2, 0, 0); // string cell content + OUString const aHelloC1("Hello world in C1"); + ScPostIt* pNoteC1 = m_pDoc->GetOrCreateNote(aAdrC1); + pNoteC1->SetText(aAdrC1, aHelloC1); + + //copy Sheet1.A1:C1 to Sheet2.A2:C2 + ScRange aRange(0,0,0,2,0,0); + ScDocument aClipDoc(SCDOCMODE_CLIP); + copyToClip(m_pDoc, aRange, &aClipDoc); + + aRange = ScRange(0,1,1,2,1,1);//target: Sheet2.A2:C2 + ScDocumentUniquePtr pUndoDoc(new ScDocument(SCDOCMODE_UNDO)); + pUndoDoc->InitUndo(m_pDoc, 1, 1, true, true); + std::unique_ptr<ScUndoPaste> pUndo(createUndoPaste(getDocShell(), aRange, std::move(pUndoDoc))); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aRange); + m_pDoc->CopyFromClip(aRange, aMark, InsertDeleteFlags::ALL, nullptr, &aClipDoc); + + //check values after copying + OUString aString; + m_pDoc->GetFormula(1,1,1, aString); + CPPUNIT_ASSERT_EQUAL_MESSAGE("formula string was not copied correctly", aString, aFormulaString); + // Only the global range points to Sheet1.A1, all copied sheet-local ranges + // to Sheet2.A1 that is empty, hence the result is 1, not 2. + fValue = m_pDoc->GetValue(ScAddress(1,1,1)); + ASSERT_DOUBLES_EQUAL_MESSAGE("copied formula should return 1", 1.0, fValue); + fValue = m_pDoc->GetValue(ScAddress(0,1,1)); + ASSERT_DOUBLES_EQUAL_MESSAGE("copied value should be 1", 1.0, fValue); + + ScRange aSheet2A1(0,0,1,0,0,1); + + //check local range name after copying + pLocal1 = m_pDoc->GetRangeName(1)->findByUpperName(OUString("LOCAL1")); + CPPUNIT_ASSERT_MESSAGE("local range name 1 should be copied", pLocal1); + ScRange aRangeLocal1; + bool bIsValidRef1 = pLocal1->IsValidReference(aRangeLocal1); + CPPUNIT_ASSERT_MESSAGE("local range name 1 should be valid", bIsValidRef1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("local range 1 should now point to Sheet2.A1", aSheet2A1, aRangeLocal1); + + pLocal2 = m_pDoc->GetRangeName(1)->findByUpperName(OUString("LOCAL2")); + CPPUNIT_ASSERT_MESSAGE("local2 should not be copied", !pLocal2); + + pLocal3 = m_pDoc->GetRangeName(1)->findByUpperName(OUString("LOCAL3")); + CPPUNIT_ASSERT_MESSAGE("local range name 3 should be copied", pLocal3); + ScRange aRangeLocal3; + bool bIsValidRef3 = pLocal3->IsValidReference(aRangeLocal3); + CPPUNIT_ASSERT_MESSAGE("local range name 3 should be valid", bIsValidRef3); + CPPUNIT_ASSERT_EQUAL_MESSAGE("local range 3 should now point to Sheet2.A1", aSheet2A1, aRangeLocal3); + + pLocal4 = m_pDoc->GetRangeName(1)->findByUpperName(OUString("LOCAL4")); + CPPUNIT_ASSERT_MESSAGE("local range name 4 should be copied", pLocal4); + ScRange aRangeLocal4; + bool bIsValidRef4 = pLocal4->IsValidReference(aRangeLocal4); + CPPUNIT_ASSERT_MESSAGE("local range name 4 should be valid", bIsValidRef4); + CPPUNIT_ASSERT_EQUAL_MESSAGE("local range 4 should now point to Sheet2.A1", aSheet2A1, aRangeLocal4); + + pLocal5 = m_pDoc->GetRangeName(1)->findByUpperName(OUString("LOCAL5")); + CPPUNIT_ASSERT_MESSAGE("local range name 5 should be copied", pLocal5); + ScRange aRangeLocal5; + bool bIsValidRef5 = pLocal5->IsValidReference(aRangeLocal5); + CPPUNIT_ASSERT_MESSAGE("local range name 5 should be valid", bIsValidRef5); + CPPUNIT_ASSERT_EQUAL_MESSAGE("local range 5 should now point to Sheet2.A1", aSheet2A1, aRangeLocal5); + + // check notes after copying + CPPUNIT_ASSERT_MESSAGE("There should be a note on Sheet2.A2", m_pDoc->HasNote(ScAddress(0, 1, 1))); + CPPUNIT_ASSERT_MESSAGE("There should be a note on Sheet2.B2", m_pDoc->HasNote(ScAddress(1, 1, 1))); + CPPUNIT_ASSERT_MESSAGE("There should be a note on Sheet2.C2", m_pDoc->HasNote(ScAddress(2, 1, 1))); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note content on Sheet1.A1 not copied to Sheet2.A2, empty cell content", + m_pDoc->GetNote(ScAddress(0, 0, 0))->GetText(), m_pDoc->GetNote(ScAddress(0, 1, 1))->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note content on Sheet1.B1 not copied to Sheet2.B2, formula cell content", + m_pDoc->GetNote(ScAddress(1, 0, 0))->GetText(), m_pDoc->GetNote(ScAddress(1, 1, 1))->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note content on Sheet1.C1 not copied to Sheet2.C2, string cell content", + m_pDoc->GetNote(ScAddress(2, 0, 0))->GetText(), m_pDoc->GetNote(ScAddress(2, 1, 1))->GetText()); + + //check undo and redo + pUndo->Undo(); + fValue = m_pDoc->GetValue(ScAddress(1,1,1)); + ASSERT_DOUBLES_EQUAL_MESSAGE("after undo formula should return nothing", fValue, 0); + aString = m_pDoc->GetString(2, 1, 1); + CPPUNIT_ASSERT_MESSAGE("after undo, string should be removed", aString.isEmpty()); + CPPUNIT_ASSERT_MESSAGE("after undo, note on A2 should be removed", !m_pDoc->HasNote(ScAddress(0, 1, 1))); + CPPUNIT_ASSERT_MESSAGE("after undo, note on B2 should be removed", !m_pDoc->HasNote(ScAddress(1, 1, 1))); + CPPUNIT_ASSERT_MESSAGE("after undo, note on C2 should be removed", !m_pDoc->HasNote(ScAddress(2, 1, 1))); + + pUndo->Redo(); + fValue = m_pDoc->GetValue(ScAddress(1,1,1)); + ASSERT_DOUBLES_EQUAL_MESSAGE("formula should return 1 after redo", 1.0, fValue); + aString = m_pDoc->GetString(2, 1, 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Cell Sheet2.C2 should contain: test", OUString("test"), aString); + m_pDoc->GetFormula(1,1,1, aString); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Formula should be correct again", aFormulaString, aString); + + CPPUNIT_ASSERT_MESSAGE("After Redo, there should be a note on Sheet2.A2", m_pDoc->HasNote(ScAddress(0, 1, 1))); + CPPUNIT_ASSERT_MESSAGE("After Redo, there should be a note on Sheet2.B2", m_pDoc->HasNote(ScAddress(1, 1, 1))); + CPPUNIT_ASSERT_MESSAGE("After Redo, there should be a note on Sheet2.C2", m_pDoc->HasNote(ScAddress(2, 1, 1))); + CPPUNIT_ASSERT_EQUAL_MESSAGE("After Redo, note again on Sheet2.A2, empty cell content", + m_pDoc->GetNote(ScAddress(0, 0, 0))->GetText(), m_pDoc->GetNote(ScAddress(0, 1, 1))->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("After Redo, note again on Sheet2.B2, formula cell content", + m_pDoc->GetNote(ScAddress(1, 0, 0))->GetText(), m_pDoc->GetNote(ScAddress(1, 1, 1))->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("After Redo, note again on Sheet2.C2, string cell content", + m_pDoc->GetNote(ScAddress(2, 0, 0))->GetText(), m_pDoc->GetNote(ScAddress(2, 1, 1))->GetText()); + + + // Copy Sheet1.A11:A13 to Sheet1.A7:A9, both within global2 range. + aRange = ScRange(0,10,0,0,12,0); + ScDocument aClipDoc2(SCDOCMODE_CLIP); + copyToClip(m_pDoc, aRange, &aClipDoc2); + + aRange = ScRange(0,6,0,0,8,0); + aMark.SetMarkArea(aRange); + m_pDoc->CopyFromClip(aRange, aMark, InsertDeleteFlags::ALL, nullptr, &aClipDoc2); + + // The global2 range must not have changed. + pGlobal2 = m_pDoc->GetRangeName()->findByUpperName("GLOBAL2"); + CPPUNIT_ASSERT_MESSAGE("GLOBAL2 name not found", pGlobal2); + OUString aSymbol; + pGlobal2->GetSymbol(aSymbol); + CPPUNIT_ASSERT_EQUAL_MESSAGE("GLOBAL2 named range changed", aGlobal2Symbol, aSymbol); + + + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteAsLink() +{ + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // Turn on auto calc. + + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + + m_pDoc->SetValue(ScAddress(0,0,0), 1); // A1 + m_pDoc->SetValue(ScAddress(0,1,0), 2); // A2 + m_pDoc->SetValue(ScAddress(0,2,0), 3); // A3 + + ScRange aRange(0,0,0,0,2,0); // Copy A1:A3 to clip. + ScDocument aClipDoc(SCDOCMODE_CLIP); + copyToClip(m_pDoc, aRange, &aClipDoc); + + aRange = ScRange(1,1,1,1,3,1); // Paste to B2:B4 on Sheet2. + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aRange); + // Paste range as link. + m_pDoc->CopyFromClip(aRange, aMark, InsertDeleteFlags::CONTENTS, nullptr, &aClipDoc, true, true); + + // Check pasted content to make sure they reference the correct cells. + ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(1,1,1)); + CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC); + CPPUNIT_ASSERT_EQUAL(1.0, pFC->GetValue()); + + pFC = m_pDoc->GetFormulaCell(ScAddress(1,2,1)); + CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC); + CPPUNIT_ASSERT_EQUAL(2.0, pFC->GetValue()); + + pFC = m_pDoc->GetFormulaCell(ScAddress(1,3,1)); + CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC); + CPPUNIT_ASSERT_EQUAL(3.0, pFC->GetValue()); + + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteTranspose() +{ + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + m_pDoc->SetValue(0, 0, 0, 1); + m_pDoc->SetString(1, 0, 0, "=A1+1"); + m_pDoc->SetString(2, 0, 0, "test"); + + // add notes to A1:C1 + ScAddress aAdrA1 (0, 0, 0); // numerical cell content + OUString const aHelloA1("Hello world in A1"); + ScPostIt* pNoteA1 = m_pDoc->GetOrCreateNote(aAdrA1); + pNoteA1->SetText(aAdrA1, aHelloA1); + ScAddress aAdrB1 (1, 0, 0); // formula cell content + OUString const aHelloB1("Hello world in B1"); + ScPostIt* pNoteB1 = m_pDoc->GetOrCreateNote(aAdrB1); + pNoteB1->SetText(aAdrB1, aHelloB1); + ScAddress aAdrC1 (2, 0, 0); // string cell content + OUString const aHelloC1("Hello world in C1"); + ScPostIt* pNoteC1 = m_pDoc->GetOrCreateNote(aAdrC1); + pNoteC1->SetText(aAdrC1, aHelloC1); + + // transpose clipboard, paste and check on Sheet2 + m_pDoc->InsertTab(1, "Sheet2"); + + ScRange aSrcRange(0,0,0,2,0,0); + ScDocument aNewClipDoc(SCDOCMODE_CLIP); + copyToClip(m_pDoc, aSrcRange, &aNewClipDoc); + + ScDocumentUniquePtr pTransClip(new ScDocument(SCDOCMODE_CLIP)); + aNewClipDoc.TransposeClip(pTransClip.get(), InsertDeleteFlags::ALL, false); + + ScRange aDestRange(3,1,1,3,3,1);//target: Sheet2.D2:D4 + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aDestRange); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::ALL, nullptr, pTransClip.get()); + pTransClip.reset(); + + //check cell content after transposed copy/paste + OUString aString = m_pDoc->GetString(3, 3, 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Cell Sheet2.D4 should contain: test", OUString("test"), aString); + double fValue = m_pDoc->GetValue(ScAddress(3,1,1)); + ASSERT_DOUBLES_EQUAL_MESSAGE("transposed copied cell should return 1", fValue, 1); + fValue = m_pDoc->GetValue(ScAddress(3,2,1)); + ASSERT_DOUBLES_EQUAL_MESSAGE("transposed copied formula should return 2", fValue, 2); + m_pDoc->GetFormula(3, 2, 1, aString); + CPPUNIT_ASSERT_EQUAL_MESSAGE("transposed formula should point on Sheet2.D2", OUString("=D2+1"), aString); + + // check notes after transposed copy/paste + CPPUNIT_ASSERT_MESSAGE("There should be a note on Sheet2.D2", m_pDoc->HasNote(ScAddress(3, 1, 1))); + CPPUNIT_ASSERT_MESSAGE("There should be a note on Sheet2.D3", m_pDoc->HasNote(ScAddress(3, 2, 1))); + CPPUNIT_ASSERT_MESSAGE("There should be a note on Sheet2.D4", m_pDoc->HasNote(ScAddress(3, 3, 1))); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Content of cell note on Sheet2.D2", + m_pDoc->GetNote(ScAddress(3, 1, 1))->GetText(), m_pDoc->GetNote(ScAddress(0, 0, 0))->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Content of cell note on Sheet2.D3", + m_pDoc->GetNote(ScAddress(3, 2, 1))->GetText(), m_pDoc->GetNote(ScAddress(1, 0, 0))->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Content of cell note on Sheet2.D4", + m_pDoc->GetNote(ScAddress(3, 3, 1))->GetText(), m_pDoc->GetNote(ScAddress(2, 0, 0))->GetText()); + + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); + +} + +void Test::testCopyPasteMultiRange() +{ + m_pDoc->InsertTab(0, "Test"); + + // Fill A2:B6 with numbers. + for (SCROW nRow = 1; nRow <= 5; ++nRow) + { + for (SCCOL nCol = 0; nCol <= 1; ++nCol) + { + ScAddress aPos(nCol,nRow,0); + m_pDoc->SetValue(aPos, nRow+nCol); + } + } + + // Fill D9:E11 with numbers. + for (SCROW nRow = 8; nRow <= 10; ++nRow) + { + for (SCCOL nCol = 3; nCol <= 4; ++nCol) + { + ScAddress aPos(nCol,nRow,0); + m_pDoc->SetValue(aPos, 10.0); + } + } + + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + + // Copy A2:B2, A4:B4, and A6:B6 to clipboard. + ScDocument aClipDoc(SCDOCMODE_CLIP); + ScClipParam aClipParam; + aClipParam.maRanges.push_back(ScRange(0,1,0,1,1,0)); // A2:B2 + aClipParam.maRanges.push_back(ScRange(0,3,0,1,3,0)); // A4:B4 + aClipParam.maRanges.push_back(ScRange(0,5,0,1,5,0)); // A6:B6 + aClipParam.meDirection = ScClipParam::Row; + m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false); + + // Paste to D9:E11, and make sure it won't crash (rhbz#1080196). + m_pDoc->CopyMultiRangeFromClip(ScAddress(3,8,0), aMark, InsertDeleteFlags::CONTENTS, &aClipDoc); + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(3,8,0))); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(4,8,0))); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(3,9,0))); + CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(4,9,0))); + CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(ScAddress(3,10,0))); + CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(4,10,0))); + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteSkipEmpty() +{ + struct Check + { + const char* mpStr; + Color maColor; + bool mbHasNote; + }; + + struct TestRange + { + ScDocument* mpDoc; + + explicit TestRange( ScDocument* pDoc ) : mpDoc(pDoc) {} + + bool checkRange( const ScAddress& rPos, const Check* p, const Check* pEnd ) + { + ScAddress aPos(rPos); + OUString aPosStr = aPos.Format(ScRefFlags::VALID); + for (; p != pEnd; ++p, aPos.IncRow()) + { + if (!mpDoc->GetString(aPos).equalsAscii(p->mpStr)) + { + cerr << aPosStr << ": incorrect string value: expected='" << p->mpStr << "' actual='" << mpDoc->GetString(aPos) << endl; + return false; + } + + const SvxBrushItem* pBrush = mpDoc->GetAttr(aPos, ATTR_BACKGROUND); + if (!pBrush) + { + cerr << aPosStr << ": failed to get brush item from the cell." << endl; + return false; + } + + if (pBrush->GetColor() != p->maColor) + { + Color aExpected = p->maColor; + Color aActual = pBrush->GetColor(); + cerr << aPosStr << ": incorrect cell background color: expected=(" + << static_cast<int>(aExpected.GetRed()) << "," + << static_cast<int>(aExpected.GetGreen()) << "," + << static_cast<int>(aExpected.GetBlue()) << "), actual=(" + << static_cast<int>(aActual.GetRed()) << "," + << static_cast<int>(aActual.GetGreen()) << "," + << static_cast<int>(aActual.GetBlue()) << ")" << endl; + + return false; + } + + bool bHasNote = mpDoc->HasNote(aPos); + if (bHasNote != p->mbHasNote) + { + cerr << aPosStr << ": "; + if (p->mbHasNote) + cerr << "this cell should have a cell note, but doesn't." << endl; + else + cerr << "this cell should NOT have a cell note, but one is found." << endl; + + return false; + } + } + + return true; + } + + } aTest(m_pDoc); + + m_pDoc->InsertTab(0, "Test"); + m_pDoc->InitDrawLayer(&getDocShell()); // for cell note objects. + + ScRange aSrcRange(0,0,0,0,4,0); + ScRange aDestRange(1,0,0,1,4,0); + + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aDestRange); + + // Put some texts in B1:B5. + m_pDoc->SetString(ScAddress(1,0,0), "A"); + m_pDoc->SetString(ScAddress(1,1,0), "B"); + m_pDoc->SetString(ScAddress(1,2,0), "C"); + m_pDoc->SetString(ScAddress(1,3,0), "D"); + m_pDoc->SetString(ScAddress(1,4,0), "E"); + + // Set the background color of B1:B5 to blue. + ScPatternAttr aCellBackColor(m_pDoc->GetPool()); + aCellBackColor.GetItemSet().Put(SvxBrushItem(COL_BLUE, ATTR_BACKGROUND)); + m_pDoc->ApplyPatternAreaTab(1, 0, 1, 4, 0, aCellBackColor); + + // Insert notes to B1:B5. + m_pDoc->GetOrCreateNote(ScAddress(1,0,0)); + m_pDoc->GetOrCreateNote(ScAddress(1,1,0)); + m_pDoc->GetOrCreateNote(ScAddress(1,2,0)); + m_pDoc->GetOrCreateNote(ScAddress(1,3,0)); + m_pDoc->GetOrCreateNote(ScAddress(1,4,0)); + + // Prepare a clipboard content interleaved with empty cells. + ScDocument aClipDoc(SCDOCMODE_CLIP); + aClipDoc.ResetClip(m_pDoc, &aMark); + ScClipParam aParam(aSrcRange, false); + aClipDoc.SetClipParam(aParam); + aClipDoc.SetString(ScAddress(0,0,0), "Clip1"); + aClipDoc.SetString(ScAddress(0,2,0), "Clip2"); + aClipDoc.SetString(ScAddress(0,4,0), "Clip3"); + + // Set the background color of A1:A5 to yellow. + aCellBackColor.GetItemSet().Put(SvxBrushItem(COL_YELLOW, ATTR_BACKGROUND)); + aClipDoc.ApplyPatternAreaTab(0, 0, 0, 4, 0, aCellBackColor); + + CPPUNIT_ASSERT_EQUAL(CELLTYPE_STRING, aClipDoc.GetCellType(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_NONE, aClipDoc.GetCellType(ScAddress(0,1,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_STRING, aClipDoc.GetCellType(ScAddress(0,2,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_NONE, aClipDoc.GetCellType(ScAddress(0,3,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_STRING, aClipDoc.GetCellType(ScAddress(0,4,0))); + + // Check the initial condition. + { + static const Check aChecks[] = { + { "A", COL_BLUE, true }, + { "B", COL_BLUE, true }, + { "C", COL_BLUE, true }, + { "D", COL_BLUE, true }, + { "E", COL_BLUE, true }, + }; + + bool bRes = aTest.checkRange(ScAddress(1,0,0), aChecks, aChecks + SAL_N_ELEMENTS(aChecks)); + CPPUNIT_ASSERT_MESSAGE("Initial check failed.", bRes); + } + + // Create undo document. + ScDocumentUniquePtr pUndoDoc(new ScDocument(SCDOCMODE_UNDO)); + pUndoDoc->InitUndo(m_pDoc, 0, 0); + m_pDoc->CopyToDocument(aDestRange, InsertDeleteFlags::ALL, false, *pUndoDoc, &aMark); + + // Paste clipboard content onto A1:A5 but skip empty cells. + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::ALL, pUndoDoc.get(), &aClipDoc, true, false, false, true/*bSkipEmpty*/); + + // Create redo document. + ScDocumentUniquePtr pRedoDoc(new ScDocument(SCDOCMODE_UNDO)); + pRedoDoc->InitUndo(m_pDoc, 0, 0); + m_pDoc->CopyToDocument(aDestRange, InsertDeleteFlags::ALL, false, *pRedoDoc, &aMark); + + // Create an undo object for this. + std::unique_ptr<ScRefUndoData> pRefUndoData(new ScRefUndoData(m_pDoc)); + ScUndoPaste aUndo(&getDocShell(), aDestRange, aMark, std::move(pUndoDoc), std::move(pRedoDoc), InsertDeleteFlags::ALL, std::move(pRefUndoData)); + + // Check the content after the paste. + { + static const Check aChecks[] = { + { "Clip1", COL_YELLOW, false }, + { "B", COL_BLUE, true }, + { "Clip2", COL_YELLOW, false }, + { "D", COL_BLUE, true }, + { "Clip3", COL_YELLOW, false }, + }; + + bool bRes = aTest.checkRange(ScAddress(1,0,0), aChecks, aChecks + SAL_N_ELEMENTS(aChecks)); + CPPUNIT_ASSERT_MESSAGE("Check after paste failed.", bRes); + } + + // Undo, and check the content. + aUndo.Undo(); + { + static const Check aChecks[] = { + { "A", COL_BLUE, true }, + { "B", COL_BLUE, true }, + { "C", COL_BLUE, true }, + { "D", COL_BLUE, true }, + { "E", COL_BLUE, true }, + }; + + bool bRes = aTest.checkRange(ScAddress(1,0,0), aChecks, aChecks + SAL_N_ELEMENTS(aChecks)); + CPPUNIT_ASSERT_MESSAGE("Check after undo failed.", bRes); + } + + // Redo, and check the content again. + aUndo.Redo(); + { + static const Check aChecks[] = { + { "Clip1", COL_YELLOW, false }, + { "B", COL_BLUE, true }, + { "Clip2", COL_YELLOW, false }, + { "D", COL_BLUE, true }, + { "Clip3", COL_YELLOW, false }, + }; + + bool bRes = aTest.checkRange(ScAddress(1,0,0), aChecks, aChecks + SAL_N_ELEMENTS(aChecks)); + CPPUNIT_ASSERT_MESSAGE("Check after redo failed.", bRes); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteSkipEmpty2() +{ + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetString(ScAddress(0,0,0), "A"); + m_pDoc->SetString(ScAddress(2,0,0), "C"); + + // Copy A1:C1 to clipboard. + ScDocument aClipDoc(SCDOCMODE_CLIP); + aClipDoc.ResetClip(m_pDoc, static_cast<SCTAB>(0)); + copyToClip(m_pDoc, ScRange(0,0,0,2,0,0), &aClipDoc); + + // Paste to A3 with the skip empty option set. This used to freeze. (fdo#77735) + ScRange aDestRange(0,2,0,2,2,0); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aDestRange); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::ALL, nullptr, &aClipDoc, false, false, true, true); + + CPPUNIT_ASSERT_EQUAL(OUString("A"), m_pDoc->GetString(ScAddress(0,2,0))); + CPPUNIT_ASSERT_EQUAL_MESSAGE("B3 should be empty.", CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(1,2,0))); + CPPUNIT_ASSERT_EQUAL(OUString("C"), m_pDoc->GetString(ScAddress(2,2,0))); + + m_pDoc->DeleteTab(0); +} + +void Test::testCutPasteRefUndo() +{ + // Testing scenario: A2 references B2, and B2 gets cut and pasted onto C2, + // which updates A2's formula to reference C2. Then the paste action gets + // undone, which should also undo A2's formula to reference back to B2. + + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc. + + m_pDoc->InsertTab(0, "Test"); + + // A2 references B2. + m_pDoc->SetString(ScAddress(0,1,0), "=B2"); + + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + + // Set up clip document for cutting of B2. + ScDocument aClipDoc(SCDOCMODE_CLIP); + aClipDoc.ResetClip(m_pDoc, &aMark); + ScClipParam aParam(ScAddress(1,1,0), true); + aClipDoc.SetClipParam(aParam); + aClipDoc.SetValue(ScAddress(1,1,0), 12.0); + + // Set up undo document for reference update. + ScDocumentUniquePtr pUndoDoc(new ScDocument(SCDOCMODE_UNDO)); + pUndoDoc->InitUndo(m_pDoc, 0, 0); + + // Do the pasting of 12 into C2. This should update A2 to reference C2. + m_pDoc->CopyFromClip(ScAddress(2,1,0), aMark, InsertDeleteFlags::CONTENTS, pUndoDoc.get(), &aClipDoc); + CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(0,1,0)); + + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "C2", "A2 should be referencing C2."); + + // At this point, the ref undo document should contain a formula cell at A2 that references B2. + ASSERT_FORMULA_EQUAL(*pUndoDoc, ScAddress(0,1,0), "B2", "A2 in the undo document should be referencing B2."); + + ScUndoPaste aUndo(&getDocShell(), ScRange(2,1,0), aMark, std::move(pUndoDoc), nullptr, InsertDeleteFlags::CONTENTS, nullptr, false, nullptr); + aUndo.Undo(); + + // Now A2 should be referencing B2 once again. + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "B2", "A2 should be referencing B2 after undo."); + + m_pDoc->DeleteTab(0); +} + +void Test::testCutPasteGroupRefUndo() +{ + // Test that Cut&Paste part of a grouped formula adjusts references + // correctly and Undo works. + + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc. + + m_pDoc->InsertTab(0, "Test"); + + // Formula data in A1:A9 + std::vector<std::vector<const char*>> aData = { + { "1" }, + { "=A1+A1" }, + { "=A2+A1" }, + { "=A3+A2" }, + { "=A4+A3" }, + { "=A5+A4" }, + { "=A6+A5" }, + { "=A7+A6" }, + { "=A8+A7" } + }; + ScAddress aPos(0,0,0); + ScRange aDataRange = insertRangeData( m_pDoc, aPos, aData); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to insert data", aPos, aDataRange.aStart); + + // Check initial data. + const char* aDataCheck[][2] = { + { "1", "" }, + { "2", "=A1+A1" }, + { "3", "=A2+A1" }, + { "5", "=A3+A2" }, + { "8", "=A4+A3" }, + { "13", "=A5+A4" }, + { "21", "=A6+A5" }, + { "34", "=A7+A6" }, + { "55", "=A8+A7" } + }; + for (size_t i=0; i<SAL_N_ELEMENTS(aDataCheck); ++i) + { + OUString aString = m_pDoc->GetString(0,i,0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Initial data failure", OUString::createFromAscii(aDataCheck[i][0]), aString); + m_pDoc->GetFormula(0,i,0, aString); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Initial formula failure", OUString::createFromAscii(aDataCheck[i][1]), aString); + } + + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + + // Set up clip document. + ScDocument aClipDoc(SCDOCMODE_CLIP); + aClipDoc.ResetClip(m_pDoc, &aMark); + // Cut A4:A6 to clipboard with Undo. + std::unique_ptr<ScUndoCut> pUndoCut( cutToClip( getDocShell(), ScRange(0,3,0, 0,5,0), &aClipDoc, true)); + + // Check data after Cut. + const char* aCutCheck[] = {"1","2","3","","","","0","0","0"}; + for (size_t i=0; i<SAL_N_ELEMENTS(aCutCheck); ++i) + { + OUString aString = m_pDoc->GetString(0,i,0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Cut data failure", OUString::createFromAscii(aCutCheck[i]), aString); + } + + // Paste to B5:B7 with Undo. + ScRange aPasteRange(1,4,0, 1,6,0); + aMark.SetMarkArea(aPasteRange); + ScDocument* pPasteUndoDoc = new ScDocument(SCDOCMODE_UNDO); + pPasteUndoDoc->InitUndoSelected( m_pDoc, aMark); + std::unique_ptr<ScUndoPaste> pUndoPaste( createUndoPaste( getDocShell(), aPasteRange, ScDocumentUniquePtr(pPasteUndoDoc))); + m_pDoc->CopyFromClip( aPasteRange, aMark, InsertDeleteFlags::ALL, pPasteUndoDoc, &aClipDoc); + + // Check data after Paste. + const char* aPasteCheck[][4] = { + { "1", "", "", "" }, + { "2", "", "=A1+A1", "" }, + { "3", "", "=A2+A1", "" }, + { "", "", "", "" }, + { "", "5", "", "=A3+A2" }, + { "", "8", "", "=B5+A3" }, + { "21", "13", "=B7+B6", "=B6+B5" }, + { "34", "", "=A7+B7", "" }, + { "55", "", "=A8+A7", "" } + }; + for (size_t i=0; i<SAL_N_ELEMENTS(aPasteCheck); ++i) + { + for (size_t j=0; j<2; ++j) + { + OUString aString = m_pDoc->GetString(j,i,0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Paste data failure", OUString::createFromAscii(aPasteCheck[i][j]), aString); + m_pDoc->GetFormula(j,i,0, aString); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Paste formula failure", OUString::createFromAscii(aPasteCheck[i][2+j]), aString); + } + } + + // Undo Paste and check, must be same as after Cut. + pUndoPaste->Undo(); + for (size_t i=0; i<SAL_N_ELEMENTS(aCutCheck); ++i) + { + OUString aString = m_pDoc->GetString(0,i,0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Undo Paste data failure", OUString::createFromAscii(aCutCheck[i]), aString); + } + + // Undo Cut and check, must be initial data. + pUndoCut->Undo(); + for (size_t i=0; i<SAL_N_ELEMENTS(aDataCheck); ++i) + { + OUString aString = m_pDoc->GetString(0,i,0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Undo Cut data failure", OUString::createFromAscii(aDataCheck[i][0]), aString); + m_pDoc->GetFormula(0,i,0, aString); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Undo Cut formula failure", OUString::createFromAscii(aDataCheck[i][1]), aString); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testMoveRefBetweenSheets() +{ + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc. + + m_pDoc->InsertTab(0, "Test1"); + m_pDoc->InsertTab(1, "Test2"); + + m_pDoc->SetValue(ScAddress(0,0,0), 12.0); + m_pDoc->SetValue(ScAddress(1,0,0), 10.0); + m_pDoc->SetValue(ScAddress(2,0,0), 8.0); + m_pDoc->SetString(ScAddress(0,1,0), "=A1"); + m_pDoc->SetString(ScAddress(0,2,0), "=SUM(A1:C1)"); + + CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(ScAddress(0,1,0))); + CPPUNIT_ASSERT_EQUAL(30.0, m_pDoc->GetValue(ScAddress(0,2,0))); + + // These formulas should not display the sheet name. + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "A1", "Wrong formula!"); + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM(A1:C1)", "Wrong formula!"); + + // Move Test1.A2:A3 to Test2.A2:A3. + ScDocFunc& rFunc = getDocShell().GetDocFunc(); + bool bMoved = rFunc.MoveBlock(ScRange(0,1,0,0,2,0), ScAddress(0,1,1), true, true, false, true); + CPPUNIT_ASSERT(bMoved); + + CPPUNIT_ASSERT_EQUAL_MESSAGE("This cell should be empty after the move.", CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(0,1,0))); + ASSERT_DOUBLES_EQUAL(12.0, m_pDoc->GetValue(ScAddress(0,1,1))); + ASSERT_DOUBLES_EQUAL(30.0, m_pDoc->GetValue(ScAddress(0,2,1))); + + // The reference in the pasted formula should display sheet name after the move. + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,1), "Test1.A1", "Wrong formula!"); + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,1), "SUM(Test1.A1:C1)", "Wrong formula!"); + + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testUndoCut() +{ + m_pDoc->InsertTab(0, "Test"); + + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc. + + // Insert values into A1:A3. + m_pDoc->SetValue(ScAddress(0,0,0), 1.0); + m_pDoc->SetValue(ScAddress(0,1,0), 10.0); + m_pDoc->SetValue(ScAddress(0,2,0), 100.0); + + // SUM in A4. + m_pDoc->SetString(ScAddress(0,3,0), "=SUM(A1:A3)"); + CPPUNIT_ASSERT_EQUAL(111.0, m_pDoc->GetValue(0,3,0)); + + // Select A1:A3. + ScMarkData aMark(MAXROW, MAXCOL); + ScRange aRange(0,0,0,0,2,0); + aMark.SetMarkArea(aRange); + aMark.MarkToMulti(); + + // Set up an undo object for cutting A1:A3. + ScDocumentUniquePtr pUndoDoc(new ScDocument(SCDOCMODE_UNDO)); + pUndoDoc->InitUndo(m_pDoc, 0 ,0); + m_pDoc->CopyToDocument(aRange, InsertDeleteFlags::ALL, false, *pUndoDoc); + ASSERT_DOUBLES_EQUAL( 1.0, pUndoDoc->GetValue(ScAddress(0,0,0))); + ASSERT_DOUBLES_EQUAL( 10.0, pUndoDoc->GetValue(ScAddress(0,1,0))); + ASSERT_DOUBLES_EQUAL(100.0, pUndoDoc->GetValue(ScAddress(0,2,0))); + ScUndoCut aUndo(&getDocShell(), aRange, aRange.aEnd, aMark, std::move(pUndoDoc)); + + // "Cut" the selection. + m_pDoc->DeleteSelection(InsertDeleteFlags::ALL, aMark); + CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(0,3,0)); // The SUM should be zero after the "cut". + + // Undo it, and check the result. + aUndo.Undo(); + ASSERT_DOUBLES_EQUAL( 1.0, m_pDoc->GetValue(ScAddress(0,0,0))); + ASSERT_DOUBLES_EQUAL( 10.0, m_pDoc->GetValue(ScAddress(0,1,0))); + ASSERT_DOUBLES_EQUAL(100.0, m_pDoc->GetValue(ScAddress(0,2,0))); + ASSERT_DOUBLES_EQUAL(111.0, m_pDoc->GetValue(0,3,0)); // The SUM value should be back to the original. + + // Redo it and check. + aUndo.Redo(); + ASSERT_DOUBLES_EQUAL(0.0, m_pDoc->GetValue(0,3,0)); + + // Undo again. + aUndo.Undo(); + ASSERT_DOUBLES_EQUAL(111.0, m_pDoc->GetValue(0,3,0)); + + m_pDoc->DeleteTab(0); +} + +void Test::testMoveBlock() +{ + m_pDoc->InsertTab(0, "SheetNotes"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + m_pDoc->SetValue(0, 0, 0, 1); + m_pDoc->SetString(1, 0, 0, "=A1+1"); + m_pDoc->SetString(2, 0, 0, "test"); + + // add notes to A1:C1 + ScAddress aAddrA1 (0, 0, 0); + OUString const aHelloA1("Hello world in A1"); + ScPostIt* pNoteA1 = m_pDoc->GetOrCreateNote(aAddrA1); + pNoteA1->SetText(aAddrA1, aHelloA1); + ScAddress aAddrB1 (1, 0, 0); + OUString const aHelloB1("Hello world in B1"); + ScPostIt* pNoteB1 = m_pDoc->GetOrCreateNote(aAddrB1); + pNoteB1->SetText(aAddrB1, aHelloB1); + ScAddress aAddrC1 (2, 0, 0); + OUString const aHelloC1("Hello world in C1"); + ScPostIt* pNoteC1 = m_pDoc->GetOrCreateNote(aAddrC1); + pNoteC1->SetText(aAddrC1, aHelloC1); + ScAddress aAddrD1 (3, 0, 0); + + // previous tests on cell note content are ok. this one fails !!! :( + //CPPUNIT_ASSERT_MESSAGE("Note content in B1 before move block", m_pDoc->GetNote(aAddrB1)->GetText() == aHelloB1); + + // move notes to B1:D1 + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + bool bMoveDone = rDocFunc.MoveBlock(ScRange(0, 0 ,0 ,2 ,0 ,0), ScAddress(1, 0, 0), true/*bCut*/, false, false, false); + + CPPUNIT_ASSERT_MESSAGE("Cells not moved", bMoveDone); + + //check cell content + OUString aString = m_pDoc->GetString(3, 0, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Cell D1 should contain: test", OUString("test"), aString); + m_pDoc->GetFormula(2, 0, 0, aString); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Cell C1 should contain an updated formula", OUString("=B1+1"), aString); + double fValue = m_pDoc->GetValue(aAddrB1); + ASSERT_DOUBLES_EQUAL_MESSAGE("Cell B1 should contain 1", fValue, 1); + + // cell notes has been moved 1 cell right (event when overlapping) + CPPUNIT_ASSERT_MESSAGE("There should be NO note on A1", !m_pDoc->HasNote(aAddrA1)); + CPPUNIT_ASSERT_MESSAGE("There should be a note on B1", m_pDoc->HasNote(aAddrB1)); + CPPUNIT_ASSERT_MESSAGE("There should be a note on C1", m_pDoc->HasNote(aAddrC1)); + CPPUNIT_ASSERT_MESSAGE("There should be a note on D1", m_pDoc->HasNote(aAddrD1)); +/* still failing, wrong content ??? + OUString sNoteText; + sNoteText = m_pDoc->GetNote(aAddrB1)->GetText(); + CPPUNIT_ASSERT_MESSAGE("Note content in B1", sNoteText == aHelloA1); + sNoteText = m_pDoc->GetNote(aAddrC1)->GetText(); + CPPUNIT_ASSERT_MESSAGE("Note content in C1", sNoteText == aHelloB1); + sNoteText = m_pDoc->GetNote(aAddrD1)->GetText(); + CPPUNIT_ASSERT_MESSAGE("Note content in D1", sNoteText == aHelloC1); +*/ + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteRelativeFormula() +{ + m_pDoc->InsertTab(0, "Formula"); + + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); + + // Insert values to A2 and A4. + m_pDoc->SetValue(ScAddress(0,1,0), 1); + m_pDoc->SetValue(ScAddress(0,3,0), 2); + + // Insert formula to B4. + m_pDoc->SetString(ScAddress(1,3,0), "=A4"); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(1,3,0))); + + // Select and copy B3:B4 to the clipboard. + ScRange aRange(1,2,0,1,3,0); + ScClipParam aClipParam(aRange, false); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aRange); + ScDocument aClipDoc(SCDOCMODE_CLIP); + m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false); + + // Paste it to B1:B2. + InsertDeleteFlags nFlags = InsertDeleteFlags::ALL; + ScRange aDestRange(1,0,0,1,1,0); + aMark.SetMarkArea(aDestRange); + m_pDoc->CopyFromClip(aDestRange, aMark, nFlags, nullptr, &aClipDoc); + + // B2 references A2, so the value should be 1. + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(1,1,0))); + + // Clear content and start over. + clearSheet(m_pDoc, 0); + clearSheet(&aClipDoc, 0); + + // Insert a single formula cell in A1. + m_pDoc->SetString(ScAddress(0,0,0), "=ROW()"); + const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(0,0,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT(!pFC->IsShared()); // single formula cell is never shared. + + // Copy A1 to clipboard. + aClipParam = ScClipParam(ScAddress(0,0,0), false); + m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false); + + pFC = aClipDoc.GetFormulaCell(ScAddress(0,0,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT(!pFC->IsShared()); + + // Paste to A3. + aDestRange = ScRange(0,2,0,0,2,0); + aMark.SetMarkArea(aDestRange); + m_pDoc->CopyFromClip(aDestRange, aMark, nFlags, nullptr, &aClipDoc); + + pFC = m_pDoc->GetFormulaCell(ScAddress(0,2,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT(!pFC->IsShared()); + + // Delete A3 and make sure it doesn't crash (see fdo#76132). + clearRange(m_pDoc, ScAddress(0,2,0)); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(0,2,0))); + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteRepeatOneFormula() +{ + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); + + m_pDoc->InsertTab(0, "Test"); + + ScDocument aClipDoc(SCDOCMODE_CLIP); + ScMarkData aMark(MAXROW, MAXCOL); + + // Insert values in A1:B10. + for (SCROW i = 0; i < 10; ++i) + { + m_pDoc->SetValue(ScAddress(0,i,0), i+1.0); // column A + m_pDoc->SetValue(ScAddress(1,i,0), (i+1.0)*10.0); // column B + } + + // Insert a formula in C1. + ScAddress aPos(2,0,0); // C1 + m_pDoc->SetString(aPos, "=SUM(A1:B1)"); + CPPUNIT_ASSERT_EQUAL(11.0, m_pDoc->GetValue(aPos)); + + // This check makes only sense if group listeners are activated. +#if !defined(USE_FORMULA_GROUP_LISTENER) || USE_FORMULA_GROUP_LISTENER + // At this point, there should be only one normal area listener listening + // on A1:B1. + ScRange aWholeSheet(0,0,0,MAXCOL,MAXROW,0); + ScBroadcastAreaSlotMachine* pBASM = m_pDoc->GetBASM(); + CPPUNIT_ASSERT(pBASM); + std::vector<sc::AreaListener> aListeners = pBASM->GetAllListeners(aWholeSheet, sc::AreaOverlapType::Inside); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), aListeners.size()); + const sc::AreaListener* pListener = aListeners.data(); + CPPUNIT_ASSERT_EQUAL(ScRange(0,0,0,1,0,0), pListener->maArea); + CPPUNIT_ASSERT_MESSAGE("This listener shouldn't be a group listener.", !pListener->mbGroupListening); +#endif + + // Copy C1 to clipboard. + ScClipParam aClipParam(aPos, false); + aMark.SetMarkArea(aPos); + m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false); + + // Paste it to C2:C10. + ScRange aDestRange(2,1,0,2,9,0); + aMark.SetMarkArea(aDestRange); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::CONTENTS, nullptr, &aClipDoc); + + // Make sure C1:C10 are grouped. + const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(aPos); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(10), pFC->GetSharedLength()); + + // Check the formula results. + for (SCROW i = 0; i < 10; ++i) + { + double fExpected = (i+1.0)*11.0; + CPPUNIT_ASSERT_EQUAL(fExpected, m_pDoc->GetValue(ScAddress(2,i,0))); + } + + // This check makes only sense if group listeners are activated. +#if !defined(USE_FORMULA_GROUP_LISTENER) || USE_FORMULA_GROUP_LISTENER + // At this point, there should only be one area listener and it should be + // a group listener listening on A1:B10. + aListeners = pBASM->GetAllListeners(aWholeSheet, sc::AreaOverlapType::Inside); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), aListeners.size()); + pListener = aListeners.data(); + CPPUNIT_ASSERT_EQUAL(ScRange(0,0,0,1,9,0), pListener->maArea); + CPPUNIT_ASSERT_MESSAGE("This listener should be a group listener.", pListener->mbGroupListening); +#endif + + // Insert a new row at row 1. + ScRange aRowOne(0,0,0,MAXCOL,0,0); + aMark.SetMarkArea(aRowOne); + ScDocFunc& rFunc = getDocShell().GetDocFunc(); + rFunc.InsertCells(aRowOne, &aMark, INS_INSROWS_BEFORE, true, true); + + CPPUNIT_ASSERT_EQUAL_MESSAGE("C1 should be empty.", CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(2,0,0))); + + // This check makes only sense if group listeners are activated. +#if !defined(USE_FORMULA_GROUP_LISTENER) || USE_FORMULA_GROUP_LISTENER + // Make there we only have one group area listener listening on A2:B11. + aListeners = pBASM->GetAllListeners(aWholeSheet, sc::AreaOverlapType::Inside); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), aListeners.size()); + pListener = aListeners.data(); + CPPUNIT_ASSERT_EQUAL(ScRange(0,1,0,1,10,0), pListener->maArea); + CPPUNIT_ASSERT_MESSAGE("This listener should be a group listener.", pListener->mbGroupListening); +#endif + + // Check the formula results. + for (SCROW i = 0; i < 10; ++i) + { + double fExpected = (i+1.0)*11.0; + CPPUNIT_ASSERT_EQUAL(fExpected, m_pDoc->GetValue(ScAddress(2,i+1,0))); + } + + // Delete row at row 1 to shift the cells up. + rFunc.DeleteCells(aRowOne, &aMark, DelCellCmd::Rows, true); + + // Check the formula results again. + for (SCROW i = 0; i < 10; ++i) + { + double fExpected = (i+1.0)*11.0; + CPPUNIT_ASSERT_EQUAL(fExpected, m_pDoc->GetValue(ScAddress(2,i,0))); + } + + // This check makes only sense if group listeners are activated. +#if !defined(USE_FORMULA_GROUP_LISTENER) || USE_FORMULA_GROUP_LISTENER + // Check the group area listener again to make sure it's listening on A1:B10 once again. + aListeners = pBASM->GetAllListeners(aWholeSheet, sc::AreaOverlapType::Inside); + CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), aListeners.size()); + pListener = aListeners.data(); + CPPUNIT_ASSERT_EQUAL(ScRange(0,0,0,1,9,0), pListener->maArea); + CPPUNIT_ASSERT_MESSAGE("This listener should be a group listener.", pListener->mbGroupListening); +#endif + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteMixedReferenceFormula() +{ + sc::AutoCalcSwitch aAC(*m_pDoc, true); // turn on auto calc. + m_pDoc->InsertTab(0, "Test"); + + // Insert value to C3 + m_pDoc->SetValue(2,2,0, 1.0); + + // Insert formula to A1 with mixed relative/absolute addressing. + m_pDoc->SetString(0,0,0, "=SUM(B:$C)"); + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,0,0), "SUM(B:$C)", "Wrong formula."); + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(0,0,0)); + + // Copy formula in A1 to clipboard. + ScRange aRange(ScAddress(0,0,0)); + ScDocument aClipDoc(SCDOCMODE_CLIP); + copyToClip(m_pDoc, aRange, &aClipDoc); + + // Paste formula to B1. + aRange = ScAddress(1,0,0); + pasteFromClip(m_pDoc, aRange, &aClipDoc); + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,0,0), "SUM(C:$C)", "Wrong formula."); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(0,0,0)); + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(1,0,0)); + + // Paste formula to C1. All three results now must be circular reference. + aRange = ScAddress(2,0,0); + pasteFromClip(m_pDoc, aRange, &aClipDoc); + ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,0,0), "SUM($C:D)", "Wrong formula."); // reference put in order + CPPUNIT_ASSERT_EQUAL(OUString("Err:522"), m_pDoc->GetString(0,0,0)); + CPPUNIT_ASSERT_EQUAL(OUString("Err:522"), m_pDoc->GetString(1,0,0)); + CPPUNIT_ASSERT_EQUAL(OUString("Err:522"), m_pDoc->GetString(2,0,0)); + + m_pDoc->DeleteTab(0); +} + +void Test::testMergedCells() +{ + //test merge and unmerge + //TODO: an undo/redo test for this would be a good idea + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->DoMerge(0, 1, 1, 3, 3, false); + SCCOL nEndCol = 1; + SCROW nEndRow = 1; + m_pDoc->ExtendMerge( 1, 1, nEndCol, nEndRow, 0); + CPPUNIT_ASSERT_MESSAGE("did not merge cells", nEndCol == 3 && nEndRow == 3); + ScRange aRange(0,2,0,MAXCOL,2,0); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aRange); + getDocShell().GetDocFunc().InsertCells(aRange, &aMark, INS_INSROWS_BEFORE, true, true); + m_pDoc->ExtendMerge(1, 1, nEndCol, nEndRow, 0); + CPPUNIT_ASSERT_MESSAGE("did not increase merge area", nEndCol == 3 && nEndRow == 4); + m_pDoc->DeleteTab(0); +} + +void Test::testRenameTable() +{ + //test set rename table + //TODO: set name1 and name2 and do an undo to check if name 1 is set now + //TODO: also check if new name for table is same as another table + + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + + //test case 1 , rename table2 to sheet 1, it should return error + OUString nameToSet = "Sheet1"; + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + CPPUNIT_ASSERT_MESSAGE("name same as another table is being set", !rDocFunc.RenameTable(1,nameToSet,false,true) ); + + //test case 2 , simple rename to check name + nameToSet = "test1"; + getDocShell().GetDocFunc().RenameTable(0,nameToSet,false,true); + OUString nameJustSet; + m_pDoc->GetName(0,nameJustSet); + CPPUNIT_ASSERT_EQUAL_MESSAGE("table not renamed", nameToSet, nameJustSet); + + //test case 3 , rename again + OUString anOldName; + m_pDoc->GetName(0,anOldName); + + nameToSet = "test2"; + rDocFunc.RenameTable(0,nameToSet,false,true); + m_pDoc->GetName(0,nameJustSet); + CPPUNIT_ASSERT_EQUAL_MESSAGE("table not renamed", nameToSet, nameJustSet); + + //test case 4 , check if undo works + SfxUndoAction* pUndo = new ScUndoRenameTab(&getDocShell(),0,anOldName,nameToSet); + pUndo->Undo(); + m_pDoc->GetName(0,nameJustSet); + CPPUNIT_ASSERT_EQUAL_MESSAGE("the correct name is not set after undo", nameJustSet, anOldName); + + pUndo->Redo(); + m_pDoc->GetName(0,nameJustSet); + CPPUNIT_ASSERT_EQUAL_MESSAGE("the correct color is not set after redo", nameJustSet, nameToSet); + delete pUndo; + + m_pDoc->DeleteTab(0); + m_pDoc->DeleteTab(1); +} + +void Test::testSetBackgroundColor() +{ + //test set background color + //TODO: set color1 and set color2 and do an undo to check if color1 is set now. + + m_pDoc->InsertTab(0, "Sheet1"); + Color aColor; + + //test yellow + aColor=COL_YELLOW; + getDocShell().GetDocFunc().SetTabBgColor(0,aColor,false, true); + CPPUNIT_ASSERT_EQUAL_MESSAGE("the correct color is not set", + aColor, m_pDoc->GetTabBgColor(0)); + + Color aOldTabBgColor=m_pDoc->GetTabBgColor(0); + aColor = COL_BLUE; + getDocShell().GetDocFunc().SetTabBgColor(0,aColor,false, true); + CPPUNIT_ASSERT_EQUAL_MESSAGE("the correct color is not set the second time", + aColor, m_pDoc->GetTabBgColor(0)); + + //now check for undo + SfxUndoAction* pUndo = new ScUndoTabColor(&getDocShell(), 0, aOldTabBgColor, aColor); + pUndo->Undo(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("the correct color is not set after undo", aOldTabBgColor, m_pDoc->GetTabBgColor(0)); + pUndo->Redo(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("the correct color is not set after undo", aColor, m_pDoc->GetTabBgColor(0)); + delete pUndo; + m_pDoc->DeleteTab(0); +} + +void Test::testUpdateReference() +{ + //test that formulas are correctly updated during sheet delete + //TODO: add tests for relative references, updating of named ranges, ... + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + m_pDoc->InsertTab(2, "Sheet3"); + m_pDoc->InsertTab(3, "Sheet4"); + + m_pDoc->SetValue(0,0,2, 1); + m_pDoc->SetValue(1,0,2, 2); + m_pDoc->SetValue(1,1,3, 4); + m_pDoc->SetString(2,0,2, "=A1+B1"); + m_pDoc->SetString(2,1,2, "=Sheet4.B2+A1"); + + double aValue; + m_pDoc->GetValue(2,0,2, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("formula does not return correct result", aValue, 3); + m_pDoc->GetValue(2,1,2, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("formula does not return correct result", aValue, 5); + + //test deleting both sheets: one is not directly before the sheet, the other one is + m_pDoc->DeleteTab(0); + m_pDoc->GetValue(2,0,1, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after deleting first sheet formula does not return correct result", aValue, 3); + m_pDoc->GetValue(2,1,1, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after deleting first sheet formula does not return correct result", aValue, 5); + + m_pDoc->DeleteTab(0); + m_pDoc->GetValue(2,0,0, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after deleting second sheet formula does not return correct result", aValue, 3); + m_pDoc->GetValue(2,1,0, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after deleting second sheet formula does not return correct result", aValue, 5); + + //test adding two sheets + m_pDoc->InsertTab(0, "Sheet2"); + m_pDoc->GetValue(2,0,1, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after inserting first sheet formula does not return correct result", aValue, 3); + m_pDoc->GetValue(2,1,1, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after inserting first sheet formula does not return correct result", aValue, 5); + + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->GetValue(2,0,2, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after inserting second sheet formula does not return correct result", aValue, 3); + m_pDoc->GetValue(2,1,2, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after inserting second sheet formula does not return correct result", aValue, 5); + + //test new DeleteTabs/InsertTabs methods + m_pDoc->DeleteTabs(0, 2); + m_pDoc->GetValue(2, 0, 0, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after deleting sheets formula does not return correct result", aValue, 3); + m_pDoc->GetValue(2, 1, 0, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after deleting sheets formula does not return correct result", aValue, 5); + + std::vector<OUString> aSheets; + aSheets.emplace_back("Sheet1"); + aSheets.emplace_back("Sheet2"); + m_pDoc->InsertTabs(0, aSheets, true); + m_pDoc->GetValue(2, 0, 2, aValue); + OUString aFormula; + m_pDoc->GetFormula(2,0,2, aFormula); + + ASSERT_DOUBLES_EQUAL_MESSAGE("after inserting sheets formula does not return correct result", aValue, 3); + m_pDoc->GetValue(2, 1, 2, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("after inserting sheets formula does not return correct result", aValue, 5); + + m_pDoc->DeleteTab(3); + m_pDoc->DeleteTab(2); + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); + + // Test positional update and invalidation of lookup cache for insertion + // and deletion within entire column reference. + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + m_pDoc->SetString(0,1,0, "s1"); + m_pDoc->SetString(0,0,1, "=MATCH(\"s1\";Sheet1.A:A;0)"); + m_pDoc->GetValue(0,0,1, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("unexpected MATCH result", 2, aValue); + m_pDoc->InsertRow(0,0,MAXCOL,0,0,1); // insert 1 row before row 1 in Sheet1 + m_pDoc->GetValue(0,0,1, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("unexpected MATCH result", 3, aValue); + m_pDoc->DeleteRow(0,0,MAXCOL,0,0,1); // delete row 1 in Sheet1 + m_pDoc->GetValue(0,0,1, aValue); + ASSERT_DOUBLES_EQUAL_MESSAGE("unexpected MATCH result", 2, aValue); + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testSearchCells() +{ + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetString(ScAddress(0,0,0), "A"); + m_pDoc->SetString(ScAddress(0,1,0), "B"); + m_pDoc->SetString(ScAddress(0,2,0), "A"); + // Leave A4 blank. + m_pDoc->SetString(ScAddress(0,4,0), "A"); + m_pDoc->SetString(ScAddress(0,5,0), "B"); + m_pDoc->SetString(ScAddress(0,6,0), "C"); + + SvxSearchItem aItem(SID_SEARCH_ITEM); + aItem.SetSearchString("A"); + aItem.SetCommand(SvxSearchCmd::FIND_ALL); + ScMarkData aMarkData(MAXROW, MAXCOL); + aMarkData.SelectOneTable(0); + SCCOL nCol = 0; + SCROW nRow = 0; + SCTAB nTab = 0; + ScRangeList aMatchedRanges; + OUString aUndoStr; + bool bSuccess = m_pDoc->SearchAndReplace(aItem, nCol, nRow, nTab, aMarkData, aMatchedRanges, aUndoStr); + + CPPUNIT_ASSERT_MESSAGE("Search And Replace should succeed", bSuccess); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be exactly 3 matching cells.", size_t(3), aMatchedRanges.size()); + ScAddress aHit(0,0,0); + CPPUNIT_ASSERT_MESSAGE("A1 should be inside the matched range.", aMatchedRanges.In(aHit)); + aHit.SetRow(2); + CPPUNIT_ASSERT_MESSAGE("A3 should be inside the matched range.", aMatchedRanges.In(aHit)); + aHit.SetRow(4); + CPPUNIT_ASSERT_MESSAGE("A5 should be inside the matched range.", aMatchedRanges.In(aHit)); + + m_pDoc->DeleteTab(0); +} + +void Test::testFormulaPosition() +{ + m_pDoc->InsertTab(0, "Test"); + + ScAddress aPos(0,0,0); // A1 + m_pDoc->SetString(aPos, "=ROW()"); + aPos.IncRow(); // A2 + m_pDoc->SetString(aPos, "=ROW()"); + aPos.SetRow(3); // A4; + m_pDoc->SetString(aPos, "=ROW()"); + + { + SCROW aRows[] = { 0, 1, 3 }; + bool bRes = checkFormulaPositions(*m_pDoc, aPos.Tab(), aPos.Col(), aRows, SAL_N_ELEMENTS(aRows)); + CPPUNIT_ASSERT(bRes); + } + + m_pDoc->InsertRow(0,0,0,0,1,5); // Insert 5 rows at A2. + { + SCROW aRows[] = { 0, 6, 8 }; + bool bRes = checkFormulaPositions(*m_pDoc, aPos.Tab(), aPos.Col(), aRows, SAL_N_ELEMENTS(aRows)); + CPPUNIT_ASSERT(bRes); + } + + m_pDoc->DeleteTab(0); +} + +namespace { + +bool hasRange(const ScDocument* pDoc, const std::vector<ScTokenRef>& rRefTokens, const ScRange& rRange, const ScAddress& rPos) +{ + for (const ScTokenRef& p : rRefTokens) + { + if (!ScRefTokenHelper::isRef(p) || ScRefTokenHelper::isExternalRef(p)) + continue; + + switch (p->GetType()) + { + case formula::svSingleRef: + { + ScSingleRefData aData = *p->GetSingleRef(); + if (rRange.aStart != rRange.aEnd) + break; + + ScAddress aThis = aData.toAbs(pDoc, rPos); + if (aThis == rRange.aStart) + return true; + } + break; + case formula::svDoubleRef: + { + ScComplexRefData aData = *p->GetDoubleRef(); + ScRange aThis = aData.toAbs(pDoc, rPos); + if (aThis == rRange) + return true; + } + break; + default: + ; + } + } + return false; +} + +} + +void Test::testJumpToPrecedentsDependents() +{ + // Precedent is another cell that the cell references, while dependent is + // another cell that references it. + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetString(2, 0, 0, "=A1+A2+B3"); // C1 + m_pDoc->SetString(2, 1, 0, "=A1"); // C2 + m_pDoc->CalcAll(); + + std::vector<ScTokenRef> aRefTokens; + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + + { + // C1's precedent should be A1:A2,B3. + ScAddress aC1(2, 0, 0); + ScRangeList aRange(aC1); + rDocFunc.DetectiveCollectAllPreds(aRange, aRefTokens); + CPPUNIT_ASSERT_MESSAGE("A1:A2 should be a precedent of C1.", + hasRange(m_pDoc, aRefTokens, ScRange(0, 0, 0, 0, 1, 0), aC1)); + CPPUNIT_ASSERT_MESSAGE("B3 should be a precedent of C1.", + hasRange(m_pDoc, aRefTokens, ScRange(1, 2, 0), aC1)); + } + + { + // C2's precedent should be A1 only. + ScAddress aC2(2, 1, 0); + ScRangeList aRange(aC2); + rDocFunc.DetectiveCollectAllPreds(aRange, aRefTokens); + CPPUNIT_ASSERT_EQUAL_MESSAGE("there should only be one reference token.", + static_cast<size_t>(1), aRefTokens.size()); + CPPUNIT_ASSERT_MESSAGE("A1 should be a precedent of C1.", + hasRange(m_pDoc, aRefTokens, ScRange(0, 0, 0), aC2)); + } + + { + // A1's dependent should be C1:C2. + ScAddress aA1(0, 0, 0); + ScRangeList aRange(aA1); + rDocFunc.DetectiveCollectAllSuccs(aRange, aRefTokens); + CPPUNIT_ASSERT_MESSAGE("C1:C2 should be the only dependent of A1.", + aRefTokens.size() == 1 && hasRange(m_pDoc, aRefTokens, ScRange(2, 0, 0, 2, 1, 0), aA1)); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testAutoFill() +{ + m_pDoc->InsertTab(0, "test"); + + m_pDoc->SetValue(0,0,0,1); + + ScMarkData aMarkData(MAXROW, MAXCOL); + aMarkData.SelectTable(0, true); + + m_pDoc->Fill( 0, 0, 0, 0, nullptr, aMarkData, 5); + for (SCROW i = 0; i< 6; ++i) + ASSERT_DOUBLES_EQUAL(static_cast<double>(i+1.0), m_pDoc->GetValue(0, i, 0)); + + // check that hidden rows are not affected by autofill + // set values for hidden rows + m_pDoc->SetValue(0,1,0,10); + m_pDoc->SetValue(0,2,0,10); + + m_pDoc->SetRowHidden(1, 2, 0, true); + m_pDoc->Fill( 0, 0, 0, 0, nullptr, aMarkData, 8); + + ASSERT_DOUBLES_EQUAL(10.0, m_pDoc->GetValue(0,1,0)); + ASSERT_DOUBLES_EQUAL(10.0, m_pDoc->GetValue(0,2,0)); + for (SCROW i = 3; i< 8; ++i) + ASSERT_DOUBLES_EQUAL(static_cast<double>(i-1.0), m_pDoc->GetValue(0, i, 0)); + + m_pDoc->Fill( 0, 0, 0, 8, nullptr, aMarkData, 5, FILL_TO_RIGHT ); + for (SCCOL i = 0; i < 5; ++i) + { + for(SCROW j = 0; j < 8; ++j) + { + if (j > 2) + { + ASSERT_DOUBLES_EQUAL(static_cast<double>(j-1+i), m_pDoc->GetValue(i, j, 0)); + } + else if (j == 0) + { + ASSERT_DOUBLES_EQUAL(static_cast<double>(i+1), m_pDoc->GetValue(i, 0, 0)); + } + else // j == 1 || j == 2 + { + if(i == 0) + ASSERT_DOUBLES_EQUAL(10.0, m_pDoc->GetValue(0,j,0)); + else + ASSERT_DOUBLES_EQUAL(0.0, m_pDoc->GetValue(i,j,0)); + } + } + } + + // test auto fill user data lists + m_pDoc->SetString( 0, 100, 0, "January" ); + m_pDoc->Fill( 0, 100, 0, 100, nullptr, aMarkData, 2, FILL_TO_BOTTOM, FILL_AUTO ); + OUString aTestValue = m_pDoc->GetString( 0, 101, 0 ); + CPPUNIT_ASSERT_EQUAL( OUString("February"), aTestValue ); + aTestValue = m_pDoc->GetString( 0, 102, 0 ); + CPPUNIT_ASSERT_EQUAL( OUString("March"), aTestValue ); + + // test that two same user data list entries will not result in incremental fill + m_pDoc->SetString( 0, 101, 0, "January" ); + m_pDoc->Fill( 0, 100, 0, 101, nullptr, aMarkData, 2, FILL_TO_BOTTOM, FILL_AUTO ); + for ( SCROW i = 102; i <= 103; ++i ) + { + aTestValue = m_pDoc->GetString( 0, i, 0 ); + CPPUNIT_ASSERT_EQUAL( OUString("January"), aTestValue ); + } + + // Clear column A for a new test. + clearRange(m_pDoc, ScRange(0,0,0,0,MAXROW,0)); + m_pDoc->SetRowHidden(0, MAXROW, 0, false); // Show all rows. + + // Fill A1:A6 with 1,2,3,4,5,6. + ScDocFunc& rFunc = getDocShell().GetDocFunc(); + m_pDoc->SetValue(ScAddress(0,0,0), 1.0); + ScRange aRange(0,0,0,0,5,0); + aMarkData.SetMarkArea(aRange); + rFunc.FillSeries(aRange, &aMarkData, FILL_TO_BOTTOM, FILL_AUTO, FILL_DAY, MAXDOUBLE, 1.0, MAXDOUBLE, true); + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(0,1,0))); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,2,0))); + CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(0,3,0))); + CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(ScAddress(0,4,0))); + CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,5,0))); + + // Undo should clear the area except for the top cell. + SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT(pUndoMgr); + pUndoMgr->Undo(); + + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,0,0))); + for (SCROW i = 1; i <= 5; ++i) + CPPUNIT_ASSERT_EQUAL(CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(0,i,0))); + + // Redo should put the serial values back in. + pUndoMgr->Redo(); + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(0,1,0))); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,2,0))); + CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(0,3,0))); + CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(ScAddress(0,4,0))); + CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,5,0))); + + // test that filling formulas vertically up does the right thing + for(SCROW nRow = 0; nRow < 10; ++nRow) + m_pDoc->SetValue(100, 100 + nRow, 0, 1); + + m_pDoc->SetString(100, 110, 0, "=A111"); + + m_pDoc->Fill(100, 110, 100, 110, nullptr, aMarkData, 10, FILL_TO_TOP, FILL_AUTO); + for(SCROW nRow = 110; nRow >= 100; --nRow) + { + OUString aExpected = "=A" + OUString::number(nRow +1); + OUString aFormula; + m_pDoc->GetFormula(100, nRow, 0, aFormula); + CPPUNIT_ASSERT_EQUAL(aExpected, aFormula); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testAutoFillSimple() +{ + m_pDoc->InsertTab(0, "test"); + + m_pDoc->SetValue(0, 0, 0, 1); + m_pDoc->SetString(0, 1, 0, "=10"); + + ScMarkData aMarkData(MAXROW, MAXCOL); + aMarkData.SelectTable(0, true); + + m_pDoc->Fill( 0, 0, 0, 1, nullptr, aMarkData, 6, FILL_TO_BOTTOM, FILL_AUTO); + + for(SCROW nRow = 0; nRow < 8; ++nRow) + { + if (nRow % 2 == 0) + { + double nVal = m_pDoc->GetValue(0, nRow, 0); + CPPUNIT_ASSERT_EQUAL((nRow+2)/2.0, nVal); + } + else + { + OString aMsg = "wrong value in row: " + OString::number(nRow); + double nVal = m_pDoc->GetValue(0, nRow, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE(aMsg.getStr(), 10.0, nVal); + } + } + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteFormulas() +{ + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + + m_pDoc->SetString(0,0,0, "=COLUMN($A$1)"); + m_pDoc->SetString(0,1,0, "=$A$1+B2" ); + m_pDoc->SetString(0,2,0, "=$Sheet2.A1"); + m_pDoc->SetString(0,3,0, "=$Sheet2.$A$1"); + m_pDoc->SetString(0,4,0, "=$Sheet2.A$1"); + + // to prevent ScEditableTester in ScDocFunc::MoveBlock + ASSERT_DOUBLES_EQUAL(m_pDoc->GetValue(0,0,0), 1.0); + ASSERT_DOUBLES_EQUAL(m_pDoc->GetValue(0,1,0), 1.0); + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + bool bMoveDone = rDocFunc.MoveBlock(ScRange(0,0,0,0,4,0), ScAddress( 10, 10, 0), false, false, false, true); + + // check that moving was successful, mainly for editable tester + CPPUNIT_ASSERT(bMoveDone); + ASSERT_DOUBLES_EQUAL(m_pDoc->GetValue(10,10,0), 1.0); + ASSERT_DOUBLES_EQUAL(m_pDoc->GetValue(10,11,0), 1.0); + OUString aFormula; + m_pDoc->GetFormula(10,10,0, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("=COLUMN($A$1)"), aFormula); + m_pDoc->GetFormula(10,11,0, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("=$A$1+L12"), aFormula); + m_pDoc->GetFormula(10,12,0, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("=$Sheet2.K11"), aFormula); + m_pDoc->GetFormula(10,13,0, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("=$Sheet2.$A$1"), aFormula); + m_pDoc->GetFormula(10,14,0, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("=$Sheet2.K$1"), aFormula); +} + +void Test::testCopyPasteFormulasExternalDoc() +{ + OUString const aDocName("file:///source.fake"); + SfxMedium* pMedium = new SfxMedium(aDocName, StreamMode::STD_READWRITE); + getDocShell().DoInitNew(pMedium); + m_pDoc = &getDocShell().GetDocument(); + + ScDocShellRef xExtDocSh = new ScDocShell; + xExtDocSh->SetIsInUcalc(); + OUString const aExtDocName("file:///extdata.fake"); + OUString const aExtSh1Name("ExtSheet1"); + OUString const aExtSh2Name("ExtSheet2"); + SfxMedium* pMed = new SfxMedium(aExtDocName, StreamMode::STD_READWRITE); + xExtDocSh->DoInitNew(pMed); + CPPUNIT_ASSERT_MESSAGE("external document instance not loaded.", + findLoadedDocShellByName(aExtDocName) != nullptr); + + ScDocument& rExtDoc = xExtDocSh->GetDocument(); + rExtDoc.InsertTab(0, aExtSh1Name); + rExtDoc.InsertTab(1, aExtSh2Name); + + m_pDoc->InsertTab(0, "Sheet1"); + m_pDoc->InsertTab(1, "Sheet2"); + + m_pDoc->SetString(0,0,0, "=COLUMN($A$1)"); + m_pDoc->SetString(0,1,0, "=$A$1+B2" ); + m_pDoc->SetString(0,2,0, "=$Sheet2.A1"); + m_pDoc->SetString(0,3,0, "=$Sheet2.$A$1"); + m_pDoc->SetString(0,4,0, "=$Sheet2.A$1"); + m_pDoc->SetString(0,5,0, "=$Sheet1.$A$1"); + + ScRange aRange(0,0,0,0,5,0); + ScClipParam aClipParam(aRange, false); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aRange); + ScDocument aClipDoc(SCDOCMODE_CLIP); + m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false); + + aRange = ScRange(1,1,1,1,6,1); + ScMarkData aMarkData2(MAXROW, MAXCOL); + aMarkData2.SetMarkArea(aRange); + rExtDoc.CopyFromClip(aRange, aMarkData2, InsertDeleteFlags::ALL, nullptr, &aClipDoc); + + OUString aFormula; + rExtDoc.GetFormula(1,1,1, aFormula); + //adjust absolute refs pointing to the copy area + CPPUNIT_ASSERT_EQUAL(OUString("=COLUMN($B$2)"), aFormula); + rExtDoc.GetFormula(1,2,1, aFormula); + //adjust absolute refs and keep relative refs + CPPUNIT_ASSERT_EQUAL(OUString("=$B$2+C3"), aFormula); + rExtDoc.GetFormula(1,3,1, aFormula); + // make absolute sheet refs external refs + CPPUNIT_ASSERT_EQUAL(OUString("='file:///source.fake'#$Sheet2.B2"), aFormula); + rExtDoc.GetFormula(1,4,1, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("='file:///source.fake'#$Sheet2.$A$1"), aFormula); + rExtDoc.GetFormula(1,5,1, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("='file:///source.fake'#$Sheet2.B$1"), aFormula); + rExtDoc.GetFormula(1,6,1, aFormula); + CPPUNIT_ASSERT_EQUAL(OUString("=$ExtSheet2.$B$2"), aFormula); + + xExtDocSh->DoClose(); +} + +void Test::testCopyPasteReferencesExternalDoc() +{ + OUString const aDocName("file:///source.fake"); + SfxMedium* pMedium = new SfxMedium(aDocName, StreamMode::STD_READWRITE); + getDocShell().DoInitNew(pMedium); + m_pDoc = &getDocShell().GetDocument(); + + ScDocShellRef xExtDocSh = new ScDocShell; + xExtDocSh->SetIsInUcalc(); + OUString aExtDocName("file:///extdata.fake"); + OUString const aExtSh1Name("ExtSheet1"); + SfxMedium* pMed = new SfxMedium(aExtDocName, StreamMode::STD_READWRITE); + xExtDocSh->DoInitNew(pMed); + CPPUNIT_ASSERT_MESSAGE("external document instance not loaded.", + findLoadedDocShellByName(aExtDocName) != nullptr); + + ScDocument& rExtDoc = xExtDocSh->GetDocument(); + rExtDoc.InsertTab(0, aExtSh1Name); + + m_pDoc->InsertTab(0, "Sheet1"); + + m_pDoc->SetString(0,5,0, "=SUM($Sheet1.A1:A5)"); + + ScRange aRange(0,2,0,0,5,0); + ScClipParam aClipParam(aRange, false); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(aRange); + ScDocument aClipDoc(SCDOCMODE_CLIP); + m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false); + + aRange = ScRange(0,0,0,0,3,0); + ScMarkData aMarkData2(MAXROW, MAXCOL); + aMarkData2.SetMarkArea(aRange); + rExtDoc.CopyFromClip(aRange, aMarkData2, InsertDeleteFlags::ALL, nullptr, &aClipDoc); + + OUString aFormula; + rExtDoc.GetFormula(0,3,0, aFormula); + //adjust absolute refs pointing to the copy area + CPPUNIT_ASSERT_EQUAL(OUString("=SUM('file:///source.fake'#$Sheet1.A#REF!:A3)"), aFormula); + + xExtDocSh->DoClose(); +} + +void Test::testFindAreaPosVertical() +{ + std::vector<std::vector<const char*>> aData = { + { nullptr, "1", "1" }, + { "1", nullptr, "1" }, + { "1", "1", "1" }, + { nullptr, "1", "1" }, + { "1", "1", "1" }, + { "1", nullptr, "1" }, + { "1", "1", "1" }, + }; + + m_pDoc->InsertTab(0, "Test1"); + clearRange( m_pDoc, ScRange(0, 0, 0, 1, aData.size(), 0)); + ScAddress aPos(0,0,0); + ScRange aDataRange = insertRangeData( m_pDoc, aPos, aData); + CPPUNIT_ASSERT_EQUAL_MESSAGE("failed to insert range data at correct position", aPos, aDataRange.aStart); + + m_pDoc->SetRowHidden(4,4,0,true); + bool bHidden = m_pDoc->RowHidden(4,0); + CPPUNIT_ASSERT(bHidden); + + SCCOL nCol = 0; + SCROW nRow = 0; + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_DOWN); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(1), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(0), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_DOWN); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(0), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_DOWN); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(5), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(0), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_DOWN); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(6), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(0), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_DOWN); + + CPPUNIT_ASSERT_EQUAL(MAXROW, nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(0), nCol); + + nCol = 1; + nRow = 2; + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_DOWN); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(3), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_DOWN); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(6), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), nCol); + + nCol = 2; + nRow = 6; + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_UP); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(2), nCol); + + m_pDoc->DeleteTab(0); +} + +void Test::testFindAreaPosColRight() +{ + std::vector<std::vector<const char*>> aData = { + { "", "1", "1", "", "1", "1", "1" }, + { "", "", "1", "1", "1", "", "1" }, + }; + + m_pDoc->InsertTab(0, "test1"); + clearRange( m_pDoc, ScRange(0, 0, 0, 7, aData.size(), 0)); + ScAddress aPos(0,0,0); + ScRange aDataRange = insertRangeData( m_pDoc, aPos, aData); + CPPUNIT_ASSERT_EQUAL_MESSAGE("failed to insert range data at correct position", aPos, aDataRange.aStart); + + m_pDoc->SetColHidden(4,4,0,true); + bool bHidden = m_pDoc->ColHidden(4,0); + CPPUNIT_ASSERT(bHidden); + + SCCOL nCol = 0; + SCROW nRow = 0; + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_RIGHT); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_RIGHT); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(2), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_RIGHT); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(5), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_RIGHT); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(6), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_RIGHT); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), nRow); + CPPUNIT_ASSERT_EQUAL(MAXCOL, nCol); + + nCol = 2; + nRow = 1; + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_RIGHT); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(1), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(3), nCol); + + m_pDoc->FindAreaPos(nCol, nRow, 0, SC_MOVE_RIGHT); + + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(1), nRow); + CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(6), nCol); + + m_pDoc->DeleteTab(0); +} + +void Test::testShiftCells() +{ + m_pDoc->InsertTab(0, "foo"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + OUString aTestVal("Some Text"); + + // Text into cell E5. + m_pDoc->SetString(4, 3, 0, aTestVal); + + // put a Note in cell E5 + ScAddress rAddr(4, 3, 0); + ScPostIt* pNote = m_pDoc->GetOrCreateNote(rAddr); + pNote->SetText(rAddr, "Hello"); + + CPPUNIT_ASSERT_MESSAGE("there should be a note", m_pDoc->HasNote(4, 3, 0)); + + // Insert cell at D5. This should shift the string cell to right. + m_pDoc->InsertCol(3, 0, 3, 0, 3, 1); + OUString aStr = m_pDoc->GetString(5, 3, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("We should have a string cell here.", aTestVal, aStr); + CPPUNIT_ASSERT_MESSAGE("D5 is supposed to be blank.", m_pDoc->IsBlockEmpty(0, 3, 4, 3, 4)); + + CPPUNIT_ASSERT_MESSAGE("there should be NO note", !m_pDoc->HasNote(4, 3, 0)); + CPPUNIT_ASSERT_MESSAGE("there should be a note", m_pDoc->HasNote(5, 3, 0)); + + // Delete cell D5, to shift the text cell back into D5. + m_pDoc->DeleteCol(3, 0, 3, 0, 3, 1); + aStr = m_pDoc->GetString(4, 3, 0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("We should have a string cell here.", aTestVal, aStr); + CPPUNIT_ASSERT_MESSAGE("E5 is supposed to be blank.", m_pDoc->IsBlockEmpty(0, 4, 4, 4, 4)); + + CPPUNIT_ASSERT_MESSAGE("there should be NO note", !m_pDoc->HasNote(5, 3, 0)); + CPPUNIT_ASSERT_MESSAGE("there should be a note", m_pDoc->HasNote(4, 3, 0)); + + m_pDoc->DeleteTab(0); +} + +void Test::testNoteBasic() +{ + m_pDoc->InsertTab(0, "PostIts"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + CPPUNIT_ASSERT(!m_pDoc->HasNotes()); + + // Check for note's presence in all tables before inserting any notes. + for (SCTAB i = 0; i <= MAXTAB; ++i) + { + bool bHasNotes = m_pDoc->HasTabNotes(i); + CPPUNIT_ASSERT(!bHasNotes); + } + + ScAddress aAddr(2, 2, 0); // cell C3 + ScPostIt *pNote = m_pDoc->GetOrCreateNote(aAddr); + + pNote->SetText(aAddr, "Hello world"); + pNote->SetAuthor("Jim Bob"); + + ScPostIt *pGetNote = m_pDoc->GetNote(aAddr); + CPPUNIT_ASSERT_EQUAL_MESSAGE("note should be itself", pNote, pGetNote); + + // Insert one row at row 1. + bool bInsertRow = m_pDoc->InsertRow(0, 0, MAXCOL, 0, 1, 1); + CPPUNIT_ASSERT_MESSAGE("failed to insert row", bInsertRow ); + + CPPUNIT_ASSERT_MESSAGE("note hasn't moved", !m_pDoc->GetNote(aAddr)); + aAddr.IncRow(); // cell C4 + CPPUNIT_ASSERT_EQUAL_MESSAGE("note not there", pNote, m_pDoc->GetNote(aAddr)); + + // Insert column at column A. + bool bInsertCol = m_pDoc->InsertCol(0, 0, MAXROW, 0, 1, 1); + CPPUNIT_ASSERT_MESSAGE("failed to insert column", bInsertCol ); + + CPPUNIT_ASSERT_MESSAGE("note hasn't moved", !m_pDoc->GetNote(aAddr)); + aAddr.IncCol(); // cell D4 + CPPUNIT_ASSERT_EQUAL_MESSAGE("note not there", pNote, m_pDoc->GetNote(aAddr)); + + // Insert a new sheet to shift the current sheet to the right. + m_pDoc->InsertTab(0, "Table2"); + CPPUNIT_ASSERT_MESSAGE("note hasn't moved", !m_pDoc->GetNote(aAddr)); + aAddr.IncTab(); // Move to the next sheet. + CPPUNIT_ASSERT_EQUAL_MESSAGE("note not there", pNote, m_pDoc->GetNote(aAddr)); + + m_pDoc->DeleteTab(0); + aAddr.IncTab(-1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("note not there", pNote, m_pDoc->GetNote(aAddr)); + + // Insert cell at C4. This should NOT shift the note position. + bInsertRow = m_pDoc->InsertRow(2, 0, 2, 0, 3, 1); + CPPUNIT_ASSERT_MESSAGE("Failed to insert cell at C4.", bInsertRow); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note shouldn't have moved but it has.", pNote, m_pDoc->GetNote(aAddr)); + + // Delete cell at C4. Again, this should NOT shift the note position. + m_pDoc->DeleteRow(2, 0, 2, 0, 3, 1); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note shouldn't have moved but it has.", pNote, m_pDoc->GetNote(aAddr)); + + // Now, with the note at D4, delete cell D3. This should shift the note one cell up. + m_pDoc->DeleteRow(3, 0, 3, 0, 2, 1); + aAddr.IncRow(-1); // cell D3 + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note at D4 should have shifted up to D3.", pNote, m_pDoc->GetNote(aAddr)); + + // Delete column C. This should shift the note one cell left. + m_pDoc->DeleteCol(0, 0, MAXROW, 0, 2, 1); + aAddr.IncCol(-1); // cell C3 + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note at D3 should have shifted left to C3.", pNote, m_pDoc->GetNote(aAddr)); + + // Insert a text where the note is. + m_pDoc->SetString(aAddr, "Note is here."); + + // Delete row 1. This should shift the note from C3 to C2. + m_pDoc->DeleteRow(0, 0, MAXCOL, 0, 0, 1); + aAddr.IncRow(-1); // C2 + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note at C3 should have shifted up to C2.", pNote, m_pDoc->GetNote(aAddr)); + + m_pDoc->DeleteTab(0); +} + +void Test::testNoteDeleteRow() +{ + m_pDoc->InsertTab(0, "Sheet1"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + OUString const aHello("Hello"); + OUString const aJimBob("Jim Bob"); + ScAddress aPos(1, 1, 0); + ScPostIt* pNote = m_pDoc->GetOrCreateNote(aPos); + pNote->SetText(aPos, aHello); + pNote->SetAuthor(aJimBob); + + CPPUNIT_ASSERT_MESSAGE("there should be a note", m_pDoc->HasNote(1, 1, 0)); + + // test with IsBlockEmpty + bool bIgnoreNotes = true; + CPPUNIT_ASSERT_MESSAGE("The Block should be detected as empty (no Notes)", m_pDoc->IsBlockEmpty(0, 0, 0, 100, 100, bIgnoreNotes)); + bIgnoreNotes = false; + CPPUNIT_ASSERT_MESSAGE("The Block should NOT be detected as empty", !m_pDoc->IsBlockEmpty(0, 0, 0, 100, 100, bIgnoreNotes)); + + m_pDoc->DeleteRow(0, 0, MAXCOL, 0, 1, 1); + + CPPUNIT_ASSERT_MESSAGE("there should be no more note", !m_pDoc->HasNote(1, 1, 0)); + + // Set values and notes into B3:B4. + aPos = ScAddress(1,2,0); // B3 + m_pDoc->SetString(aPos, "First"); + ScNoteUtil::CreateNoteFromString(*m_pDoc, aPos, "First Note", false, false); + + aPos = ScAddress(1,3,0); // B4 + m_pDoc->SetString(aPos, "Second"); + ScNoteUtil::CreateNoteFromString(*m_pDoc, aPos, "Second Note", false, false); + + // Delete row 2. + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + rDocFunc.DeleteCells(ScRange(0,1,0,MAXCOL,1,0), &aMark, DelCellCmd::CellsUp, true); + + // Check to make sure the notes have shifted upward. + pNote = m_pDoc->GetNote(ScAddress(1,1,0)); + CPPUNIT_ASSERT_MESSAGE("B2 should have a note.", pNote); + CPPUNIT_ASSERT_EQUAL(OUString("First Note"), pNote->GetText()); + pNote = m_pDoc->GetNote(ScAddress(1,2,0)); + CPPUNIT_ASSERT_MESSAGE("B3 should have a note.", pNote); + CPPUNIT_ASSERT_EQUAL(OUString("Second Note"), pNote->GetText()); + pNote = m_pDoc->GetNote(ScAddress(1,3,0)); + CPPUNIT_ASSERT_MESSAGE("B4 should NOT have a note.", !pNote); + + // Undo. + + SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT_MESSAGE("Failed to get undo manager.", pUndoMgr); + m_pDoc->CreateAllNoteCaptions(); // to make sure that all notes have their corresponding caption objects... + + pUndoMgr->Undo(); + pNote = m_pDoc->GetNote(ScAddress(1,1,0)); + CPPUNIT_ASSERT_MESSAGE("B2 should NOT have a note.", !pNote); + pNote = m_pDoc->GetNote(ScAddress(1,2,0)); + CPPUNIT_ASSERT_MESSAGE("B3 should have a note.", pNote); + CPPUNIT_ASSERT_EQUAL(OUString("First Note"), pNote->GetText()); + pNote = m_pDoc->GetNote(ScAddress(1,3,0)); + CPPUNIT_ASSERT_MESSAGE("B4 should have a note.", pNote); + CPPUNIT_ASSERT_EQUAL(OUString("Second Note"), pNote->GetText()); + + // Delete row 3. + rDocFunc.DeleteCells(ScRange(0,2,0,MAXCOL,2,0), &aMark, DelCellCmd::CellsUp, true); + + pNote = m_pDoc->GetNote(ScAddress(1,2,0)); + CPPUNIT_ASSERT_MESSAGE("B3 should have a note.", pNote); + CPPUNIT_ASSERT_EQUAL(OUString("Second Note"), pNote->GetText()); + pNote = m_pDoc->GetNote(ScAddress(1,3,0)); + CPPUNIT_ASSERT_MESSAGE("B4 should NOT have a note.", !pNote); + + // Undo and check the result. + pUndoMgr->Undo(); + pNote = m_pDoc->GetNote(ScAddress(1,2,0)); + CPPUNIT_ASSERT_MESSAGE("B3 should have a note.", pNote); + CPPUNIT_ASSERT_EQUAL(OUString("First Note"), pNote->GetText()); + pNote = m_pDoc->GetNote(ScAddress(1,3,0)); + CPPUNIT_ASSERT_MESSAGE("B4 should have a note.", pNote); + CPPUNIT_ASSERT_EQUAL(OUString("Second Note"), pNote->GetText()); + + m_pDoc->DeleteTab(0); +} + +void Test::testNoteDeleteCol() +{ + ScDocument& rDoc = getDocShell().GetDocument(); + rDoc.InsertTab(0, "Sheet1"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + ScAddress rAddr(1, 1, 0); + ScPostIt* pNote = m_pDoc->GetOrCreateNote(rAddr); + pNote->SetText(rAddr, "Hello"); + pNote->SetAuthor("Jim Bob"); + + CPPUNIT_ASSERT_MESSAGE("there should be a note", rDoc.HasNote(1, 1, 0)); + + rDoc.DeleteCol(0, 0, MAXROW, 0, 1, 1); + + CPPUNIT_ASSERT_MESSAGE("there should be no more note", !rDoc.HasNote(1, 1, 0)); + + rDoc.DeleteTab(0); +} + +void Test::testNoteLifeCycle() +{ + m_pDoc->InsertTab(0, "Test"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + ScAddress aPos(1,1,0); + ScPostIt* pNote = m_pDoc->GetOrCreateNote(aPos); + CPPUNIT_ASSERT_MESSAGE("Failed to insert a new cell comment.", pNote); + + pNote->SetText(aPos, "New note"); + std::unique_ptr<ScPostIt> pNote2 = m_pDoc->ReleaseNote(aPos); + CPPUNIT_ASSERT_EQUAL_MESSAGE("This note instance is expected to be identical to the original.", pNote, pNote2.get()); + CPPUNIT_ASSERT_MESSAGE("The note shouldn't be here after it's been released.", !m_pDoc->HasNote(aPos)); + + // Modify the internal state of the note instance to make sure it's really + // been released. + pNote->SetText(aPos, "New content"); + + // Re-insert the note back to the same place. + m_pDoc->SetNote(aPos, std::move(pNote2)); + SdrCaptionObj* pCaption = pNote->GetOrCreateCaption(aPos); + CPPUNIT_ASSERT_MESSAGE("Failed to create a caption object.", pCaption); + CPPUNIT_ASSERT_EQUAL_MESSAGE("This caption should belong to the drawing layer of the document.", + m_pDoc->GetDrawLayer(), static_cast<ScDrawLayer*>(&pCaption->getSdrModelFromSdrObject())); + + // Copy B2 with note to a clipboard. + + ScClipParam aClipParam(aPos, false); + ScDocument aClipDoc(SCDOCMODE_CLIP); + ScMarkData aMarkData(MAXROW, MAXCOL); + aMarkData.SelectOneTable(0); + m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMarkData, false, true); + + ScPostIt* pClipNote = aClipDoc.GetNote(aPos); + CPPUNIT_ASSERT_MESSAGE("Failed to copy note to the clipboard.", pClipNote); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Note on the clipboard should share the same caption object from the original.", + pCaption, pClipNote->GetCaption()); + + + // Move B2 to B3 with note, which creates an ScUndoDragDrop, and Undo. + + ScAddress aOrigPos(aPos); + ScAddress aMovePos(1,2,0); + ScPostIt* pOrigNote = m_pDoc->GetNote(aOrigPos); + const SdrCaptionObj* pOrigCaption = pOrigNote->GetOrCreateCaption(aOrigPos); + bool const bCut = true; // like Drag&Drop + bool bRecord = true; // record Undo + bool const bPaint = false; // don't care about + bool bApi = true; // API to prevent dialogs + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + bool bMoveDone = rDocFunc.MoveBlock(ScRange(aOrigPos, aOrigPos), aMovePos, bCut, bRecord, bPaint, bApi); + CPPUNIT_ASSERT_MESSAGE("Cells not moved", bMoveDone); + + // Verify the note move. + ScPostIt* pGoneNote = m_pDoc->GetNote(aOrigPos); + CPPUNIT_ASSERT_MESSAGE("Failed to move the note from source.", !pGoneNote); + ScPostIt* pMoveNote = m_pDoc->GetNote(aMovePos); + CPPUNIT_ASSERT_MESSAGE("Failed to move the note to destination.", pMoveNote); + + // The caption object should not be identical, it was newly created upon + // Drop from clipboard. + // pOrigCaption is a dangling pointer. + const SdrCaptionObj* pMoveCaption = pMoveNote->GetOrCreateCaption(aMovePos); + CPPUNIT_ASSERT_MESSAGE("Captions identical after move.", pOrigCaption != pMoveCaption); + + SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT(pUndoMgr); + pUndoMgr->Undo(); // this should not crash ... tdf#92995 + + // Verify the note move Undo. + pMoveNote = m_pDoc->GetNote(aMovePos); + CPPUNIT_ASSERT_MESSAGE("Failed to undo the note move from destination.", !pMoveNote); + pOrigNote = m_pDoc->GetNote(aOrigPos); + CPPUNIT_ASSERT_MESSAGE("Failed to undo the note move to source.", pOrigNote); + + // The caption object still should not be identical. + // pMoveCaption is a dangling pointer. + pOrigCaption = pOrigNote->GetOrCreateCaption(aOrigPos); + CPPUNIT_ASSERT_MESSAGE("Captions identical after move undo.", pOrigCaption != pMoveCaption); + + + // Create a note at B4, merge B4 and B5 with ScUndoMerge, and Undo. + + ScAddress aPosB4(1,3,0); + ScPostIt* pNoteB4 = m_pDoc->GetOrCreateNote(aPosB4); + CPPUNIT_ASSERT_MESSAGE("Failed to insert cell comment at B4.", pNoteB4); + const SdrCaptionObj* pCaptionB4 = pNoteB4->GetOrCreateCaption(aPosB4); + ScCellMergeOption aCellMergeOption(1,3,2,3); + rDocFunc.MergeCells( aCellMergeOption, true /*bContents*/, bRecord, bApi, false /*bEmptyMergedCells*/ ); + + SfxUndoManager* pMergeUndoManager = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT(pMergeUndoManager); + pMergeUndoManager->Undo(); // this should not crash ... tdf#105667 + + // Undo contained the original caption object pointer which was still alive + // at B4 after the merge and not cloned nor recreated during Undo. + ScPostIt* pUndoNoteB4 = m_pDoc->GetNote(aPosB4); + CPPUNIT_ASSERT_MESSAGE("No cell comment at B4 after Undo.", pUndoNoteB4); + const SdrCaptionObj* pUndoCaptionB4 = pUndoNoteB4->GetCaption(); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Captions not identical after Merge Undo.", pCaptionB4, pUndoCaptionB4); + + + // In a second document copy a note from B5 to clipboard, close the + // document and then paste the note into this document. + { + ScDocShellRef xDocSh2; + getNewDocShell(xDocSh2); + ScDocument* pDoc2 = &xDocSh2->GetDocument(); + pDoc2->InsertTab(0, "OtherSheet1"); + pDoc2->InitDrawLayer(xDocSh2.get()); + + ScAddress aPosB5(1,4,0); + ScPostIt* pOtherNoteB5 = pDoc2->GetOrCreateNote(aPosB5); + CPPUNIT_ASSERT_MESSAGE("Failed to insert cell comment at B5.", pOtherNoteB5); + const SdrCaptionObj* pOtherCaptionB5 = pOtherNoteB5->GetOrCreateCaption(aPosB5); + CPPUNIT_ASSERT_MESSAGE("No caption at B5.", pOtherCaptionB5); + + ScDocument aClipDoc2(SCDOCMODE_CLIP); + copyToClip( pDoc2, aPosB5, &aClipDoc2); + + // There's no ScTransferObject involved in the "fake" clipboard copy + // and ScDocument dtor asking IsClipboardSource() gets no, so emulate + // the part that normally is responsible for forgetting the caption + // objects. + aClipDoc2.ClosingClipboardSource(); + + pDoc2->DeleteTab(0); + closeDocShell(xDocSh2); + + pasteFromClip( m_pDoc, aPosB5, &aClipDoc2); // should not crash... tdf#104967 + ScPostIt* pNoteB5 = m_pDoc->GetNote(aPosB5); + CPPUNIT_ASSERT_MESSAGE("Failed to paste cell comment at B5.", pNoteB5); + const SdrCaptionObj* pCaptionB5 = pNoteB5->GetOrCreateCaption(aPosB5); + CPPUNIT_ASSERT_MESSAGE("No caption at pasted B5.", pCaptionB5); + // Do not test if pCaptionB5 != pOtherCaptionB5 because since pDoc2 + // has been closed and the caption been deleted objects *may* be + // allocated at the very same memory location. + } + + m_pDoc->DeleteTab(0); +} + +void Test::testNoteCopyPaste() +{ + m_pDoc->InsertTab(0, "Test"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + // Insert in B2 a text and cell comment. + ScAddress aPos(1,1,0); + m_pDoc->SetString(aPos, "Text"); + ScPostIt* pNote = m_pDoc->GetOrCreateNote(aPos); + CPPUNIT_ASSERT(pNote); + pNote->SetText(aPos, "Note1"); + + // Insert in B4 a number and cell comment. + aPos.SetRow(3); + m_pDoc->SetValue(aPos, 1.1); + pNote = m_pDoc->GetOrCreateNote(aPos); + CPPUNIT_ASSERT(pNote); + pNote->SetText(aPos, "Note2"); + + // Copy B2:B4 to clipboard. + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + ScRange aCopyRange(1,1,0,1,3,0); + ScDocument aClipDoc(SCDOCMODE_CLIP); + aClipDoc.ResetClip(m_pDoc, &aMark); + ScClipParam aClipParam(aCopyRange, false); + m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false); + + // Make sure the notes are in the clipboard. + pNote = aClipDoc.GetNote(ScAddress(1,1,0)); + CPPUNIT_ASSERT(pNote); + CPPUNIT_ASSERT_EQUAL(OUString("Note1"), pNote->GetText()); + + pNote = aClipDoc.GetNote(ScAddress(1,3,0)); + CPPUNIT_ASSERT(pNote); + CPPUNIT_ASSERT_EQUAL(OUString("Note2"), pNote->GetText()); + + // Paste to B6:B8 but only cell notes. + ScRange aDestRange(1,5,0,1,7,0); + m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::NOTE, nullptr, &aClipDoc); + + // Make sure the notes are there. + pNote = m_pDoc->GetNote(ScAddress(1,5,0)); + CPPUNIT_ASSERT(pNote); + CPPUNIT_ASSERT_EQUAL(OUString("Note1"), pNote->GetText()); + + pNote = m_pDoc->GetNote(ScAddress(1,7,0)); + CPPUNIT_ASSERT(pNote); + CPPUNIT_ASSERT_EQUAL(OUString("Note2"), pNote->GetText()); + + // Test that GetNotesInRange includes the end of its range + // and so can find the note + std::vector<sc::NoteEntry> aNotes; + m_pDoc->GetNotesInRange(ScRange(1,7,0), aNotes); + CPPUNIT_ASSERT_EQUAL(size_t(1), aNotes.size()); + + m_pDoc->DeleteTab(0); +} + +// tdf#112454 +void Test::testNoteContainsNotesInRange() { + m_pDoc->InsertTab(0, "PostIts"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + ScAddress aAddr(2, 2, 0); // cell C3 + + CPPUNIT_ASSERT_MESSAGE("Claiming there's notes in a document that doesn't have any.", + !m_pDoc->ContainsNotesInRange((ScRange(ScAddress(0, 0, 0), aAddr)))); + + m_pDoc->GetOrCreateNote(aAddr); + + CPPUNIT_ASSERT_MESSAGE("Claiming there's notes in range that doesn't have any.", + !m_pDoc->ContainsNotesInRange(ScRange(ScAddress(0, 0, 0), ScAddress(0, 1, 0)))); + CPPUNIT_ASSERT_MESSAGE("Note not detected that lies on border of range.", + m_pDoc->ContainsNotesInRange((ScRange(ScAddress(0, 0, 0), aAddr)))); + CPPUNIT_ASSERT_MESSAGE("Note not detected that lies in inner area of range.", + m_pDoc->ContainsNotesInRange((ScRange(ScAddress(0, 0, 0), ScAddress(3, 3, 0))))); +} + +void Test::testAreasWithNotes() +{ + ScDocument& rDoc = getDocShell().GetDocument(); + rDoc.InsertTab(0, "Sheet1"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + ScAddress rAddr(1, 5, 0); + ScPostIt* pNote = m_pDoc->GetOrCreateNote(rAddr); + pNote->SetText(rAddr, "Hello"); + pNote->SetAuthor("Jim Bob"); + ScAddress rAddrMin(2, 2, 0); + ScPostIt* pNoteMin = m_pDoc->GetOrCreateNote(rAddrMin); + pNoteMin->SetText(rAddrMin, "Hello"); + + SCCOL col; + SCROW row; + bool dataFound; + + // only cell notes (empty content) + + dataFound = rDoc.GetDataStart(0,col,row); + + CPPUNIT_ASSERT_MESSAGE("No DataStart found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("DataStart wrong col for notes", static_cast<SCCOL>(1), col); + CPPUNIT_ASSERT_EQUAL_MESSAGE("DataStart wrong row for notes", static_cast<SCROW>(2), row); + + dataFound = rDoc.GetCellArea(0,col,row); + + CPPUNIT_ASSERT_MESSAGE("No CellArea found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("CellArea wrong col for notes", static_cast<SCCOL>(2), col); + CPPUNIT_ASSERT_EQUAL_MESSAGE("CellArea wrong row for notes", static_cast<SCROW>(5), row); + + bool bNotes = true; + dataFound = rDoc.GetPrintArea(0,col,row, bNotes); + + CPPUNIT_ASSERT_MESSAGE("No PrintArea found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintArea wrong col for notes", static_cast<SCCOL>(2), col); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintArea wrong row for notes", static_cast<SCROW>(5), row); + + bNotes = false; + dataFound = rDoc.GetPrintArea(0,col,row, bNotes); + CPPUNIT_ASSERT_MESSAGE("No PrintArea should be found", !dataFound); + + bNotes = true; + dataFound = rDoc.GetPrintAreaVer(0,0,1,row, bNotes); // cols 0 & 1 + CPPUNIT_ASSERT_MESSAGE("No PrintAreaVer found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintAreaVer wrong row for notes", static_cast<SCROW>(5), row); + + dataFound = rDoc.GetPrintAreaVer(0,2,3,row, bNotes); // cols 2 & 3 + CPPUNIT_ASSERT_MESSAGE("No PrintAreaVer found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintAreaVer wrong row for notes", static_cast<SCROW>(2), row); + + bNotes = false; + dataFound = rDoc.GetPrintAreaVer(0,0,1,row, bNotes); // col 0 & 1 + CPPUNIT_ASSERT_MESSAGE("No PrintAreaVer should be found", !dataFound); + + // now add cells with value, check that notes are taken into account in good cases + + m_pDoc->SetString(0, 3, 0, "Some Text"); + m_pDoc->SetString(3, 3, 0, "Some Text"); + + dataFound = rDoc.GetDataStart(0,col,row); + + CPPUNIT_ASSERT_MESSAGE("No DataStart found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("DataStart wrong col", static_cast<SCCOL>(0), col); + CPPUNIT_ASSERT_EQUAL_MESSAGE("DataStart wrong row", static_cast<SCROW>(2), row); + + dataFound = rDoc.GetCellArea(0,col,row); + + CPPUNIT_ASSERT_MESSAGE("No CellArea found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("CellArea wrong col", static_cast<SCCOL>(3), col); + CPPUNIT_ASSERT_EQUAL_MESSAGE("CellArea wrong row", static_cast<SCROW>(5), row); + + bNotes = true; + dataFound = rDoc.GetPrintArea(0,col,row, bNotes); + + CPPUNIT_ASSERT_MESSAGE("No PrintArea found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintArea wrong col", static_cast<SCCOL>(3), col); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintArea wrong row", static_cast<SCROW>(5), row); + + bNotes = false; + dataFound = rDoc.GetPrintArea(0,col,row, bNotes); + CPPUNIT_ASSERT_MESSAGE("No PrintArea found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintArea wrong col", static_cast<SCCOL>(3), col); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintArea wrong row", static_cast<SCROW>(3), row); + + bNotes = true; + dataFound = rDoc.GetPrintAreaVer(0,0,1,row, bNotes); // cols 0 & 1 + CPPUNIT_ASSERT_MESSAGE("No PrintAreaVer found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintAreaVer wrong row", static_cast<SCROW>(5), row); + + dataFound = rDoc.GetPrintAreaVer(0,2,3,row, bNotes); // cols 2 & 3 + CPPUNIT_ASSERT_MESSAGE("No PrintAreaVer found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintAreaVer wrong row", static_cast<SCROW>(3), row); + + bNotes = false; + dataFound = rDoc.GetPrintAreaVer(0,0,1,row, bNotes); // cols 0 & 1 + CPPUNIT_ASSERT_MESSAGE("No PrintAreaVer found", dataFound); + CPPUNIT_ASSERT_EQUAL_MESSAGE("PrintAreaVer wrong row", static_cast<SCROW>(3), row); + + rDoc.DeleteTab(0); +} + +void Test::testAnchoredRotatedShape() +{ + m_pDoc->InsertTab(0, "TestTab"); + SCROW nRow1, nRow2; + bool bHidden = m_pDoc->RowHidden(0, 0, &nRow1, &nRow2); + CPPUNIT_ASSERT_MESSAGE("new sheet should have all rows visible", !bHidden && nRow1 == 0 && nRow2 == MAXROW); + + m_pDoc->InitDrawLayer(); + ScDrawLayer *pDrawLayer = m_pDoc->GetDrawLayer(); + CPPUNIT_ASSERT_MESSAGE("must have a draw layer", pDrawLayer != nullptr); + SdrPage* pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("must have a draw page", pPage != nullptr); + m_pDoc->SetRowHeightRange( 0, MAXROW, 0, sc::HMMToTwips( 1000 ) ); + const long TOLERANCE = 30; //30 hmm + for ( SCCOL nCol = 0; nCol < MAXCOL; ++nCol ) + m_pDoc->SetColWidth( nCol, 0, sc::HMMToTwips( 1000 ) ); + { + //Add a rect + tools::Rectangle aRect( 4000, 5000, 10000, 7000 ); + + tools::Rectangle aRotRect( 6000, 3000, 8000, 9000 ); + SdrRectObj *pObj = new SdrRectObj(*pDrawLayer, aRect); + pPage->InsertObject(pObj); + Point aRef1(pObj->GetSnapRect().Center()); + int nAngle = 9000; //90 deg. + double nSin = sin(nAngle * F_PI18000); + double nCos = cos(nAngle * F_PI18000); + pObj->Rotate(aRef1,nAngle,nSin,nCos); + + ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *m_pDoc, 0, true); + + tools::Rectangle aSnap = pObj->GetSnapRect(); + CPPUNIT_ASSERT_EQUAL( true, testEqualsWithTolerance( aRotRect.GetHeight(), aSnap.GetHeight(), TOLERANCE ) ); + CPPUNIT_ASSERT_EQUAL( true, testEqualsWithTolerance( aRotRect.GetWidth(), aSnap.GetWidth(), TOLERANCE ) ); + CPPUNIT_ASSERT_EQUAL( true, testEqualsWithTolerance( aRotRect.Left(), aSnap.Left(), TOLERANCE ) ); + CPPUNIT_ASSERT_EQUAL( true, testEqualsWithTolerance( aRotRect.Top(), aSnap.Top(), TOLERANCE ) ); + + ScDrawObjData aAnchor; + ScDrawObjData* pData = ScDrawLayer::GetObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to get drawing object meta-data.", pData); + + aAnchor.maStart = pData->maStart; + aAnchor.maEnd = pData->maEnd; + + m_pDoc->SetDrawPageSize(0); + + // increase row 5 by 2000 hmm + m_pDoc->SetRowHeight( 5, 0, sc::HMMToTwips( 3000 ) ); + // increase col 6 by 1000 hmm + m_pDoc->SetColWidth( 6, 0, sc::HMMToTwips( 2000 ) ); + + aRotRect.setWidth( aRotRect.GetWidth() + 1000 ); + aRotRect.setHeight( aRotRect.GetHeight() + 2000 ); + + m_pDoc->SetDrawPageSize(0); + + aSnap = pObj->GetSnapRect(); + + // ensure that width and height have been adjusted accordingly + CPPUNIT_ASSERT_EQUAL( true, testEqualsWithTolerance( aRotRect.GetHeight(), aSnap.GetHeight(), TOLERANCE ) ); + CPPUNIT_ASSERT_EQUAL( true, testEqualsWithTolerance( aRotRect.GetWidth(), aSnap.GetWidth(), TOLERANCE ) ); + + // ensure that anchor start and end addresses haven't changed + CPPUNIT_ASSERT_EQUAL( aAnchor.maStart.Row(), pData->maStart.Row() ); // start row 0 + CPPUNIT_ASSERT_EQUAL( aAnchor.maStart.Col(), pData->maStart.Col() ); // start column 5 + CPPUNIT_ASSERT_EQUAL( aAnchor.maEnd.Row(), pData->maEnd.Row() ); // end row 3 + CPPUNIT_ASSERT_EQUAL( aAnchor.maEnd.Col(), pData->maEnd.Col() ); // end col 7 + } + m_pDoc->DeleteTab(0); +} + +void Test::testCellTextWidth() +{ + m_pDoc->InsertTab(0, "Test"); + + ScAddress aTopCell(0, 0, 0); + + // Sheet is empty. + std::unique_ptr<ScColumnTextWidthIterator> pIter(new ScColumnTextWidthIterator(*m_pDoc, aTopCell, MAXROW)); + CPPUNIT_ASSERT_MESSAGE("Column should have no text widths stored.", !pIter->hasCell()); + + // Sheet only has one cell. + m_pDoc->SetString(0, 0, 0, "Only one cell"); + pIter.reset(new ScColumnTextWidthIterator(*m_pDoc, aTopCell, MAXROW)); + CPPUNIT_ASSERT_MESSAGE("Column should have a cell.", pIter->hasCell()); + CPPUNIT_ASSERT_EQUAL(SCROW(0), pIter->getPos()); + + // Setting a text width here should commit it to the column. + sal_uInt16 nTestVal = 432; + pIter->setValue(nTestVal); + CPPUNIT_ASSERT_EQUAL(nTestVal, m_pDoc->GetTextWidth(aTopCell)); + + // Set values to row 2 through 6. + for (SCROW i = 2; i <= 6; ++i) + m_pDoc->SetString(0, i, 0, "foo"); + + // Set values to row 10 through 18. + for (SCROW i = 10; i <= 18; ++i) + m_pDoc->SetString(0, i, 0, "foo"); + + { + // Full range. + pIter.reset(new ScColumnTextWidthIterator(*m_pDoc, aTopCell, MAXROW)); + SCROW aRows[] = { 0, 2, 3, 4, 5, 6, 10, 11, 12, 13, 14, 15, 16, 17, 18 }; + for (size_t i = 0; i < SAL_N_ELEMENTS(aRows); ++i, pIter->next()) + { + CPPUNIT_ASSERT_MESSAGE("Cell expected, but not there.", pIter->hasCell()); + CPPUNIT_ASSERT_EQUAL(aRows[i], pIter->getPos()); + } + CPPUNIT_ASSERT_MESSAGE("Iterator should have ended.", !pIter->hasCell()); + } + + { + // Specify start and end rows (6 - 16) + ScAddress aStart = aTopCell; + aStart.SetRow(6); + pIter.reset(new ScColumnTextWidthIterator(*m_pDoc, aStart, 16)); + SCROW aRows[] = { 6, 10, 11, 12, 13, 14, 15, 16 }; + for (size_t i = 0; i < SAL_N_ELEMENTS(aRows); ++i, pIter->next()) + { + CPPUNIT_ASSERT_MESSAGE("Cell expected, but not there.", pIter->hasCell()); + CPPUNIT_ASSERT_EQUAL(aRows[i], pIter->getPos()); + } + CPPUNIT_ASSERT_MESSAGE("Iterator should have ended.", !pIter->hasCell()); + } + + // Clear from row 3 to row 17. After this, we should only have cells at rows 0, 2 and 18. + clearRange(m_pDoc, ScRange(0, 3, 0, 0, 17, 0)); + + { + // Full range again. + pIter.reset(new ScColumnTextWidthIterator(*m_pDoc, aTopCell, MAXROW)); + SCROW aRows[] = { 0, 2, 18 }; + for (size_t i = 0; i < SAL_N_ELEMENTS(aRows); ++i, pIter->next()) + { + CPPUNIT_ASSERT_MESSAGE("Cell expected, but not there.", pIter->hasCell()); + CPPUNIT_ASSERT_EQUAL(aRows[i], pIter->getPos()); + } + CPPUNIT_ASSERT_MESSAGE("Iterator should have ended.", !pIter->hasCell()); + } + + // Delete row 2 which shifts all cells below row 2 upward. After this, we + // should only have cells at rows 0 and 17. + m_pDoc->DeleteRow(0, 0, MAXCOL, MAXTAB, 2, 1); + { + // Full range again. + pIter.reset(new ScColumnTextWidthIterator(*m_pDoc, aTopCell, MAXROW)); + SCROW aRows[] = { 0, 17 }; + for (size_t i = 0; i < SAL_N_ELEMENTS(aRows); ++i, pIter->next()) + { + CPPUNIT_ASSERT_MESSAGE("Cell expected, but not there.", pIter->hasCell()); + CPPUNIT_ASSERT_EQUAL(aRows[i], pIter->getPos()); + } + CPPUNIT_ASSERT_MESSAGE("Iterator should have ended.", !pIter->hasCell()); + } + + m_pDoc->DeleteTab(0); +} + +static bool checkEditTextIterator(sc::EditTextIterator& rIter, const char** pChecks) +{ + const EditTextObject* pText = rIter.first(); + const char* p = *pChecks; + + for (int i = 0; i < 100; ++i) // cap it to 100 loops. + { + if (!pText) + // No more edit cells. The check string array should end too. + return p == nullptr; + + if (!p) + // More edit cell, but no more check string. Bad. + return false; + + if (pText->GetParagraphCount() != 1) + // For this test, we don't handle multi-paragraph text. + return false; + + if (pText->GetText(0) != OUString::createFromAscii(p)) + // Text differs from what's expected. + return false; + + pText = rIter.next(); + ++pChecks; + p = *pChecks; + } + + return false; +} + +void Test::testEditTextIterator() +{ + m_pDoc->InsertTab(0, "Test"); + + { + // First, try with an empty sheet. + sc::EditTextIterator aIter(*m_pDoc,0); + const char* pChecks[] = { nullptr }; + CPPUNIT_ASSERT_MESSAGE("Wrong iterator behavior.", checkEditTextIterator(aIter, pChecks)); + } + + ScFieldEditEngine& rEditEngine = m_pDoc->GetEditEngine(); + + { + // Only set one edit cell. + rEditEngine.SetTextCurrentDefaults("A2"); + m_pDoc->SetEditText(ScAddress(0,1,0), rEditEngine.CreateTextObject()); + sc::EditTextIterator aIter(*m_pDoc,0); + const char* pChecks[] = { "A2", nullptr }; + CPPUNIT_ASSERT_MESSAGE("Wrong iterator behavior.", checkEditTextIterator(aIter, pChecks)); + } + + { + // Add a series of edit cells. + rEditEngine.SetTextCurrentDefaults("A5"); + m_pDoc->SetEditText(ScAddress(0,4,0), rEditEngine.CreateTextObject()); + rEditEngine.SetTextCurrentDefaults("A6"); + m_pDoc->SetEditText(ScAddress(0,5,0), rEditEngine.CreateTextObject()); + rEditEngine.SetTextCurrentDefaults("A7"); + m_pDoc->SetEditText(ScAddress(0,6,0), rEditEngine.CreateTextObject()); + sc::EditTextIterator aIter(*m_pDoc,0); + const char* pChecks[] = { "A2", "A5", "A6", "A7", nullptr }; + CPPUNIT_ASSERT_MESSAGE("Wrong iterator behavior.", checkEditTextIterator(aIter, pChecks)); + } + + { + // Add more edit cells to column C. Skip column B. + rEditEngine.SetTextCurrentDefaults("C1"); + m_pDoc->SetEditText(ScAddress(2,0,0), rEditEngine.CreateTextObject()); + rEditEngine.SetTextCurrentDefaults("C3"); + m_pDoc->SetEditText(ScAddress(2,2,0), rEditEngine.CreateTextObject()); + rEditEngine.SetTextCurrentDefaults("C4"); + m_pDoc->SetEditText(ScAddress(2,3,0), rEditEngine.CreateTextObject()); + sc::EditTextIterator aIter(*m_pDoc,0); + const char* pChecks[] = { "A2", "A5", "A6", "A7", "C1", "C3", "C4", nullptr }; + CPPUNIT_ASSERT_MESSAGE("Wrong iterator behavior.", checkEditTextIterator(aIter, pChecks)); + } + + { + // Add some numeric, string and formula cells. This shouldn't affect the outcome. + m_pDoc->SetString(ScAddress(0,99,0), "=ROW()"); + m_pDoc->SetValue(ScAddress(1,3,0), 1.2); + m_pDoc->SetString(ScAddress(2,4,0), "Simple string"); + sc::EditTextIterator aIter(*m_pDoc,0); + const char* pChecks[] = { "A2", "A5", "A6", "A7", "C1", "C3", "C4", nullptr }; + CPPUNIT_ASSERT_MESSAGE("Wrong iterator behavior.", checkEditTextIterator(aIter, pChecks)); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testImportStream() +{ + sc::AutoCalcSwitch aAC(*m_pDoc, true); // turn on auto calc. + sc::UndoSwitch aUndo(*m_pDoc, true); // enable undo. + + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetString(ScAddress(0,1,0), "=SUM(A1:C1)"); // A2 + + CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(0,1,0))); + + // CSV import options. + ScAsciiOptions aOpt; + aOpt.SetFieldSeps(","); + + // Import values to A1:C1. + ScImportExport aObj(m_pDoc, ScAddress(0,0,0)); + aObj.SetImportBroadcast(true); + aObj.SetExtOptions(aOpt); + aObj.ImportString("1,2,3", SotClipboardFormatId::STRING); + + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(1,0,0))); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(2,0,0))); + + // Formula value should have been updated. + CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,1,0))); + + // Undo, and check the result. + SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT_MESSAGE("Failed to get the undo manager.", pUndoMgr); + pUndoMgr->Undo(); + + CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(1,0,0))); + CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(2,0,0))); + + CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(0,1,0))); // formula + + // Redo, and check the result. + pUndoMgr->Redo(); + + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(1,0,0))); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(2,0,0))); + + CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,1,0))); // formula + + pUndoMgr->Clear(); + + m_pDoc->DeleteTab(0); +} + +void Test::testDeleteContents() +{ + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc. + sc::UndoSwitch aUndoSwitch(*m_pDoc, true); // enable undo. + + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetValue(ScAddress(3,1,0), 1.0); + m_pDoc->SetValue(ScAddress(3,2,0), 1.0); + m_pDoc->SetValue(ScAddress(3,3,0), 1.0); + m_pDoc->SetValue(ScAddress(3,4,0), 1.0); + m_pDoc->SetValue(ScAddress(3,5,0), 1.0); + m_pDoc->SetValue(ScAddress(3,6,0), 1.0); + m_pDoc->SetValue(ScAddress(3,7,0), 1.0); + m_pDoc->SetValue(ScAddress(3,8,0), 1.0); + m_pDoc->SetString(ScAddress(3,15,0), "=SUM(D2:D15)"); + + CPPUNIT_ASSERT_EQUAL(8.0, m_pDoc->GetValue(ScAddress(3,15,0))); // formula + + // Delete D2:D6. + ScRange aRange(3,1,0,3,5,0); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + aMark.SetMarkArea(aRange); + + ScDocumentUniquePtr pUndoDoc(new ScDocument(SCDOCMODE_UNDO)); + pUndoDoc->InitUndo(m_pDoc, 0, 0); + m_pDoc->CopyToDocument(aRange, InsertDeleteFlags::CONTENTS, false, *pUndoDoc, &aMark); + ScUndoDeleteContents aUndo(&getDocShell(), aMark, aRange, std::move(pUndoDoc), false, InsertDeleteFlags::CONTENTS, true); + + clearRange(m_pDoc, aRange); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(3,15,0))); // formula + + aUndo.Undo(); + CPPUNIT_ASSERT_EQUAL(8.0, m_pDoc->GetValue(ScAddress(3,15,0))); // formula + + aUndo.Redo(); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(3,15,0))); // formula + + m_pDoc->DeleteTab(0); +} + +void Test::testTransliterateText() +{ + m_pDoc->InsertTab(0, "Test"); + + // Set texts to A1:A3. + m_pDoc->SetString(ScAddress(0,0,0), "Mike"); + m_pDoc->SetString(ScAddress(0,1,0), "Noah"); + m_pDoc->SetString(ScAddress(0,2,0), "Oscar"); + + // Change them to uppercase. + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(ScRange(0,0,0,0,2,0)); + ScDocFunc& rFunc = getDocShell().GetDocFunc(); + rFunc.TransliterateText( + aMark, TransliterationFlags::LOWERCASE_UPPERCASE, true); + + CPPUNIT_ASSERT_EQUAL(OUString("MIKE"), m_pDoc->GetString(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(OUString("NOAH"), m_pDoc->GetString(ScAddress(0,1,0))); + CPPUNIT_ASSERT_EQUAL(OUString("OSCAR"), m_pDoc->GetString(ScAddress(0,2,0))); + + // Test the undo and redo. + SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT_MESSAGE("Failed to get undo manager.", pUndoMgr); + + pUndoMgr->Undo(); + CPPUNIT_ASSERT_EQUAL(OUString("Mike"), m_pDoc->GetString(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(OUString("Noah"), m_pDoc->GetString(ScAddress(0,1,0))); + CPPUNIT_ASSERT_EQUAL(OUString("Oscar"), m_pDoc->GetString(ScAddress(0,2,0))); + + pUndoMgr->Redo(); + CPPUNIT_ASSERT_EQUAL(OUString("MIKE"), m_pDoc->GetString(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(OUString("NOAH"), m_pDoc->GetString(ScAddress(0,1,0))); + CPPUNIT_ASSERT_EQUAL(OUString("OSCAR"), m_pDoc->GetString(ScAddress(0,2,0))); + + m_pDoc->DeleteTab(0); +} + +void Test::testFormulaToValue() +{ + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); + FormulaGrammarSwitch aFGSwitch(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH_XL_R1C1); + + m_pDoc->InsertTab(0, "Test"); + + const char* aData[][3] = { + { "=1", "=RC[-1]*2", "=ISFORMULA(RC[-1])" }, + { "=2", "=RC[-1]*2", "=ISFORMULA(RC[-1])" }, + { "=3", "=RC[-1]*2", "=ISFORMULA(RC[-1])" }, + { "=4", "=RC[-1]*2", "=ISFORMULA(RC[-1])" }, + { "=5", "=RC[-1]*2", "=ISFORMULA(RC[-1])" }, + { "=6", "=RC[-1]*2", "=ISFORMULA(RC[-1])" }, + }; + + ScAddress aPos(1,2,0); // B3 + ScRange aDataRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData)); + CPPUNIT_ASSERT_EQUAL_MESSAGE("failed to insert range data at correct position", aPos, aDataRange.aStart); + + { + // Expected output table content. 0 = empty cell + std::vector<std::vector<const char*>> aOutputCheck = { + { "1", "2", "TRUE" }, + { "2", "4", "TRUE" }, + { "3", "6", "TRUE" }, + { "4", "8", "TRUE" }, + { "5", "10", "TRUE" }, + { "6", "12", "TRUE" }, + }; + + bool bSuccess = checkOutput(m_pDoc, aDataRange, aOutputCheck, "Initial value"); + CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess); + } + + // Convert B5:C6 to static values, and check the result. + ScDocFunc& rFunc = getDocShell().GetDocFunc(); + ScRange aConvRange(1,4,0,2,5,0); // B5:C6 + rFunc.ConvertFormulaToValue(aConvRange, false); + + { + // Expected output table content. 0 = empty cell + std::vector<std::vector<const char*>> aOutputCheck = { + { "1", "2", "TRUE" }, + { "2", "4", "TRUE" }, + { "3", "6", "FALSE" }, + { "4", "8", "FALSE" }, + { "5", "10", "TRUE" }, + { "6", "12", "TRUE" }, + }; + + bool bSuccess = checkOutput(m_pDoc, aDataRange, aOutputCheck, "Converted"); + CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess); + } + + // Make sure that B3:B4 and B7:B8 are formula cells. + CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(ScAddress(1,2,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(ScAddress(1,3,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(ScAddress(1,6,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(ScAddress(1,7,0))); + + // Make sure that B5:C6 are numeric cells. + CPPUNIT_ASSERT_EQUAL(CELLTYPE_VALUE, m_pDoc->GetCellType(ScAddress(1,4,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_VALUE, m_pDoc->GetCellType(ScAddress(1,5,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_VALUE, m_pDoc->GetCellType(ScAddress(2,4,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_VALUE, m_pDoc->GetCellType(ScAddress(2,5,0))); + + // Make sure that formula cells in C3:C4 and C7:C8 are grouped. + const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(2,2,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedTopRow()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedLength()); + pFC = m_pDoc->GetFormulaCell(ScAddress(2,6,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(6), pFC->GetSharedTopRow()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedLength()); + + // Undo and check. + SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT(pUndoMgr); + pUndoMgr->Undo(); + + { + // Expected output table content. 0 = empty cell + std::vector<std::vector<const char*>> aOutputCheck = { + { "1", "2", "TRUE" }, + { "2", "4", "TRUE" }, + { "3", "6", "TRUE" }, + { "4", "8", "TRUE" }, + { "5", "10", "TRUE" }, + { "6", "12", "TRUE" }, + }; + + bool bSuccess = checkOutput(m_pDoc, aDataRange, aOutputCheck, "After undo"); + CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess); + } + + // B3:B8 should all be (ungrouped) formula cells. + for (SCROW i = 2; i <= 7; ++i) + { + pFC = m_pDoc->GetFormulaCell(ScAddress(1,i,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT(!pFC->IsShared()); + } + + // C3:C8 should be shared formula cells. + pFC = m_pDoc->GetFormulaCell(ScAddress(2,2,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedTopRow()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(6), pFC->GetSharedLength()); + + // Redo and check. + pUndoMgr->Redo(); + { + // Expected output table content. 0 = empty cell + std::vector<std::vector<const char*>> aOutputCheck = { + { "1", "2", "TRUE" }, + { "2", "4", "TRUE" }, + { "3", "6", "FALSE" }, + { "4", "8", "FALSE" }, + { "5", "10", "TRUE" }, + { "6", "12", "TRUE" }, + }; + + bool bSuccess = checkOutput(m_pDoc, aDataRange, aOutputCheck, "Converted"); + CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess); + } + + // Make sure that B3:B4 and B7:B8 are formula cells. + CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(ScAddress(1,2,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(ScAddress(1,3,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(ScAddress(1,6,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_FORMULA, m_pDoc->GetCellType(ScAddress(1,7,0))); + + // Make sure that B5:C6 are numeric cells. + CPPUNIT_ASSERT_EQUAL(CELLTYPE_VALUE, m_pDoc->GetCellType(ScAddress(1,4,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_VALUE, m_pDoc->GetCellType(ScAddress(1,5,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_VALUE, m_pDoc->GetCellType(ScAddress(2,4,0))); + CPPUNIT_ASSERT_EQUAL(CELLTYPE_VALUE, m_pDoc->GetCellType(ScAddress(2,5,0))); + + // Make sure that formula cells in C3:C4 and C7:C8 are grouped. + pFC = m_pDoc->GetFormulaCell(ScAddress(2,2,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedTopRow()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedLength()); + pFC = m_pDoc->GetFormulaCell(ScAddress(2,6,0)); + CPPUNIT_ASSERT(pFC); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(6), pFC->GetSharedTopRow()); + CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedLength()); + + // Undo again and make sure the recovered formulas in C5:C6 still track B5:B6. + pUndoMgr->Undo(); + m_pDoc->SetValue(ScAddress(1,4,0), 10); + m_pDoc->SetValue(ScAddress(1,5,0), 11); + CPPUNIT_ASSERT_EQUAL(20.0, m_pDoc->GetValue(ScAddress(2,4,0))); + CPPUNIT_ASSERT_EQUAL(22.0, m_pDoc->GetValue(ScAddress(2,5,0))); + + m_pDoc->DeleteTab(0); +} + +void Test::testFormulaToValue2() +{ + sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); + FormulaGrammarSwitch aFGSwitch(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH_XL_R1C1); + + m_pDoc->InsertTab(0, "Test"); + + std::vector<std::vector<const char*>> aData = { + { "=1", "=ISFORMULA(RC[-1])" }, + { "=2", "=ISFORMULA(RC[-1])" }, + { "3", "=ISFORMULA(RC[-1])" }, + { "=4", "=ISFORMULA(RC[-1])" }, + { "=5", "=ISFORMULA(RC[-1])" }, + }; + + // Insert data into B2:C6. + ScAddress aPos(1,1,0); // B2 + ScRange aDataRange = insertRangeData(m_pDoc, aPos, aData); + CPPUNIT_ASSERT_EQUAL_MESSAGE("failed to insert range data at correct position", aPos, aDataRange.aStart); + + { + // Expected output table content. 0 = empty cell + std::vector<std::vector<const char*>> aOutputCheck = { + { "1", "TRUE" }, + { "2", "TRUE" }, + { "3", "FALSE" }, + { "4", "TRUE" }, + { "5", "TRUE" }, + }; + + bool bSuccess = checkOutput(m_pDoc, aDataRange, aOutputCheck, "Initial value"); + CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess); + } + + // Convert B3:B5 to a value. + ScDocFunc& rFunc = getDocShell().GetDocFunc(); + ScRange aConvRange(1,2,0,1,4,0); // B3:B5 + rFunc.ConvertFormulaToValue(aConvRange, false); + + { + // Expected output table content. 0 = empty cell + std::vector<std::vector<const char*>> aOutputCheck = { + { "1", "TRUE" }, + { "2", "FALSE" }, + { "3", "FALSE" }, + { "4", "FALSE" }, + { "5", "TRUE" }, + }; + + bool bSuccess = checkOutput(m_pDoc, aDataRange, aOutputCheck, "Initial value"); + CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess); + } + + // Undo and check. + SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT(pUndoMgr); + pUndoMgr->Undo(); + + { + // Expected output table content. 0 = empty cell + std::vector<std::vector<const char*>> aOutputCheck = { + { "1", "TRUE" }, + { "2", "TRUE" }, + { "3", "FALSE" }, + { "4", "TRUE" }, + { "5", "TRUE" }, + }; + + bool bSuccess = checkOutput(m_pDoc, aDataRange, aOutputCheck, "Initial value"); + CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess); + } + + m_pDoc->DeleteTab(0); +} + +void Test::testMixData() +{ + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetValue(ScAddress(1,0,0), 2.0); // B1 + m_pDoc->SetValue(ScAddress(0,1,0), 3.0); // A2 + + // Copy A1:B1 to the clip document. + ScDocument aClipDoc(SCDOCMODE_CLIP); + copyToClip(m_pDoc, ScRange(0,0,0,1,0,0), &aClipDoc); // A1:B1 + + // Copy A2:B2 to the mix document (for arithmetic paste). + ScDocument aMixDoc(SCDOCMODE_CLIP); + copyToClip(m_pDoc, ScRange(0,1,0,1,1,0), &aMixDoc); // A2:B2 + + // Paste A1:B1 to A2:B2 and perform addition. + pasteFromClip(m_pDoc, ScRange(0,1,0,1,1,0), &aClipDoc); + m_pDoc->MixDocument(ScRange(0,1,0,1,1,0), ScPasteFunc::ADD, false, &aMixDoc); + + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(0,1,0)); // A2 + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(1,1,0)); // B2 + + // Clear everything and start over. + clearSheet(m_pDoc, 0); + clearSheet(&aClipDoc, 0); + clearSheet(&aMixDoc, 0); + + // Set values to A1, A2, and B1. B2 will remain empty. + m_pDoc->SetValue(ScAddress(0,0,0), 15.0); + m_pDoc->SetValue(ScAddress(0,1,0), 16.0); + m_pDoc->SetValue(ScAddress(1,0,0), 12.0); + CPPUNIT_ASSERT_EQUAL_MESSAGE("B2 should be empty.", CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(1,1,0))); + + // Copy A1:A2 and paste it onto B1:B2 with subtraction operation. + copyToClip(m_pDoc, ScRange(0,0,0,0,1,0), &aClipDoc); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetValue(ScAddress(0,0,0)), aClipDoc.GetValue(ScAddress(0,0,0))); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetValue(ScAddress(0,1,0)), aClipDoc.GetValue(ScAddress(0,1,0))); + + copyToClip(m_pDoc, ScRange(1,0,0,1,1,0), &aMixDoc); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetValue(ScAddress(1,0,0)), aMixDoc.GetValue(ScAddress(1,0,0))); + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetValue(ScAddress(1,1,0)), aMixDoc.GetValue(ScAddress(1,1,0))); + + pasteFromClip(m_pDoc, ScRange(1,0,0,1,1,0), &aClipDoc); + m_pDoc->MixDocument(ScRange(1,0,0,1,1,0), ScPasteFunc::SUB, false, &aMixDoc); + + CPPUNIT_ASSERT_EQUAL( -3.0, m_pDoc->GetValue(ScAddress(1,0,0))); // 12 - 15 + CPPUNIT_ASSERT_EQUAL(-16.0, m_pDoc->GetValue(ScAddress(1,1,0))); // 0 - 16 + + m_pDoc->DeleteTab(0); +} + +void Test::testFormulaWizardSubformula() +{ + m_pDoc->InsertTab(0, "Test"); + + m_pDoc->SetString(ScAddress(1,0,0), "=1"); // B1 + m_pDoc->SetString(ScAddress(1,1,0), "=1/0"); // B2 + m_pDoc->SetString(ScAddress(1,2,0), "=gibberish"); // B3 + + ScSimpleFormulaCalculator aFCell1( m_pDoc, ScAddress(0,0,0), "=B1:B3", true ); + FormulaError nErrCode = aFCell1.GetErrCode(); + CPPUNIT_ASSERT( nErrCode == FormulaError::NONE || aFCell1.IsMatrix() ); + CPPUNIT_ASSERT_EQUAL( OUString("{1;#DIV/0!;#NAME?}"), aFCell1.GetString().getString() ); + + m_pDoc->SetString(ScAddress(1,0,0), "=NA()"); // B1 + m_pDoc->SetString(ScAddress(1,1,0), "2"); // B2 + m_pDoc->SetString(ScAddress(1,2,0), "=1+2"); // B3 + ScSimpleFormulaCalculator aFCell2( m_pDoc, ScAddress(0,0,0), "=B1:B3", true ); + nErrCode = aFCell2.GetErrCode(); + CPPUNIT_ASSERT( nErrCode == FormulaError::NONE || aFCell2.IsMatrix() ); + CPPUNIT_ASSERT_EQUAL( OUString("{#N/A;2;3}"), aFCell2.GetString().getString() ); + + m_pDoc->DeleteTab(0); +} + +void Test::testSetStringAndNote() +{ + m_pDoc->InsertTab(0, "Test"); + + // We need a drawing layer in order to create caption objects. + m_pDoc->InitDrawLayer(&getDocShell()); + + //note on A1 + ScAddress aAdrA1 (0, 0, 0); + ScPostIt* pNote = m_pDoc->GetOrCreateNote(aAdrA1); + pNote->SetText(aAdrA1, "Hello world in A1"); + + m_pDoc->SetString(0, 0, 0, ""); + + pNote = m_pDoc->GetNote(aAdrA1); + CPPUNIT_ASSERT(pNote); + + m_pDoc->DeleteTab(0); +} + +void Test::testCopyPasteMatrixFormula() +{ + m_pDoc->InsertTab(0, "hcv"); + + // Set Values to B1, C1, D1 + m_pDoc->SetValue(ScAddress(1,0,0), 2.0); // B1 + m_pDoc->SetValue(ScAddress(2,0,0), 5.0); // C1 + m_pDoc->SetValue(ScAddress(3,0,0), 3.0); // D1 + + // Set Values to B2, C2 + m_pDoc->SetString(ScAddress(1,1,0), "B2"); // B2 + //m_pDoc->SetString(ScAddress(2,1,0), "C2"); // C2 + m_pDoc->SetString(ScAddress(3,1,0), "D2"); // D2 + + // Set Values to D3 + //m_pDoc->SetValue(ScAddress(1,2,0), 9.0); // B3 + //m_pDoc->SetString(ScAddress(2,2,0), "C3"); // C3 + m_pDoc->SetValue(ScAddress(3,2,0), 11.0); // D3 + + // Insert matrix formula to A1 + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + m_pDoc->InsertMatrixFormula(0, 0, 0, 0, aMark, "=COUNTIF(ISBLANK(B1:D1);TRUE())"); + m_pDoc->CalcAll(); + // A1 should contain 0 + CPPUNIT_ASSERT_EQUAL( 0.0, m_pDoc->GetValue(ScAddress(0,0,0)) ); // A1 + + // Copy cell A1 to clipboard. + ScAddress aPos(0,0,0); // A1 + ScDocument aClipDoc(SCDOCMODE_CLIP); + ScClipParam aParam(aPos, false); + m_pDoc->CopyToClip(aParam, &aClipDoc, &aMark, false, false); + // Formula string should be equal. + CPPUNIT_ASSERT_EQUAL(m_pDoc->GetString(aPos), aClipDoc.GetString(aPos)); + + // First try single range. + // Paste matrix formula to A2 + pasteFromClip(m_pDoc, ScRange(0,1,0,0,1,0), &aClipDoc); // A2 + // A2 Cell value should contain 1.0 + CPPUNIT_ASSERT_EQUAL( 1.0, m_pDoc->GetValue(ScAddress(0,1,0))); + + // Paste matrix formula to A3 + pasteFromClip(m_pDoc, ScRange(0,2,0,0,2,0), &aClipDoc); // A3 + // A3 Cell value should contain 2.0 + CPPUNIT_ASSERT_EQUAL( 2.0, m_pDoc->GetValue(ScAddress(0,2,0))); + + // Paste matrix formula to A4 + pasteFromClip(m_pDoc, ScRange(0,3,0,0,3,0), &aClipDoc); // A4 + // A4 Cell value should contain 3.0 + CPPUNIT_ASSERT_EQUAL( 3.0, m_pDoc->GetValue(ScAddress(0,3,0))); + + // Clear cell A2:A4 + clearRange(m_pDoc, ScRange(0,1,0,0,3,0)); + + // Paste matrix formula to range A2:A4 + pasteFromClip(m_pDoc, ScRange(0,1,0,0,3,0), &aClipDoc); // A2:A4 + + // A2 Cell value should contain 1.0 + CPPUNIT_ASSERT_EQUAL( 1.0, m_pDoc->GetValue(ScAddress(0,1,0))); + // A3 Cell value should contain 2.0 + CPPUNIT_ASSERT_EQUAL( 2.0, m_pDoc->GetValue(ScAddress(0,2,0))); + // A4 Cell value should contain 3.0 + CPPUNIT_ASSERT_EQUAL( 3.0, m_pDoc->GetValue(ScAddress(0,3,0))); + + m_pDoc->DeleteTab(0); +} + +void Test::testUndoDataAnchor() +{ + m_pDoc->InsertTab(0, "Tab1"); + CPPUNIT_ASSERT_EQUAL_MESSAGE("There should be only 1 sheets to begin with", + static_cast<SCTAB>(1), m_pDoc->GetTableCount()); + + m_pDoc->InitDrawLayer(); + ScDrawLayer* pDrawLayer = m_pDoc->GetDrawLayer(); + CPPUNIT_ASSERT_MESSAGE("No drawing layer.", pDrawLayer); + SdrPage* pPage = pDrawLayer->GetPage(0); + CPPUNIT_ASSERT_MESSAGE("No page instance for the 1st sheet.", pPage); + + // Insert an object. + tools::Rectangle aObjRect(2,1000,100,1100); + SdrObject* pObj = new SdrRectObj(*pDrawLayer, aObjRect); + pPage->InsertObject(pObj); + ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *m_pDoc, 0, false); + + // Get anchor data + ScDrawObjData* pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + + ScAddress aOldStart = pData->maStart; + ScAddress aOldEnd = pData->maEnd; + + // Get non rotated anchor data + ScDrawObjData* pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + + ScAddress aNOldStart = pNData->maStart; + ScAddress aNOldEnd = pNData->maEnd; + CPPUNIT_ASSERT_EQUAL(aOldStart, aNOldStart); + CPPUNIT_ASSERT_EQUAL(aOldEnd, aNOldEnd); + + //pDrawLayer->BeginCalcUndo(false); + // Insert a new row at row 3. + ScDocFunc& rFunc = getDocShell().GetDocFunc(); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + rFunc.InsertCells(ScRange( 0, aOldStart.Row() - 1, 0, MAXCOL, aOldStart.Row(), 0 ), &aMark, INS_INSROWS_BEFORE, true, true); + + pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + + ScAddress aNewStart = pData->maStart; + ScAddress aNewEnd = pData->maEnd; + + // Get non rotated anchor data + pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + + ScAddress aNNewStart = pNData->maStart; + ScAddress aNNewEnd = pNData->maEnd; + CPPUNIT_ASSERT_EQUAL(aNewStart, aNNewStart); + CPPUNIT_ASSERT_EQUAL(aNewEnd, aNNewEnd); + CPPUNIT_ASSERT_MESSAGE("Failed to compare Address.", aNewStart != aOldStart && aNewEnd != aOldEnd && + aNNewStart != aNOldStart && aNNewEnd != aNOldEnd ); + + SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager(); + CPPUNIT_ASSERT(pUndoMgr); + pUndoMgr->Undo(); + + // Check state + ScAnchorType oldType = ScDrawLayer::GetAnchorType(*pObj); + CPPUNIT_ASSERT_EQUAL_MESSAGE( "Failed to check state SCA_CELL.", SCA_CELL, oldType); + + // Get anchor data + pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + + // Get non rotated anchor data + pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + + // Check if data has moved to new rows + CPPUNIT_ASSERT_EQUAL(pData->maStart, aOldStart); + CPPUNIT_ASSERT_EQUAL(pData->maEnd, aOldEnd); + + CPPUNIT_ASSERT_EQUAL(pNData->maStart, aNOldStart); + CPPUNIT_ASSERT_EQUAL(pNData->maEnd, aNOldEnd); + + pUndoMgr->Redo(); + + // Get anchor data + pData = ScDrawLayer::GetObjData(pObj); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve user data for this object.", pData); + + // Get non rotated anchor data + pNData = ScDrawLayer::GetNonRotatedObjData( pObj ); + CPPUNIT_ASSERT_MESSAGE("Failed to retrieve non rotated user data for this object.", pNData); + + // Check if data has moved to new rows + CPPUNIT_ASSERT_EQUAL(pData->maStart, aNewStart); + CPPUNIT_ASSERT_EQUAL(pData->maEnd, aNewEnd); + + CPPUNIT_ASSERT_EQUAL(pNData->maStart, aNNewStart); + CPPUNIT_ASSERT_EQUAL(pNData->maEnd, aNNewEnd); + + m_pDoc->DeleteTab(0); +} + + +void Test::testEmptyCalcDocDefaults() +{ + CPPUNIT_ASSERT_EQUAL( sal_uLong(0), m_pDoc->GetCellCount() ); + CPPUNIT_ASSERT_EQUAL( sal_uLong(0), m_pDoc->GetFormulaGroupCount() ); + CPPUNIT_ASSERT_EQUAL( sal_uLong(0), m_pDoc->GetCodeCount() ); + CPPUNIT_ASSERT_EQUAL( int(CharCompressType::NONE), static_cast<int>(m_pDoc->GetAsianCompression()) ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->HasPrintRange() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsInVBAMode() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->HasNotes() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsCutMode() ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsEmbedFonts() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsEmbedUsedFontsOnly() ); + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsEmbedFontScriptLatin() ); + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsEmbedFontScriptAsian() ); + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsEmbedFontScriptComplex() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsEmbedded() ); + + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsDocEditable() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsDocProtected() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsDocVisible() ); + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsUserInteractionEnabled() ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->HasAnyCalcNotification() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsAutoCalcShellDisabled() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsForcedFormulaPending() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsCalculatingFormulaTree() ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsClipOrUndo() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsClipboard() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsUndo() ); + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsUndoEnabled() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsCutMode() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsClipboardSource() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsInsertingFromOtherDoc() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->PastingDrawFromOtherDoc() ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsAdjustHeightLocked() ); + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsExecuteLinkEnabled() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsChangeReadOnlyEnabled() ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IdleCalcTextWidth() ); + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsIdleEnabled() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsDetectiveDirty() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->HasLinkFormulaNeedingCheck() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsChartListenerCollectionNeedsUpdate() ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->HasRangeOverflow() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsImportingXML() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsCalcingAfterLoad() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->GetNoListening() ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsValidAsianCompression() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->GetAsianKerning() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsValidAsianKerning() ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsInInterpreter() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsInInterpreterTableOp() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsInDtorClear() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsExpandRefs() ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsInLinkUpdate() ); + + SCTAB tab = m_pDoc->GetVisibleTab(); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsVisible(tab) ); + CPPUNIT_ASSERT_EQUAL( true, m_pDoc->IsDefaultTabBgColor(tab) ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->HasTable(tab) ); + + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->IsActiveScenario(tab) ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->HasCalcNotification(tab) ); + CPPUNIT_ASSERT_EQUAL( false, m_pDoc->HasManualBreaks(tab) ); +} + +ScDocShell* Test::findLoadedDocShellByName(const OUString& rName) +{ + ScDocShell* pShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>, false)); + while (pShell) + { + SfxMedium* pMedium = pShell->GetMedium(); + if (pMedium) + { + OUString aName = pMedium->GetName(); + if (aName == rName) + return pShell; + } + pShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pShell, checkSfxObjectShell<ScDocShell>, false)); + } + return nullptr; +} + +bool Test::insertRangeNames( + ScDocument* pDoc, ScRangeName* pNames, const RangeNameDef* p, const RangeNameDef* pEnd) +{ + ScAddress aA1(0, 0, 0); + for (; p != pEnd; ++p) + { + ScRangeData* pNew = new ScRangeData( + pDoc, + OUString::createFromAscii(p->mpName), + OUString::createFromAscii(p->mpExpr), + aA1, ScRangeData::Type::Name, + formula::FormulaGrammar::GRAM_ENGLISH); + pNew->SetIndex(p->mnIndex); + bool bSuccess = pNames->insert(pNew); + if (!bSuccess) + { + cerr << "Insertion failed." << endl; + return false; + } + } + + return true; +} + +void Test::printRange(ScDocument* pDoc, const ScRange& rRange, const char* pCaption) +{ + SCROW nRow1 = rRange.aStart.Row(), nRow2 = rRange.aEnd.Row(); + SCCOL nCol1 = rRange.aStart.Col(), nCol2 = rRange.aEnd.Col(); + svl::GridPrinter printer(nRow2 - nRow1 + 1, nCol2 - nCol1 + 1, CALC_DEBUG_OUTPUT != 0); + for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow) + { + for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol) + { + ScAddress aPos(nCol, nRow, rRange.aStart.Tab()); + ScRefCellValue aCell(*pDoc, aPos); + OUString aVal = ScCellFormat::GetOutputString(*pDoc, aPos, aCell); + printer.set(nRow-nRow1, nCol-nCol1, aVal); + } + } + printer.print(pCaption); +} + +void Test::clearRange(ScDocument* pDoc, const ScRange& rRange) +{ + ScMarkData aMarkData(MAXROW, MAXCOL); + aMarkData.SetMarkArea(rRange); + pDoc->DeleteArea( + rRange.aStart.Col(), rRange.aStart.Row(), + rRange.aEnd.Col(), rRange.aEnd.Row(), aMarkData, InsertDeleteFlags::CONTENTS); +} + +void Test::clearSheet(ScDocument* pDoc, SCTAB nTab) +{ + ScRange aRange(0,0,nTab,MAXCOL,MAXROW,nTab); + clearRange(pDoc, aRange); +} + +ScUndoCut* Test::cutToClip(ScDocShell& rDocSh, const ScRange& rRange, ScDocument* pClipDoc, bool bCreateUndo) +{ + ScDocument* pSrcDoc = &rDocSh.GetDocument(); + + ScClipParam aClipParam(rRange, true); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(rRange); + pSrcDoc->CopyToClip(aClipParam, pClipDoc, &aMark, false, false); + + // Taken from ScViewFunc::CutToClip() + ScDocumentUniquePtr pUndoDoc; + if (bCreateUndo) + { + pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO )); + pUndoDoc->InitUndoSelected( pSrcDoc, aMark ); + // all sheets - CopyToDocument skips those that don't exist in pUndoDoc + ScRange aCopyRange = rRange; + aCopyRange.aStart.SetTab(0); + aCopyRange.aEnd.SetTab(pSrcDoc->GetTableCount()-1); + pSrcDoc->CopyToDocument( aCopyRange, + (InsertDeleteFlags::ALL & ~InsertDeleteFlags::OBJECTS) | InsertDeleteFlags::NOCAPTIONS, + false, *pUndoDoc ); + } + + aMark.MarkToMulti(); + pSrcDoc->DeleteSelection( InsertDeleteFlags::ALL, aMark ); + aMark.MarkToSimple(); + + if (pUndoDoc) + return new ScUndoCut( &rDocSh, rRange, rRange.aEnd, aMark, std::move(pUndoDoc) ); + + return nullptr; +} + +void Test::copyToClip(ScDocument* pSrcDoc, const ScRange& rRange, ScDocument* pClipDoc) +{ + ScClipParam aClipParam(rRange, false); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(rRange); + pSrcDoc->CopyToClip(aClipParam, pClipDoc, &aMark, false, false); +} + +void Test::pasteFromClip(ScDocument* pDestDoc, const ScRange& rDestRange, ScDocument* pClipDoc) +{ + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(rDestRange); + pDestDoc->CopyFromClip(rDestRange, aMark, InsertDeleteFlags::ALL, nullptr, pClipDoc); +} + +void Test::pasteOneCellFromClip(ScDocument* pDestDoc, const ScRange& rDestRange, ScDocument* pClipDoc, InsertDeleteFlags eFlags) +{ + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SetMarkArea(rDestRange); + sc::CopyFromClipContext aCxt(*pDestDoc, nullptr, pClipDoc, eFlags, false, false); + aCxt.setDestRange(rDestRange.aStart.Col(), rDestRange.aStart.Row(), + rDestRange.aEnd.Col(), rDestRange.aEnd.Row()); + aCxt.setTabRange(rDestRange.aStart.Tab(), rDestRange.aEnd.Tab()); + pDestDoc->CopyOneCellFromClip(aCxt, rDestRange.aStart.Col(), rDestRange.aStart.Row(), + rDestRange.aEnd.Col(), rDestRange.aEnd.Row()); +} + +ScUndoPaste* Test::createUndoPaste(ScDocShell& rDocSh, const ScRange& rRange, ScDocumentUniquePtr pUndoDoc) +{ + ScDocument& rDoc = rDocSh.GetDocument(); + ScMarkData aMarkData(MAXROW, MAXCOL); + aMarkData.SetMarkArea(rRange); + std::unique_ptr<ScRefUndoData> pRefUndoData(new ScRefUndoData(&rDoc)); + + return new ScUndoPaste( + &rDocSh, rRange, aMarkData, std::move(pUndoDoc), nullptr, InsertDeleteFlags::ALL, std::move(pRefUndoData), false); +} + +void Test::setExpandRefs(bool bExpand) +{ + ScModule* pMod = SC_MOD(); + ScInputOptions aOpt = pMod->GetInputOptions(); + aOpt.SetExpandRefs(bExpand); + pMod->SetInputOptions(aOpt); +} + +void Test::setCalcAsShown(ScDocument* pDoc, bool bCalcAsShown) +{ + ScDocOptions aOpt = pDoc->GetDocOptions(); + aOpt.SetCalcAsShown(bCalcAsShown); + pDoc->SetDocOptions(aOpt); +} + +void Test::checkPrecisionAsShown( OUString& rCode, double fValue, double fExpectedRoundVal ) +{ + SvNumberFormatter* pFormatter = m_pDoc->GetFormatTable(); + sal_uInt32 nFormat = pFormatter->GetEntryKey( rCode ); + if ( nFormat == NUMBERFORMAT_ENTRY_NOT_FOUND ) + { + sal_Int32 nCheckPos = 0; + SvNumFormatType nType; + pFormatter->PutEntry( rCode, nCheckPos, nType, nFormat ); + CPPUNIT_ASSERT_EQUAL( sal_Int32(0), nCheckPos ); + } + double fRoundValue = m_pDoc->RoundValueAsShown( fValue, nFormat ); + OString aMessage = "Format \"" + + OUStringToOString( rCode, RTL_TEXTENCODING_ASCII_US ) + + "\" is not correctly rounded"; + CPPUNIT_ASSERT_EQUAL_MESSAGE( aMessage.getStr(), fExpectedRoundVal, fRoundValue ); +} + +ScRange Test::insertRangeData( + ScDocument* pDoc, const ScAddress& rPos, const std::vector<std::vector<const char*>>& rData ) +{ + if (rData.empty()) + return ScRange(ScAddress::INITIALIZE_INVALID); + + ScAddress aPos = rPos; + + SCCOL nColWidth = 1; + for (const std::vector<const char*>& rRow : rData) + nColWidth = std::max<SCCOL>(nColWidth, rRow.size()); + + ScRange aRange(aPos); + aRange.aEnd.IncCol(nColWidth-1); + aRange.aEnd.IncRow(rData.size()-1); + + clearRange(pDoc, aRange); + + for (const std::vector<const char*>& rRow : rData) + { + aPos.SetCol(rPos.Col()); + + for (const char* pStr : rRow) + { + if (!pStr) + { + aPos.IncCol(); + continue; + } + + OUString aStr(pStr, strlen(pStr), RTL_TEXTENCODING_UTF8); + + ScSetStringParam aParam; // Leave default. + aParam.meStartListening = sc::NoListening; + pDoc->SetString(aPos, aStr, &aParam); + + aPos.IncCol(); + } + + aPos.IncRow(); + } + + pDoc->StartAllListeners(aRange); + printRange(pDoc, aRange, "Range data content"); + return aRange; +} + +void Test::testPrecisionAsShown() +{ + m_pDoc->InsertTab(0, "Test"); + + // Turn on "precision as shown" option. + setCalcAsShown( m_pDoc, true); + + OUString aCode; + double fValue, fExpectedRoundVal; + { // decimal rounding + aCode = "0.00"; + fValue = 1.0/3.0; + fExpectedRoundVal = 0.33; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 10.001; + fExpectedRoundVal = 10.0; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + } + { // thousand rounding tdf#106253 + aCode = "0,,"; + fValue = 4.0e9 / 7.0; + fExpectedRoundVal = 571e6; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + aCode = "\"k\"[$$-409]* #,;[RED]-\"k\"[$$-409]* #,"; + fValue = 4.0e8 / 7.0; + fExpectedRoundVal = 57.143e6; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + } + { // percent rounding + aCode = "0.00%"; + fValue = 4.0 / 7.0; + fExpectedRoundVal = 0.5714; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 40.0 / 7.0; + fExpectedRoundVal = 5.7143; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + } + { // scientific rounding + aCode = "0.00E0"; + fValue = 400000.0 / 7.0; + fExpectedRoundVal = 57100.0; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4.0 / 70000.0; + fExpectedRoundVal = 5.71e-5; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + // engineering rounding tdf#106252 + aCode = "##0.000E0"; + fValue = 400000.0 / 7.0; + fExpectedRoundVal = 57.143e3; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4000000.0 / 7.0; + fExpectedRoundVal = 571.429e3; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 40000000.0 / 7.0; + fExpectedRoundVal = 5.714e6; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4.0 / 70000.0; + fExpectedRoundVal = 57.143e-6; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4.0 / 7000.0; + fExpectedRoundVal = 571.429e-6; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4.0 / 700.0; + fExpectedRoundVal = 5.714e-3; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + aCode = "##?0.0#E0"; + fValue = 400000.0 / 7.0; + fExpectedRoundVal = 5.71e4; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4000000.0 / 7.0; + fExpectedRoundVal = 57.14e4; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 40000000.0 / 7.0; + fExpectedRoundVal = 571.43e4; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 400000000.0 / 7.0; + fExpectedRoundVal = 5714.29e4; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4.0 / 70000.0; + fExpectedRoundVal = 5714.29e-8; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4.0 / 7000.0; + fExpectedRoundVal = 5.71e-4; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4.0 / 700.0; + fExpectedRoundVal = 57.14e-4; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + fValue = 4.0 / 70.0; + fExpectedRoundVal = 571.43e-4; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + } + { // fraction rounding tdf#105657 + aCode = "# ?/?"; + fValue = 0.35; + fExpectedRoundVal = 1.0/3.0; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + } + { // exact fraction + aCode = "# ?/??"; + fValue = 0.35; + fExpectedRoundVal = 0.35; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + checkPrecisionAsShown( aCode, -fValue, -fExpectedRoundVal ); + } + { // several sub-formats tdf#106052 + aCode = "0.00;-0.000"; + fValue = 1.0/3.0; + fExpectedRoundVal = 0.33; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + fValue = -1.0/3.0; + fExpectedRoundVal = -0.333; + checkPrecisionAsShown( aCode, fValue, fExpectedRoundVal ); + } + + setCalcAsShown( m_pDoc, false); + m_pDoc->DeleteTab(0); +} + +void Test::testProtectedSheetEditByRow() +{ + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + m_pDoc->InsertTab(0, "Protected"); + + { + // Remove protected flags from rows 2-5. + ScPatternAttr aAttr(m_pDoc->GetPool()); + aAttr.GetItemSet().Put(ScProtectionAttr(false)); + m_pDoc->ApplyPatternAreaTab(0, 1, MAXCOL, 4, 0, aAttr); + + // Protect the sheet without any options. + ScTableProtection aProtect; + aProtect.setProtected(true); + m_pDoc->SetTabProtection(0, &aProtect); + + // Try to delete row 3. It should fail. + ScRange aRow3(0,2,0,MAXCOL,2,0); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + bool bDeleted = rDocFunc.DeleteCells(aRow3, &aMark, DelCellCmd::Rows, true); + CPPUNIT_ASSERT_MESSAGE("deletion of row 3 should fail.", !bDeleted); + + // Protect the sheet but allow row deletion. + aProtect.setOption(ScTableProtection::DELETE_ROWS, true); + m_pDoc->SetTabProtection(0, &aProtect); + + // Now we should be able to delete row 3. + bDeleted = rDocFunc.DeleteCells(aRow3, &aMark, DelCellCmd::Rows, true); + CPPUNIT_ASSERT_MESSAGE("deletion of row 3 should succeed.", bDeleted); + + // But, row deletion should still fail on a protected row. + ScRange aRow10(0,9,0,MAXCOL,9,0); + bDeleted = rDocFunc.DeleteCells(aRow10, &aMark, DelCellCmd::Rows, true); + CPPUNIT_ASSERT_MESSAGE("deletion of row 10 should not be allowed.", !bDeleted); + + // Try inserting a new row. It should fail. + bool bInserted = rDocFunc.InsertCells(aRow3, &aMark, INS_INSROWS_AFTER, true, true); + CPPUNIT_ASSERT_MESSAGE("row insertion at row 3 should fail.", !bInserted); + + // Allow row insertions. + aProtect.setOption(ScTableProtection::INSERT_ROWS, true); + m_pDoc->SetTabProtection(0, &aProtect); + + bInserted = rDocFunc.InsertCells(aRow3, &aMark, INS_INSROWS_AFTER, true, true); + CPPUNIT_ASSERT_MESSAGE("row insertion at row 3 should succeed.", bInserted); + + // Row insertion is allowed even when the rows above and below have protected flags set. + bInserted = rDocFunc.InsertCells(aRow10, &aMark, INS_INSROWS_AFTER, true, true); + CPPUNIT_ASSERT_MESSAGE("row insertion at row 10 should succeed.", bInserted); + } + + m_pDoc->InsertTab(1, "Matrix"); // This sheet is unprotected. + + { + // Insert matrix into B2:C3. + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(1); + m_pDoc->InsertMatrixFormula(1, 1, 2, 2, aMark, "={1;2|3;4}"); + + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(1,1,1))); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(2,1,1))); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(1,2,1))); + CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(2,2,1))); + + // Try to insert a row at row 3. It should fail because of matrix's presence. + + ScRange aRow3(0,2,1,MAXCOL,2,1); + bool bInserted = rDocFunc.InsertCells(aRow3, &aMark, INS_INSROWS_BEFORE, true, true); + CPPUNIT_ASSERT_MESSAGE("row insertion at row 3 should fail.", !bInserted); + } + + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +void Test::testProtectedSheetEditByColumn() +{ + ScDocFunc& rDocFunc = getDocShell().GetDocFunc(); + m_pDoc->InsertTab(0, "Protected"); + + { + // Remove protected flags from columns B to E. + ScPatternAttr aAttr(m_pDoc->GetPool()); + aAttr.GetItemSet().Put(ScProtectionAttr(false)); + m_pDoc->ApplyPatternAreaTab(1, 0, 4, MAXROW, 0, aAttr); + + // Protect the sheet without any options. + ScTableProtection aProtect; + aProtect.setProtected(true); + m_pDoc->SetTabProtection(0, &aProtect); + + // Try to delete column C. It should fail. + ScRange aCol3(2,0,0,2,MAXROW,0); + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(0); + bool bDeleted = rDocFunc.DeleteCells(aCol3, &aMark, DelCellCmd::Cols, true); + CPPUNIT_ASSERT_MESSAGE("deletion of column 3 should fail.", !bDeleted); + + // Protect the sheet but allow column deletion. + aProtect.setOption(ScTableProtection::DELETE_COLUMNS, true); + m_pDoc->SetTabProtection(0, &aProtect); + + // Now we should be able to delete column C. + bDeleted = rDocFunc.DeleteCells(aCol3, &aMark, DelCellCmd::Cols, true); + CPPUNIT_ASSERT_MESSAGE("deletion of column 3 should succeed.", bDeleted); + + // But, column deletion should still fail on a protected column. + ScRange aCol10(9,0,0,9,MAXROW,0); + bDeleted = rDocFunc.DeleteCells(aCol10, &aMark, DelCellCmd::Cols, true); + CPPUNIT_ASSERT_MESSAGE("deletion of column 10 should not be allowed.", !bDeleted); + + // Try inserting a new column. It should fail. + bool bInserted = rDocFunc.InsertCells(aCol3, &aMark, INS_INSCOLS_AFTER, true, true); + CPPUNIT_ASSERT_MESSAGE("column insertion at column 3 should fail.", !bInserted); + + // Allow column insertions. + aProtect.setOption(ScTableProtection::INSERT_COLUMNS, true); + m_pDoc->SetTabProtection(0, &aProtect); + + bInserted = rDocFunc.InsertCells(aCol3, &aMark, INS_INSCOLS_AFTER, true, true); + CPPUNIT_ASSERT_MESSAGE("column insertion at column 3 should succeed.", bInserted); + + // Column insertion is allowed even when the columns above and below have protected flags set. + bInserted = rDocFunc.InsertCells(aCol10, &aMark, INS_INSCOLS_AFTER, true, true); + CPPUNIT_ASSERT_MESSAGE("column insertion at column 10 should succeed.", bInserted); + } + + m_pDoc->InsertTab(1, "Matrix"); // This sheet is unprotected. + + { + // Insert matrix into B2:C3. + ScMarkData aMark(MAXROW, MAXCOL); + aMark.SelectOneTable(1); + m_pDoc->InsertMatrixFormula(1, 1, 2, 2, aMark, "={1;2|3;4}"); + + CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(1,1,1))); + CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(2,1,1))); + CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(1,2,1))); + CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(2,2,1))); + + // Try to insert a column at column C. It should fail because of matrix's presence. + + ScRange aCol3(2,0,1,2,MAXROW,1); + bool bInserted = rDocFunc.InsertCells(aCol3, &aMark, INS_INSCOLS_BEFORE, true, true); + CPPUNIT_ASSERT_MESSAGE("column insertion at column C should fail.", !bInserted); + } + + m_pDoc->DeleteTab(1); + m_pDoc->DeleteTab(0); +} + +CPPUNIT_TEST_SUITE_REGISTRATION(Test); + +CPPUNIT_PLUGIN_IMPLEMENT(); + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |