Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 9179 insertions, 0 deletions

diff --git a/sc/qa/unit/ucalc_formula.cxx b/sc/qa/unit/ucalc_formula.cxx
new file mode 100644
index 000000000..332da1efe
--- /dev/null
+++ b/sc/qa/unit/ucalc_formula.cxx
@@ -0,0 +1,9179 @@
+/* -*- 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 <markdata.hxx>
+#include <calcconfig.hxx>
+#include <clipparam.hxx>
+#include <compiler.hxx>
+#include <tokenarray.hxx>
+#include <refdata.hxx>
+#include <scopetools.hxx>
+#include <formulacell.hxx>
+#include <docsh.hxx>
+#include <docfunc.hxx>
+#include <paramisc.hxx>
+#include <tokenstringcontext.hxx>
+#include <refupdatecontext.hxx>
+#include <dbdata.hxx>
+#include <scmatrix.hxx>
+#include <validat.hxx>
+#include <scitems.hxx>
+#include <patattr.hxx>
+#include <docpool.hxx>
+#include <docoptio.hxx>
+#include <formulaopt.hxx>
+#include <externalrefmgr.hxx>
+#include <svl/itemset.hxx>
+
+#include <formula/vectortoken.hxx>
+#include <svl/broadcast.hxx>
+#include <svl/intitem.hxx>
+#include <sfx2/docfile.hxx>
+
+#include <memory>
+#include <functional>
+#include <set>
+#include <algorithm>
+
+using namespace formula;
+
+namespace {
+
+ScRange getCachedRange(const ScExternalRefCache::TableTypeRef& pCacheTab)
+{
+    ScRange aRange;
+
+    vector<SCROW> aRows;
+    pCacheTab->getAllRows(aRows);
+    bool bFirst = true;
+    for (const SCROW nRow : aRows)
+    {
+        vector<SCCOL> aCols;
+        pCacheTab->getAllCols(nRow, aCols);
+        for (const SCCOL nCol : aCols)
+        {
+            if (bFirst)
+            {
+                aRange.aStart = ScAddress(nCol, nRow, 0);
+                aRange.aEnd = aRange.aStart;
+                bFirst = false;
+            }
+            else
+            {
+                if (nCol < aRange.aStart.Col())
+                    aRange.aStart.SetCol(nCol);
+                else if (aRange.aEnd.Col() < nCol)
+                    aRange.aEnd.SetCol(nCol);
+
+                if (nRow < aRange.aStart.Row())
+                    aRange.aStart.SetRow(nRow);
+                else if (aRange.aEnd.Row() < nRow)
+                    aRange.aEnd.SetRow(nRow);
+            }
+        }
+    }
+    return aRange;
+}
+
+}
+
+void Test::testFormulaCreateStringFromTokens()
+{
+    // Insert sheets.
+    OUString const aTabName1("Test");
+    OUString const aTabName2("Kevin's Data");
+    OUString const aTabName3("Past Data");
+    OUString const aTabName4("2013");
+    m_pDoc->InsertTab(0, aTabName1);
+    m_pDoc->InsertTab(1, aTabName2);
+    m_pDoc->InsertTab(2, aTabName3);
+    m_pDoc->InsertTab(3, aTabName4);
+
+    // Insert named ranges.
+    static const struct {
+        bool bGlobal;
+        const char* pName;
+        const char* pExpr;
+    } aNames[] = {
+        { true, "x", "Test.H1" },
+        { true, "y", "Test.H2" },
+        { true, "z", "Test.H3" },
+
+        { false, "sheetx", "Test.J1" }
+    };
+
+    ScRangeName* pGlobalNames = m_pDoc->GetRangeName();
+    ScRangeName* pSheetNames = m_pDoc->GetRangeName(0);
+    CPPUNIT_ASSERT_MESSAGE("Failed to obtain global named expression object.", pGlobalNames);
+    CPPUNIT_ASSERT_MESSAGE("Failed to obtain sheet-local named expression object.", pSheetNames);
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i)
+    {
+        ScRangeData* pName = new ScRangeData(
+            m_pDoc, OUString::createFromAscii(aNames[i].pName), OUString::createFromAscii(aNames[i].pExpr),
+            ScAddress(0,0,0), ScRangeData::Type::Name, formula::FormulaGrammar::GRAM_NATIVE);
+
+        if (aNames[i].bGlobal)
+        {
+            bool bInserted = pGlobalNames->insert(pName);
+            CPPUNIT_ASSERT_MESSAGE("Failed to insert a new name.", bInserted);
+        }
+        else
+        {
+            bool bInserted = pSheetNames->insert(pName);
+            CPPUNIT_ASSERT_MESSAGE("Failed to insert a new name.", bInserted);
+        }
+    }
+
+    // Insert DB ranges.
+    static const struct {
+        const char* pName;
+        SCTAB nTab;
+        SCCOL nCol1;
+        SCROW nRow1;
+        SCCOL nCol2;
+        SCROW nRow2;
+    } aDBs[] = {
+        { "Table1", 0, 0, 0, 10, 10 },
+        { "Table2", 1, 0, 0, 10, 10 },
+        { "Table3", 2, 0, 0, 10, 10 }
+    };
+
+    ScDBCollection* pDBs = m_pDoc->GetDBCollection();
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch DB collection object.", pDBs);
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aDBs); ++i)
+    {
+        std::unique_ptr<ScDBData> pData( new ScDBData(
+            OUString::createFromAscii(
+                aDBs[i].pName), aDBs[i].nTab, aDBs[i].nCol1, aDBs[i].nRow1, aDBs[i].nCol2,aDBs[i].nRow2) );
+        bool bInserted = pDBs->getNamedDBs().insert(std::move(pData));
+        CPPUNIT_ASSERT_MESSAGE(
+            OString(
+                OStringLiteral("Failed to insert \"") + aDBs[i].pName + "\"").getStr(),
+            bInserted);
+    }
+
+    const char* aTests[] = {
+        "1+2",
+        "SUM(A1:A10;B1:B10;C5;D6)",
+        "IF(Test.B10<>10;\"Good\";\"Bad\")",
+        "AVERAGE('2013'.B10:C20)",
+        "'Kevin''s Data'.B10",
+        "'Past Data'.B1+'2013'.B2*(1+'Kevin''s Data'.C10)",
+        "x+y*z", // named ranges
+        "SUM(sheetx;x;y;z)", // sheet local and global named ranges mixed
+        "MAX(Table1)+MIN(Table2)*SUM(Table3)", // database ranges
+        "{1;TRUE;3|FALSE;5;\"Text\"|;;}", // inline matrix
+        "SUM('file:///path/to/fake.file'#$Sheet.A1:B10)",
+    };
+    (void) aTests;
+
+    sc::TokenStringContext aCxt(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH);
+
+    // Artificially add external reference data after the context object is
+    // initialized.
+    aCxt.maExternalFileNames.emplace_back("file:///path/to/fake.file");
+    std::vector<OUString> aExtTabNames;
+    aExtTabNames.emplace_back("Sheet");
+    aCxt.maExternalCachedTabNames.emplace(0, aExtTabNames);
+
+    ScAddress aPos(0,0,0);
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aTests); ++i)
+    {
+#if 0
+        OUString aFormula = OUString::createFromAscii(aTests[i]);
+#endif
+        ScCompiler aComp(m_pDoc, aPos, FormulaGrammar::GRAM_ENGLISH);
+#if 0 // TODO: This call to CompileString() causes the cppunittester to somehow fail on Windows.
+        pArray.reset(aComp.CompileString(aFormula));
+        CPPUNIT_ASSERT_MESSAGE("Failed to compile formula string.", pArray.get());
+
+        OUString aCheck = pArray->CreateString(aCxt, aPos);
+        CPPUNIT_ASSERT_EQUAL(aFormula, aCheck);
+#endif
+    }
+
+    m_pDoc->DeleteTab(3);
+    m_pDoc->DeleteTab(2);
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+namespace {
+
+bool isEmpty( const formula::VectorRefArray& rArray, size_t nPos )
+{
+    if (rArray.mpStringArray)
+    {
+        if (rArray.mpStringArray[nPos])
+            return false;
+    }
+
+    if (rArray.mpNumericArray)
+        return std::isnan(rArray.mpNumericArray[nPos]);
+    else
+        return true;
+}
+
+bool equals( const formula::VectorRefArray& rArray, size_t nPos, double fVal )
+{
+    if (rArray.mpStringArray && rArray.mpStringArray[nPos])
+        // This is a string cell.
+        return false;
+
+    return rArray.mpNumericArray && rArray.mpNumericArray[nPos] == fVal;
+}
+
+bool equals( const formula::VectorRefArray& rArray, size_t nPos, const OUString& rVal )
+{
+    if (!rArray.mpStringArray)
+        return false;
+
+    bool bEquals = OUString(rArray.mpStringArray[nPos]).equalsIgnoreAsciiCase(rVal);
+    if (!bEquals)
+    {
+        cerr << "Expected: " << rVal.toAsciiUpperCase() << " (upcased)" << endl;
+        cerr << "Actual: " << OUString(rArray.mpStringArray[nPos]) << " (upcased)" << endl;
+    }
+    return bEquals;
+}
+
+}
+
+void Test::testFormulaParseReference()
+{
+    OUString aTab1("90's Music"), aTab2("90's and 70's"), aTab3("All Others"), aTab4("NoQuote");
+    m_pDoc->InsertTab(0, "Dummy"); // just to shift the sheet indices...
+    m_pDoc->InsertTab(1, aTab1); // name with a single quote.
+    m_pDoc->InsertTab(2, aTab2); // name with 2 single quotes.
+    m_pDoc->InsertTab(3, aTab3); // name without single quotes.
+    m_pDoc->InsertTab(4, aTab4); // name that doesn't require to be quoted.
+
+    OUString aTabName;
+    m_pDoc->GetName(1, aTabName);
+    CPPUNIT_ASSERT_EQUAL(aTab1, aTabName);
+    m_pDoc->GetName(2, aTabName);
+    CPPUNIT_ASSERT_EQUAL(aTab2, aTabName);
+    m_pDoc->GetName(3, aTabName);
+    CPPUNIT_ASSERT_EQUAL(aTab3, aTabName);
+    m_pDoc->GetName(4, aTabName);
+    CPPUNIT_ASSERT_EQUAL(aTab4, aTabName);
+
+    // Make sure the formula input and output match.
+    {
+        const char* aChecks[] = {
+            "'90''s Music'.B12",
+            "'90''s and 70''s'.$AB$100",
+            "'All Others'.Z$100",
+            "NoQuote.$C111"
+        };
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+        {
+            // Use the 'Dummy' sheet for this.
+            OUString aInput = "=" + OUString::createFromAscii(aChecks[i]);
+            m_pDoc->SetString(ScAddress(0,0,0), aInput);
+            ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,0,0), aChecks[i], "Wrong formula");
+        }
+    }
+
+    ScAddress aPos;
+    ScAddress::ExternalInfo aExtInfo;
+    ScRefFlags nRes = aPos.Parse("'90''s Music'.D10", m_pDoc, formula::FormulaGrammar::CONV_OOO, &aExtInfo);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(1), aPos.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(3), aPos.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(9), aPos.Row());
+    CPPUNIT_ASSERT_MESSAGE("This is not an external address.", !aExtInfo.mbExternal);
+
+    nRes = aPos.Parse("'90''s and 70''s'.C100", m_pDoc, formula::FormulaGrammar::CONV_OOO, &aExtInfo);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(2), aPos.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(2), aPos.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(99), aPos.Row());
+    CPPUNIT_ASSERT_MESSAGE("This is not an external address.", !aExtInfo.mbExternal);
+
+    nRes = aPos.Parse("'All Others'.B3", m_pDoc, formula::FormulaGrammar::CONV_OOO, &aExtInfo);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(3), aPos.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), aPos.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), aPos.Row());
+    CPPUNIT_ASSERT_MESSAGE("This is not an external address.", !aExtInfo.mbExternal);
+
+    nRes = aPos.Parse("NoQuote.E13", m_pDoc, formula::FormulaGrammar::CONV_OOO, &aExtInfo);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(4), aPos.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(4), aPos.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(12), aPos.Row());
+    CPPUNIT_ASSERT_MESSAGE("This is not an external address.", !aExtInfo.mbExternal);
+
+    ScRange aRange;
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse(":B", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("B:", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse(":B2", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("B2:", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse(":2", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("2:", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse(":2B", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("2B:", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("abc_foo:abc_bar", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("B1:B2~C1", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Should fail to parse.", !(nRes & ScRefFlags::VALID));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("B:B", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(0), aRange.aStart.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), aRange.aStart.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), aRange.aStart.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(0), aRange.aEnd.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), aRange.aEnd.Col());
+    CPPUNIT_ASSERT_EQUAL(m_pDoc->MaxRow(), aRange.aEnd.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                 ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                         ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::ZERO),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_ABS | ScRefFlags::COL2_ABS)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::ROW_ABS | ScRefFlags::ROW2_ABS),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::ROW_ABS | ScRefFlags::ROW2_ABS)));
+
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("2:2", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(0), aRange.aStart.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(0), aRange.aStart.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(1), aRange.aStart.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(0), aRange.aEnd.Tab());
+    CPPUNIT_ASSERT_EQUAL(m_pDoc->MaxCol(), aRange.aEnd.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(1), aRange.aEnd.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                 ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                         ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::ZERO),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::ROW_ABS | ScRefFlags::ROW2_ABS)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::COL_ABS | ScRefFlags::COL2_ABS),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_ABS | ScRefFlags::COL2_ABS)));
+
+    nRes = aRange.Parse("NoQuote.B:C", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(4), aRange.aStart.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), aRange.aStart.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), aRange.aStart.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(4), aRange.aEnd.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(2), aRange.aEnd.Col());
+    CPPUNIT_ASSERT_EQUAL(m_pDoc->MaxRow(), aRange.aEnd.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                 ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                         ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::ZERO),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_ABS | ScRefFlags::COL2_ABS)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::ROW_ABS | ScRefFlags::ROW2_ABS),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::ROW_ABS | ScRefFlags::ROW2_ABS)));
+
+    // Both rows at sheet bounds and relative => convert to absolute => entire column reference.
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("B1:B1048576", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(0), aRange.aStart.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), aRange.aStart.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), aRange.aStart.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(0), aRange.aEnd.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), aRange.aEnd.Col());
+    CPPUNIT_ASSERT_EQUAL(m_pDoc->MaxRow(), aRange.aEnd.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                 ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                         ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::ZERO),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_ABS | ScRefFlags::COL2_ABS)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::ROW_ABS | ScRefFlags::ROW2_ABS),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::ROW_ABS | ScRefFlags::ROW2_ABS)));
+
+    // Both columns at sheet bounds and relative => convert to absolute => entire row reference.
+    aRange.aStart.SetTab(0);
+    nRes = aRange.Parse("A2:AMJ2", m_pDoc, formula::FormulaGrammar::CONV_OOO);
+    CPPUNIT_ASSERT_MESSAGE("Failed to parse.", (nRes & ScRefFlags::VALID));
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(0), aRange.aStart.Tab());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(0), aRange.aStart.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(1), aRange.aStart.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCTAB>(0), aRange.aEnd.Tab());
+    CPPUNIT_ASSERT_EQUAL(m_pDoc->MaxCol(), aRange.aEnd.Col());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(1), aRange.aEnd.Row());
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                 ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_VALID | ScRefFlags::ROW_VALID | ScRefFlags::TAB_VALID |
+                                                         ScRefFlags::COL2_VALID | ScRefFlags::ROW2_VALID | ScRefFlags::TAB2_VALID)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::ZERO),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::ROW_ABS | ScRefFlags::ROW2_ABS)));
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(ScRefFlags::COL_ABS | ScRefFlags::COL2_ABS),
+                         static_cast<sal_uInt16>(nRes & (ScRefFlags::COL_ABS | ScRefFlags::COL2_ABS)));
+
+    // Check for reference input conversion to and display string of entire column/row.
+    {
+        const char* aChecks[][2] = {
+            { "=B:B",           "B:B" },
+            { "=B1:B1048576",   "B:B" },
+            { "=B1:B$1048576",  "B1:B$1048576" },
+            { "=B$1:B1048576",  "B$1:B1048576" },
+            { "=B$1:B$1048576", "B:B" },
+            { "=2:2",           "2:2" },
+            { "=A2:AMJ2",       "2:2" },
+            { "=A2:$AMJ2",      "A2:$AMJ2" },
+            { "=$A2:AMJ2",      "$A2:AMJ2" },
+            { "=$A2:$AMJ2",     "2:2" }
+        };
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+        {
+            // Use the 'Dummy' sheet for this.
+            m_pDoc->SetString(ScAddress(0,0,0), OUString::createFromAscii(aChecks[i][0]));
+            ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,0,0), aChecks[i][1], "Wrong formula");
+        }
+    }
+
+    m_pDoc->DeleteTab(4);
+    m_pDoc->DeleteTab(3);
+    m_pDoc->DeleteTab(2);
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFetchVectorRefArray()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    // All numeric cells in Column A.
+    m_pDoc->SetValue(ScAddress(0,0,0), 1);
+    m_pDoc->SetValue(ScAddress(0,1,0), 2);
+    m_pDoc->SetValue(ScAddress(0,2,0), 3);
+    m_pDoc->SetValue(ScAddress(0,3,0), 4);
+
+    formula::VectorRefArray aArray = m_pDoc->FetchVectorRefArray(ScAddress(0,0,0), 4);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array is expected to be numeric cells only.", !aArray.mpStringArray);
+    CPPUNIT_ASSERT_EQUAL(1.0, aArray.mpNumericArray[0]);
+    CPPUNIT_ASSERT_EQUAL(2.0, aArray.mpNumericArray[1]);
+    CPPUNIT_ASSERT_EQUAL(3.0, aArray.mpNumericArray[2]);
+    CPPUNIT_ASSERT_EQUAL(4.0, aArray.mpNumericArray[3]);
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(0,0,0), 5);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array is expected to be numeric cells only.", !aArray.mpStringArray);
+    CPPUNIT_ASSERT_EQUAL(1.0, aArray.mpNumericArray[0]);
+    CPPUNIT_ASSERT_EQUAL(2.0, aArray.mpNumericArray[1]);
+    CPPUNIT_ASSERT_EQUAL(3.0, aArray.mpNumericArray[2]);
+    CPPUNIT_ASSERT_EQUAL(4.0, aArray.mpNumericArray[3]);
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 4));
+
+    // All string cells in Column B.  Note that the fetched string arrays are
+    // only to be compared case-insensitively.  Right now, we use upper cased
+    // strings to achieve case-insensitive-ness, but that may change. So,
+    // don't count on that.
+    m_pDoc->SetString(ScAddress(1,0,0), "Andy");
+    m_pDoc->SetString(ScAddress(1,1,0), "Bruce");
+    m_pDoc->SetString(ScAddress(1,2,0), "Charlie");
+    m_pDoc->SetString(ScAddress(1,3,0), "David");
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(1,0,0), 5);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array is expected to be string cells only.", !aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 0, "Andy"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 1, "Bruce"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 2, "Charlie"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 3, "David"));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 4));
+
+    // Mixture of numeric, string, and empty cells in Column C.
+    m_pDoc->SetString(ScAddress(2,0,0), "Header");
+    m_pDoc->SetValue(ScAddress(2,1,0), 11);
+    m_pDoc->SetValue(ScAddress(2,2,0), 12);
+    m_pDoc->SetValue(ScAddress(2,3,0), 13);
+    m_pDoc->SetString(ScAddress(2,5,0), "=SUM(C2:C4)");
+    m_pDoc->CalcAll();
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(2,0,0), 7);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should have both numeric and string arrays.", aArray.mpNumericArray && aArray.mpStringArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 0, "Header"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 1, 11));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 2, 12));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 3, 13));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 4));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 5, 36));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 6));
+
+    // Mixed type again in Column D, but it starts with a numeric cell.
+    m_pDoc->SetValue(ScAddress(3,0,0), 10);
+    m_pDoc->SetString(ScAddress(3,1,0), "Below 10");
+    // Leave 2 empty cells.
+    m_pDoc->SetValue(ScAddress(3,4,0), 11);
+    m_pDoc->SetString(ScAddress(3,5,0), "=12");
+    m_pDoc->SetString(ScAddress(3,6,0), "=13");
+    m_pDoc->SetString(ScAddress(3,7,0), "=CONCATENATE(\"A\";\"B\";\"C\")");
+    m_pDoc->CalcAll();
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(3,0,0), 8);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should have both numeric and string arrays.", aArray.mpNumericArray && aArray.mpStringArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 0, 10));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 1, "Below 10"));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 2));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 3));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 4, 11));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 5, 12));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 6, 13));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 7, "ABC"));
+
+    // Column E consists of formula cells whose results are all numeric.
+    for (SCROW i = 0; i <= 6; ++i)
+        m_pDoc->SetString(ScAddress(4,i,0), "=ROW()");
+    m_pDoc->CalcAll();
+
+    // Leave row 7 empty.
+    m_pDoc->SetString(ScAddress(4,8,0), "Andy");
+    m_pDoc->SetValue(ScAddress(4,9,0), 123);
+
+    // This array fits within a single formula block.
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(4,0,0), 5);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should be purely numeric.", aArray.mpNumericArray && !aArray.mpStringArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 0, 1));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 1, 2));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 2, 3));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 3, 4));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 4, 5));
+
+    // This array spans over multiple blocks.
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(4,0,0), 11);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should have both numeric and string arrays.", aArray.mpNumericArray && aArray.mpStringArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 0, 1));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 1, 2));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 2, 3));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 3, 4));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 4, 5));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 5, 6));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 6, 7));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 7));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 8, "Andy"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 9, 123));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 10));
+
+    // Hit the cache but at a different start row.
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(4,2,0), 3);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should at least have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 0, 3));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 1, 4));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 2, 5));
+
+    // Column F begins with empty rows at the top.
+    m_pDoc->SetValue(ScAddress(5,2,0), 1.1);
+    m_pDoc->SetValue(ScAddress(5,3,0), 1.2);
+    m_pDoc->SetString(ScAddress(5,4,0), "=2*8");
+    m_pDoc->CalcAll();
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(5,2,0), 4);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should at least have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 0, 1.1));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 1, 1.2));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 2, 16));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 3));
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(5,0,0), 3);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should at least have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 0));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 1));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 2, 1.1));
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(5,0,0), 10);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should at least have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 0));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 1));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 2, 1.1));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 3, 1.2));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected numeric cell.", equals(aArray, 4, 16));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 5));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 6));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 7));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 8));
+    CPPUNIT_ASSERT_MESSAGE("This should be empty.", isEmpty(aArray, 9));
+
+    // Get the array for F3:F4. This array should only consist of numeric array.
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(5,2,0), 3);
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+
+    // Column G consists only of strings.
+    m_pDoc->SetString(ScAddress(6,0,0), "Title");
+    m_pDoc->SetString(ScAddress(6,1,0), "foo");
+    m_pDoc->SetString(ScAddress(6,2,0), "bar");
+    m_pDoc->SetString(ScAddress(6,3,0), "foo");
+    m_pDoc->SetString(ScAddress(6,4,0), "baz");
+    m_pDoc->SetString(ScAddress(6,5,0), "quack");
+    m_pDoc->SetString(ScAddress(6,6,0), "beep");
+    m_pDoc->SetString(ScAddress(6,7,0), "kerker");
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(6,1,0), 4); // G2:G5
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a numeric array.", !aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should have a string array.", aArray.mpStringArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 0, "foo"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 1, "bar"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 2, "foo"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 3, "baz"));
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(6,2,0), 4); // G3:G6
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a numeric array.", !aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should have a string array.", aArray.mpStringArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 0, "bar"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 1, "foo"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 2, "baz"));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 3, "quack"));
+
+    // Column H starts with formula cells.
+    for (SCROW i = 0; i < 10; ++i)
+        m_pDoc->SetString(ScAddress(7,i,0), "=ROW()");
+
+    m_pDoc->CalcAll();
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(7,3,0), 3); // H4:H6
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 0, 4.0));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 1, 5.0));
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 2, 6.0));
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(7,4,0), 10); // H5:H15
+    CPPUNIT_ASSERT_MESSAGE("Failed to fetch vector ref array.", aArray.isValid());
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected string cell.", equals(aArray, 0, 5.0));
+
+    // Clear everything and start over.
+    clearRange(m_pDoc, ScRange(0,0,0,m_pDoc->MaxCol(),m_pDoc->MaxRow(),0));
+    m_pDoc->PrepareFormulaCalc();
+
+    // Totally empty range in a totally empty column (Column A).
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(0,0,0), 3); // A1:A3
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[0]));
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[1]));
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[2]));
+
+    // Totally empty range in a non-empty column (Column B).
+    m_pDoc->SetString(ScAddress(1,10,0), "Some text"); // B11
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(1,0,0), 3); // B1:B3
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[0]));
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[1]));
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[2]));
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(1,12,0), 3); // B13:B15
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[0]));
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[1]));
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[2]));
+
+    // These values come from a cache because of the call above.
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(1,1,0), 3); // B2:B4
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[0]));
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[1]));
+    CPPUNIT_ASSERT(std::isnan(aArray.mpNumericArray[2]));
+
+    // The column begins with a string header at row 1 (Column C).
+    m_pDoc->SetString(ScAddress(2,0,0), "MyHeader");
+    for (SCROW i = 1; i <= 9; ++i) // rows 2-10 are numeric.
+        m_pDoc->SetValue(ScAddress(2,i,0), i);
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(2,1,0), 9); // C2:C10
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    for (size_t i = 0; i < 9; ++i)
+        CPPUNIT_ASSERT_EQUAL(double(i+1), aArray.mpNumericArray[i]);
+
+    // The column begins with a number, followed by a string then followed by
+    // a block of numbers (Column D).
+    m_pDoc->SetValue(ScAddress(3,0,0), 0.0);
+    m_pDoc->SetString(ScAddress(3,1,0), "Some string");
+    for (SCROW i = 2; i <= 9; ++i) // rows 3-10 are numeric.
+        m_pDoc->SetValue(ScAddress(3,i,0), i);
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(3,2,0), 8); // D3:D10
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    for (size_t i = 0; i < 8; ++i)
+        CPPUNIT_ASSERT_EQUAL(double(i+2), aArray.mpNumericArray[i]);
+
+    // The column begins with a formula, followed by a string then followed by
+    // a block of numbers (Column E).
+    m_pDoc->SetString(ScAddress(4,0,0), "=1*2");
+    m_pDoc->SetString(ScAddress(4,1,0), "Some string");
+    for (SCROW i = 2; i <= 9; ++i) // rows 3-10 are numeric.
+        m_pDoc->SetValue(ScAddress(4,i,0), i*2);
+
+    aArray = m_pDoc->FetchVectorRefArray(ScAddress(4,2,0), 8); // E3:E10
+    CPPUNIT_ASSERT_MESSAGE("Array should have a numeric array.", aArray.mpNumericArray);
+    CPPUNIT_ASSERT_MESSAGE("Array should NOT have a string array.", !aArray.mpStringArray);
+    for (size_t i = 0; i < 8; ++i)
+        CPPUNIT_ASSERT_EQUAL(double((i+2)*2), aArray.mpNumericArray[i]);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testGroupConverter3D()
+{
+    m_pDoc->InsertTab(0, "Test");
+    m_pDoc->InsertTab(1, "Test2");
+
+    m_pDoc->SetValue(1, 0, 0, 1.0);
+    m_pDoc->SetValue(1, 0, 1, 2.0);
+
+    for (SCROW nRow = 0; nRow < 200; ++nRow)
+    {
+        OUString aFormula = "=SUM(Test.B" + OUString::number(nRow+1) + ":Test2.B" + OUString::number(nRow+1) + ")";
+        m_pDoc->SetString(0, nRow, 0, aFormula);
+    }
+
+    double nVal = m_pDoc->GetValue(0, 0, 0);
+    CPPUNIT_ASSERT_EQUAL(3.0, nVal);
+
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaHashAndTag()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    ScAddress aPos1(0,0,0), aPos2(1,0,0);
+
+    // Test formula hashing.
+
+    static const struct {
+        const char* pFormula1; const char* pFormula2; bool bEqual;
+    } aHashTests[] = {
+        { "=1", "=2", false }, // different constants
+        { "=SUM(1;2;3;4;5)", "=AVERAGE(1;2;3;4;5)", false }, // different functions
+        { "=C2*3", "=D2*3", true },  // relative references
+        { "=C2*3", "=D2*4", false }, // different constants
+        { "=C2*4", "=D2*4", true },  // relative references
+        { "=3*4*5", "=3*4*\"foo\"", false }, // numeric vs string constants
+        { "=$C3/2", "=$C3/2", true }, // absolute column references
+        { "=C$3/2", "=D$3/2", true }, // absolute row references
+        { "=$E$30/2", "=$E$30/2", true }, // absolute references
+        { "=X20", "=$X$20", false }, // absolute vs relative
+        { "=X20", "=X$20", false }, // absolute vs relative
+        { "=X20", "=$X20", false }, // absolute vs relative
+        { "=X$20", "=$X20", false }, // column absolute vs row absolute
+        // similar enough for merging ...
+        { "=A1", "=B1", true },
+        { "=$A$1", "=$B$1", true },
+        { "=A1", "=C2", true },
+        { "=SUM(A1)", "=SUM(B1)", true },
+        { "=A1+3", "=B1+3", true },
+        { "=A1+7", "=B1+42", false },
+    };
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aHashTests); ++i)
+    {
+        m_pDoc->SetString(aPos1, OUString::createFromAscii(aHashTests[i].pFormula1));
+        m_pDoc->SetString(aPos2, OUString::createFromAscii(aHashTests[i].pFormula2));
+        size_t nHashVal1 = m_pDoc->GetFormulaHash(aPos1);
+        size_t nHashVal2 = m_pDoc->GetFormulaHash(aPos2);
+
+        std::ostringstream os;
+        os << "(expr1:" << aHashTests[i].pFormula1 << "; expr2:" << aHashTests[i].pFormula2 << ")";
+        if (aHashTests[i].bEqual)
+        {
+            os << " Error: these hashes should be equal." << endl;
+            CPPUNIT_ASSERT_EQUAL_MESSAGE(os.str(), nHashVal1, nHashVal2);
+        }
+        else
+        {
+            os << " Error: these hashes should differ." << endl;
+            CPPUNIT_ASSERT_MESSAGE(os.str(), nHashVal1 != nHashVal2);
+        }
+
+        aPos1.IncRow();
+        aPos2.IncRow();
+    }
+
+    // Go back to row 1.
+    aPos1.SetRow(0);
+    aPos2.SetRow(0);
+
+    // Test formula vectorization state.
+
+    static const struct {
+        const char* pFormula;
+        ScFormulaVectorState eState;
+    } aVectorTests[] = {
+        { "=SUM(1;2;3;4;5)", FormulaVectorEnabled },
+        { "=NOW()", FormulaVectorDisabled },
+        { "=AVERAGE(X1:Y200)", FormulaVectorCheckReference },
+        { "=MAX(X1:Y200;10;20)", FormulaVectorCheckReference },
+        { "=MIN(10;11;22)", FormulaVectorEnabled },
+        { "=H4", FormulaVectorCheckReference },
+    };
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aVectorTests); ++i)
+    {
+        m_pDoc->SetString(aPos1, OUString::createFromAscii(aVectorTests[i].pFormula));
+        ScFormulaVectorState eState = m_pDoc->GetFormulaVectorState(aPos1);
+        ScFormulaVectorState eReferenceState = aVectorTests[i].eState;
+
+        if (eState != eReferenceState)
+        {
+            std::ostringstream os;
+            os << "Unexpected vectorization state: expr: '" << aVectorTests[i].pFormula << "'";
+            CPPUNIT_ASSERT_MESSAGE(os.str(), false);
+        }
+        aPos1.IncRow();
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaTokenEquality()
+{
+    struct FormulaTokenEqualityTest
+    {
+        const char* mpFormula1;
+        const char* mpFormula2;
+        bool mbEqual;
+    };
+
+    static const FormulaTokenEqualityTest aTests[] = {
+        { "R1C2", "R1C2", true },
+        { "R1C2", "R1C3", false },
+        { "R1C2", "R2C2", false },
+        { "RC2",  "RC[1]", false },
+        { "R1C2:R10C2", "R1C2:R10C2", true },
+        { "R1C2:R10C2", "R1C2:R11C2", false },
+        { "1", "2", false },
+        { "RC[1]+1.2", "RC[1]+1.2", true },
+        { "RC[1]*0.2", "RC[1]*0.5", false },
+        { "\"Test1\"", "\"Test2\"", false },
+        { "\"Test\"", "\"Test\"", true },
+        { "CONCATENATE(\"Test1\")", "CONCATENATE(\"Test1\")", true },
+        { "CONCATENATE(\"Test1\")", "CONCATENATE(\"Test2\")", false },
+    };
+
+    formula::FormulaGrammar::Grammar eGram = formula::FormulaGrammar::GRAM_ENGLISH_XL_R1C1;
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aTests); ++i)
+    {
+        ScFormulaCell aCell1(m_pDoc, ScAddress(), OUString::createFromAscii(aTests[i].mpFormula1), eGram);
+        ScFormulaCell aCell2(m_pDoc, ScAddress(), OUString::createFromAscii(aTests[i].mpFormula2), eGram);
+
+        ScFormulaCell::CompareState eComp = aCell1.CompareByTokenArray(aCell2);
+        if (aTests[i].mbEqual)
+        {
+            if (eComp == ScFormulaCell::NotEqual)
+            {
+                std::ostringstream os;
+                os << "These two formulas should be evaluated equal: '"
+                    << aTests[i].mpFormula1 << "' vs '" << aTests[i].mpFormula2 << "'" << endl;
+                CPPUNIT_FAIL(os.str());
+            }
+        }
+        else
+        {
+            if (eComp != ScFormulaCell::NotEqual)
+            {
+                std::ostringstream os;
+                os << "These two formulas should be evaluated non-equal: '"
+                    << aTests[i].mpFormula1 << "' vs '" << aTests[i].mpFormula2 << "'" << endl;
+                CPPUNIT_FAIL(os.str());
+            }
+        }
+    }
+}
+
+void Test::testFormulaRefData()
+{
+    std::unique_ptr<ScDocument> pDoc = std::make_unique<ScDocument>();
+
+    ScAddress aAddr(4,5,3), aPos(2,2,2);
+    ScSingleRefData aRef;
+    aRef.InitAddress(aAddr);
+    CPPUNIT_ASSERT_MESSAGE("Wrong ref data state.", !aRef.IsRowRel() && !aRef.IsColRel() && !aRef.IsTabRel());
+    CPPUNIT_ASSERT_EQUAL(SCCOL(4), aRef.Col());
+    CPPUNIT_ASSERT_EQUAL(SCROW(5), aRef.Row());
+    CPPUNIT_ASSERT_EQUAL(SCTAB(3), aRef.Tab());
+
+    aRef.SetRowRel(true);
+    aRef.SetColRel(true);
+    aRef.SetTabRel(true);
+    aRef.SetAddress(pDoc->GetSheetLimits(), aAddr, aPos);
+    CPPUNIT_ASSERT_EQUAL(SCCOL(2), aRef.Col());
+    CPPUNIT_ASSERT_EQUAL(SCROW(3), aRef.Row());
+    CPPUNIT_ASSERT_EQUAL(SCTAB(1), aRef.Tab());
+
+    // Test extension of range reference.
+
+    ScComplexRefData aDoubleRef;
+    aDoubleRef.InitRange(ScRange(2,2,0,4,4,0));
+
+    aRef.InitAddress(ScAddress(6,5,0));
+
+    aDoubleRef.Extend(pDoc->GetSheetLimits(), aRef, ScAddress());
+    ScRange aTest = aDoubleRef.toAbs(pDoc.get(), ScAddress());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong start position of extended range.", ScAddress(2,2,0), aTest.aStart);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong end position of extended range.", ScAddress(6,5,0), aTest.aEnd);
+
+    ScComplexRefData aDoubleRef2;
+    aDoubleRef2.InitRangeRel(pDoc.get(), ScRange(1,2,0,8,6,0), ScAddress(5,5,0));
+    aDoubleRef.Extend(pDoc->GetSheetLimits(), aDoubleRef2, ScAddress(5,5,0));
+    aTest = aDoubleRef.toAbs(pDoc.get(), ScAddress(5,5,0));
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong start position of extended range.", ScAddress(1,2,0), aTest.aStart);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong end position of extended range.", ScAddress(8,6,0), aTest.aEnd);
+}
+
+void Test::testFormulaCompiler()
+{
+    static const struct {
+        const char* pInput; FormulaGrammar::Grammar eInputGram;
+        const char* pOutput; FormulaGrammar::Grammar eOutputGram;
+    } aTests[] = {
+        { "=B1-$C2+D$3-$E$4", FormulaGrammar::GRAM_NATIVE, "[.B1]-[.$C2]+[.D$3]-[.$E$4]", FormulaGrammar::GRAM_ODFF },
+        { "=B1-$C2+D$3-$E$4", FormulaGrammar::GRAM_NATIVE, "B1-$C2+D$3-$E$4", FormulaGrammar::GRAM_NATIVE },
+        { "=B1-$C2+D$3-$E$4", FormulaGrammar::GRAM_NATIVE, "B1-$C2+D$3-$E$4", FormulaGrammar::GRAM_NATIVE_XL_A1 },
+        { "=B1-$C2+D$3-$E$4", FormulaGrammar::GRAM_NATIVE, "RC[1]-R[1]C3+R3C[3]-R4C5", FormulaGrammar::GRAM_NATIVE_XL_R1C1 },
+    };
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aTests); ++i)
+    {
+        std::unique_ptr<ScTokenArray> pArray = compileFormula(m_pDoc, OUString::createFromAscii(aTests[i].pInput), aTests[i].eInputGram);
+        CPPUNIT_ASSERT_MESSAGE("Token array shouldn't be NULL!", pArray);
+
+        OUString aFormula = toString(*m_pDoc, ScAddress(), *pArray, aTests[i].eOutputGram);
+        CPPUNIT_ASSERT_EQUAL(OUString::createFromAscii(aTests[i].pOutput), aFormula);
+    }
+}
+
+void Test::testFormulaCompilerJumpReordering()
+{
+    struct TokenCheck
+    {
+        OpCode meOp;
+        StackVar meType;
+    };
+
+    // Set separators first.
+    ScFormulaOptions aOptions;
+    aOptions.SetFormulaSepArg(";");
+    aOptions.SetFormulaSepArrayCol(";");
+    aOptions.SetFormulaSepArrayRow("|");
+    getDocShell().SetFormulaOptions(aOptions);
+
+    {
+        OUString const aInput("=IF(B1;12;\"text\")");
+
+        // Compile formula string first.
+        std::unique_ptr<ScTokenArray> pCode(compileFormula(m_pDoc, aInput));
+        CPPUNIT_ASSERT(pCode);
+
+        // Then generate RPN tokens.
+        ScCompiler aCompRPN(m_pDoc, ScAddress(), *pCode, FormulaGrammar::GRAM_NATIVE);
+        aCompRPN.CompileTokenArray();
+
+        // RPN tokens should be ordered: B1, ocIf, C1, ocSep, D1, ocClose.
+        static const TokenCheck aCheckRPN[] =
+        {
+            { ocPush,  svSingleRef },
+            { ocIf,    svUnknown   }, // type is context dependent, don't test it
+            { ocPush,  svDouble    },
+            { ocSep,   svSep       },
+            { ocPush,  svString    },
+            { ocClose, svSep       },
+        };
+
+        sal_uInt16 nLen = pCode->GetCodeLen();
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong RPN token count.", static_cast<sal_uInt16>(SAL_N_ELEMENTS(aCheckRPN)), nLen);
+
+        FormulaToken** ppTokens = pCode->GetCode();
+        for (sal_uInt16 i = 0; i < nLen; ++i)
+        {
+            const FormulaToken* p = ppTokens[i];
+            CPPUNIT_ASSERT_EQUAL(aCheckRPN[i].meOp, p->GetOpCode());
+            if (aCheckRPN[i].meOp != ocIf )
+                CPPUNIT_ASSERT_EQUAL(static_cast<int>(aCheckRPN[i].meType), static_cast<int>(p->GetType()));
+        }
+
+        // Generate RPN tokens again, but this time no jump command reordering.
+        pCode->DelRPN();
+        ScCompiler aCompRPN2(m_pDoc, ScAddress(), *pCode, FormulaGrammar::GRAM_NATIVE);
+        aCompRPN2.EnableJumpCommandReorder(false);
+        aCompRPN2.CompileTokenArray();
+
+        static const TokenCheck aCheckRPN2[] =
+        {
+            { ocPush,  svSingleRef },
+            { ocPush,  svDouble    },
+            { ocPush,  svString    },
+            { ocIf,    svUnknown   }, // type is context dependent, don't test it
+        };
+
+        nLen = pCode->GetCodeLen();
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong RPN token count.", static_cast<sal_uInt16>(SAL_N_ELEMENTS(aCheckRPN2)), nLen);
+        ppTokens = pCode->GetCode();
+        for (sal_uInt16 i = 0; i < nLen; ++i)
+        {
+            const FormulaToken* p = ppTokens[i];
+            CPPUNIT_ASSERT_EQUAL(aCheckRPN2[i].meOp, p->GetOpCode());
+            if (aCheckRPN[i].meOp == ocPush)
+                CPPUNIT_ASSERT_EQUAL(static_cast<int>(aCheckRPN2[i].meType), static_cast<int>(p->GetType()));
+        }
+    }
+}
+
+void Test::testFormulaCompilerImplicitIntersection2Param()
+{
+    struct TestCaseFormula
+    {
+        OUString  aFormula;
+        ScAddress aCellAddress;
+        ScRange   aSumRange;
+        bool      bStartColRel;  // SumRange-StartCol
+        bool      bEndColRel;    // SumRange-EndCol
+    };
+
+    m_pDoc->InsertTab(0, "Formula");
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    {
+        TestCaseFormula aTestCases[] =
+        {
+            // Formula, FormulaCellAddress, SumRange with Implicit Intersection
+
+            // Sumrange is single cell, address is abs
+            {
+                OUString("=SUMIF($B$2:$B$10;F2;$D$5)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                false,
+                false
+            },
+
+            // Sumrange is single cell, address is relative
+            {
+                OUString("=SUMIF($B$2:$B$10;F2;D5)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                true,
+                true
+            },
+
+            // Baserange(abs,abs), Sumrange(abs,abs)
+            {
+                OUString("=SUMIF($B$2:$B$10;F2;$D$5:$D$10)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                false,
+                false
+            },
+
+            // Baserange(abs,rel), Sumrange(abs,abs)
+            {
+                OUString("=SUMIF($B$2:B10;F2;$D$5:$D$10)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                false,
+                false
+            },
+
+            // Baserange(rel,abs), Sumrange(abs,abs)
+            {
+                OUString("=SUMIF(B2:$B$10;F2;$D$5:$D$10)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                false,
+                false
+            },
+
+            // Baserange(rel,rel), Sumrange(abs,abs)
+            {
+                OUString("=SUMIF(B2:B10;F2;$D$5:$D$10)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                false,
+                false
+            },
+
+            // Baserange(abs,abs), Sumrange(abs,rel)
+            {
+                OUString("=SUMIF($B$2:$B$10;F2;$D$5:D10)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                false,
+                true
+            },
+
+            // Baserange(abs,abs), Sumrange(rel,abs)
+            {
+                OUString("=SUMIF($B$2:$B$10;F2;D5:$D$10)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                true,
+                false
+            },
+
+            // Baserange(abs,abs), Sumrange(rel,rel)
+            {
+                OUString("=SUMIF($B$2:$B$10;F2;D5:D10)"),
+                ScAddress(7, 5, 0),
+                ScRange( ScAddress(3, 4, 0), ScAddress(3, 12, 0) ),
+                true,
+                true
+            }
+        };
+
+        for (const auto& rCase : aTestCases)
+        {
+            m_pDoc->SetString(rCase.aCellAddress, rCase.aFormula);
+            const ScFormulaCell* pCell = m_pDoc->GetFormulaCell(rCase.aCellAddress);
+            const ScTokenArray* pCode = pCell->GetCode();
+            CPPUNIT_ASSERT(pCode);
+
+            sal_uInt16 nLen = pCode->GetCodeLen();
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong RPN token count.", static_cast<sal_uInt16>(4), nLen);
+
+            FormulaToken** ppTokens = pCode->GetCode();
+
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong type of token(first argument to SUMIF)", svDoubleRef, ppTokens[0]->GetType());
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong type of token(third argument to SUMIF)", svDoubleRef, ppTokens[2]->GetType());
+
+            ScComplexRefData aSumRangeData = *ppTokens[2]->GetDoubleRef();
+            ScRange aSumRange = aSumRangeData.toAbs(m_pDoc, rCase.aCellAddress);
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong sum-range in RPN array", rCase.aSumRange, aSumRange);
+
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong IsRel type for start column address in sum-range", rCase.bStartColRel, aSumRangeData.Ref1.IsColRel());
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong IsRel type for end column address in sum-range", rCase.bEndColRel, aSumRangeData.Ref2.IsColRel());
+        }
+    }
+}
+
+void Test::testFormulaCompilerImplicitIntersection1ParamNoChange()
+{
+    struct TestCaseFormulaNoChange
+    {
+        OUString  aFormula;
+        ScAddress aCellAddress;
+        bool      bMatrixFormula;
+        bool      bForcedArray;
+    };
+
+    m_pDoc->InsertTab(0, "Formula");
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    {
+        ScAddress aStartAddr(4, 5, 0);
+        TestCaseFormulaNoChange aCasesNoChange[] =
+        {
+            {
+                OUString("=COS(A$2:A$100)"),  // No change because of abs col ref.
+                aStartAddr,
+                false,
+                false
+            },
+            {
+                OUString("=COS($A7:$A100)"),  // No intersection
+                aStartAddr,
+                false,
+                false
+            },
+            {
+                OUString("=COS($A5:$C7)"),   // No intersection 2-D range
+                aStartAddr,
+                false,
+                false
+            },
+            {
+                OUString("=SUMPRODUCT(COS(A6:A10))"),  // COS() in forced array mode
+                aStartAddr,
+                false,
+                true
+            },
+            {
+                OUString("=COS(A6:A10)"),  // Matrix formula
+                aStartAddr,
+                true,
+                false
+            }
+        };
+
+        for (const auto& rCase : aCasesNoChange)
+        {
+            if (rCase.bMatrixFormula)
+            {
+                ScMarkData aMark(MAXROW, MAXCOL);
+                aMark.SelectOneTable(0);
+                SCCOL nColStart = rCase.aCellAddress.Col();
+                SCROW nRowStart = rCase.aCellAddress.Row();
+                m_pDoc->InsertMatrixFormula(nColStart, nRowStart, nColStart, nRowStart + 4,
+                                            aMark, rCase.aFormula);
+            }
+            else
+                m_pDoc->SetString(rCase.aCellAddress, rCase.aFormula);
+
+            const ScFormulaCell* pCell = m_pDoc->GetFormulaCell(rCase.aCellAddress);
+            const ScTokenArray* pCode = pCell->GetCode();
+            CPPUNIT_ASSERT(pCode);
+
+            sal_uInt16 nRPNLen = pCode->GetCodeLen();
+            sal_uInt16 nRawLen = pCode->GetLen();
+            sal_uInt16 nRawArgPos;
+            if (rCase.bForcedArray)
+            {
+                nRawArgPos = 4;
+                CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong raw token count.", static_cast<sal_uInt16>(7), nRawLen);
+                CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong RPN token count.", static_cast<sal_uInt16>(3), nRPNLen);
+            }
+            else
+            {
+                nRawArgPos = 2;
+                CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong raw token count.", static_cast<sal_uInt16>(4), nRawLen);
+                CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong RPN token count.", static_cast<sal_uInt16>(2), nRPNLen);
+            }
+
+            FormulaToken** ppRawTokens = pCode->GetArray();
+            FormulaToken** ppRPNTokens = pCode->GetCode();
+
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong type of raw token(argument to COS)", svDoubleRef, ppRawTokens[nRawArgPos]->GetType());
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong type of RPN token(argument to COS)", svDoubleRef, ppRPNTokens[0]->GetType());
+
+            ScComplexRefData aArgRangeRaw = *ppRawTokens[nRawArgPos]->GetDoubleRef();
+            ScComplexRefData aArgRangeRPN = *ppRPNTokens[0]->GetDoubleRef();
+            bool bRawMatchRPNToken(aArgRangeRaw == aArgRangeRPN);
+            CPPUNIT_ASSERT_MESSAGE("raw arg token and RPN arg token contents do not match", bRawMatchRPNToken);
+        }
+    }
+}
+
+void Test::testFormulaCompilerImplicitIntersection1ParamWithChange()
+{
+    struct TestCaseFormula
+    {
+        OUString  aFormula;
+        ScAddress aCellAddress;
+        ScAddress aArgAddr;
+    };
+
+    m_pDoc->InsertTab(0, "Formula");
+    m_pDoc->InsertTab(1, "Formula1");
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    {
+        ScAddress aStartAddr(10, 5, 0);
+        TestCaseFormula aCasesWithChange[] =
+        {
+            {
+                OUString("=COS($A6:$A100)"),  // Corner case with intersection
+                aStartAddr,
+                ScAddress(0, 5, 0)
+            },
+            {
+                OUString("=COS($A2:$A6)"),    // Corner case with intersection
+                aStartAddr,
+                ScAddress(0, 5, 0)
+            },
+            {
+                OUString("=COS($A2:$A100)"),    // Typical 1D case
+                aStartAddr,
+                ScAddress(0, 5, 0)
+            },
+            {
+                OUString("=COS($Formula.$A1:$C3)"),      // 2D corner case
+                ScAddress(0, 0, 1),                      // Formula in sheet 1
+                ScAddress(0, 0, 0)
+            },
+            {
+                OUString("=COS($Formula.$A1:$C3)"),      // 2D corner case
+                ScAddress(0, 2, 1),                      // Formula in sheet 1
+                ScAddress(0, 2, 0)
+            },
+            {
+                OUString("=COS($Formula.$A1:$C3)"),      // 2D corner case
+                ScAddress(2, 0, 1),                      // Formula in sheet 1
+                ScAddress(2, 0, 0)
+            },
+            {
+                OUString("=COS($Formula.$A1:$C3)"),      // 2D corner case
+                ScAddress(2, 2, 1),                      // Formula in sheet 1
+                ScAddress(2, 2, 0)
+            },
+            {
+                OUString("=COS($Formula.$A1:$C3)"),      // Typical 2D case
+                ScAddress(1, 1, 1),                      // Formula in sheet 1
+                ScAddress(1, 1, 0)
+            }
+        };
+
+        for (const auto& rCase : aCasesWithChange)
+        {
+            m_pDoc->SetString(rCase.aCellAddress, rCase.aFormula);
+
+            const ScFormulaCell* pCell = m_pDoc->GetFormulaCell(rCase.aCellAddress);
+            const ScTokenArray* pCode = pCell->GetCode();
+            CPPUNIT_ASSERT(pCode);
+
+            sal_uInt16 nRPNLen = pCode->GetCodeLen();
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong RPN token count.", static_cast<sal_uInt16>(2), nRPNLen);
+
+            FormulaToken** ppRPNTokens = pCode->GetCode();
+
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong type of RPN token(argument to COS)", svSingleRef, ppRPNTokens[0]->GetType());
+
+            ScSingleRefData aArgAddrRPN = *ppRPNTokens[0]->GetSingleRef();
+            ScAddress aArgAddrActual = aArgAddrRPN.toAbs(m_pDoc, rCase.aCellAddress);
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Computed implicit intersection singleref is wrong", rCase.aArgAddr, aArgAddrActual);
+        }
+    }
+}
+
+void Test::testFormulaCompilerImplicitIntersection1NoGroup()
+{
+    m_pDoc->InsertTab(0, "Formula");
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->SetString(ScAddress(1,2,0), "=COS(A1:A5)"); // B3
+    m_pDoc->SetString(ScAddress(1,3,0), "=COS(A1:A5)"); // B4
+
+    // Implicit intersection optimization in ScCompiler::HandleIIOpCode() internally changes
+    // these to "=COS(A3)" and "=COS(A4)", but these shouldn't be merged into a formula group,
+    // otherwise B4's formula would then be "=COS(A2:A6)".
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,0), "COS(A1:A5)", "Formula in B3 has changed.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,3,0), "COS(A1:A5)", "Formula in B4 has changed.");
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaCompilerImplicitIntersectionOperators()
+{
+    struct TestCase
+    {
+        OUString formula[3];
+        double result[3];
+    };
+
+    m_pDoc->InsertTab(0, "Test");
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->SetValue(2, 0, 0, 5); // C1
+    m_pDoc->SetValue(2, 1, 0, 4); // C2
+    m_pDoc->SetValue(2, 2, 0, 3); // C3
+    m_pDoc->SetValue(3, 0, 0, 1); // D1
+    m_pDoc->SetValue(3, 1, 0, 2); // D2
+    m_pDoc->SetValue(3, 2, 0, 3); // D3
+
+    TestCase tests[] =
+    {
+        { OUString("=C:C/D:D"), OUString("=C:C/D:D"), OUString("=C:C/D:D"), 5, 2, 1 },
+        { OUString("=C1:C2/D1:D2"), OUString("=C2:C3/D2:D3"), OUString("=C3:C4/D3:D4"), 5, 2, 1 }
+    };
+
+    for (const TestCase& test : tests)
+    {
+        for(int i = 0; i < 2; ++i )
+            m_pDoc->SetString(ScAddress(4,i,0), test.formula[i]); // E1-3
+        for(int i = 0; i < 2; ++i )
+            CPPUNIT_ASSERT_EQUAL_MESSAGE(OUString( test.formula[i] + " result incorrect in row " + OUString::number(i+1)).toUtf8().getStr(),
+                test.result[i], m_pDoc->GetValue(ScAddress(4,i,0)));
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdate()
+{
+    m_pDoc->InsertTab(0, "Formula");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->SetValue(ScAddress(0,0,0), 2.0); // A1
+    m_pDoc->SetString(ScAddress(2,2,0), "=A1");   // C3
+    m_pDoc->SetString(ScAddress(2,3,0), "=$A$1"); // C4
+
+    ScAddress aPos(2,2,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A1", "Wrong formula in C3.");
+
+    aPos = ScAddress(2,3,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$1", "Wrong formula in C4.");
+
+    // Delete row 2 to push formula cells up (to C2:C3).
+    m_pDoc->DeleteRow(ScRange(0,1,0,m_pDoc->MaxCol(),1,0));
+
+    aPos = ScAddress(2,1,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A1", "Wrong formula in C2.");
+
+    aPos = ScAddress(2,2,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$1", "Wrong formula in C3.");
+
+    // Insert one row at row 2 to move them back.
+    m_pDoc->InsertRow(ScRange(0,1,0,m_pDoc->MaxCol(),1,0));
+
+    aPos = ScAddress(2,2,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A1", "Wrong formula in C3.");
+
+    aPos = ScAddress(2,3,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$1", "Wrong formula in C4.");
+
+    // Insert 2 rows at row 1 to shift all of A1 and C3:C4 down.
+    m_pDoc->InsertRow(ScRange(0,0,0,m_pDoc->MaxCol(),1,0));
+
+    aPos = ScAddress(2,4,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A3", "Wrong formula in C5.");
+
+    aPos = ScAddress(2,5,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$3", "Wrong formula in C6.");
+
+    // Delete 2 rows at row 1 to shift them back.
+    m_pDoc->DeleteRow(ScRange(0,0,0,m_pDoc->MaxCol(),1,0));
+
+    aPos = ScAddress(2,2,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A1", "Wrong formula in C3.");
+
+    aPos = ScAddress(2,3,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$1", "Wrong formula in C4.");
+
+    // Insert 3 columns at column B. to shift C3:C4 to F3:F4.
+    m_pDoc->InsertCol(ScRange(1,0,0,3,m_pDoc->MaxRow(),0));
+
+    aPos = ScAddress(5,2,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A1", "Wrong formula in F3.");
+
+    aPos = ScAddress(5,3,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$1", "Wrong formula in F4.");
+
+    // Delete columns B:D to shift them back.
+    m_pDoc->DeleteCol(ScRange(1,0,0,3,m_pDoc->MaxRow(),0));
+
+    aPos = ScAddress(2,2,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A1", "Wrong formula in C3.");
+
+    aPos = ScAddress(2,3,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$1", "Wrong formula in C4.");
+
+    // Insert cells over A1:A3 to only shift A1 down to A4.
+    m_pDoc->InsertRow(ScRange(0,0,0,0,2,0));
+
+    aPos = ScAddress(2,2,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A4", "Wrong formula in C3.");
+
+    aPos = ScAddress(2,3,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$4", "Wrong formula in C4.");
+
+    // .. and back.
+    m_pDoc->DeleteRow(ScRange(0,0,0,0,2,0));
+
+    aPos = ScAddress(2,2,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "A1", "Wrong formula in C3.");
+
+    aPos = ScAddress(2,3,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$A$1", "Wrong formula in C4.");
+
+    // Delete row 1 which will delete the value cell (A1).
+    m_pDoc->DeleteRow(ScRange(0,0,0,m_pDoc->MaxCol(),0,0));
+
+    aPos = ScAddress(2,1,0);
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell(aPos);
+    CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC);
+    CPPUNIT_ASSERT_EQUAL(int(FormulaError::NoRef), static_cast<int>(pFC->GetErrCode()));
+    aPos = ScAddress(2,2,0);
+    pFC = m_pDoc->GetFormulaCell(aPos);
+    CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC);
+    CPPUNIT_ASSERT_EQUAL(int(FormulaError::NoRef), static_cast<int>(pFC->GetErrCode()));
+
+    // Clear all and start over.
+    clearRange(m_pDoc, ScRange(0,0,0,10,10,0));
+
+    // Test range updates
+
+    // Fill B2:C3 with values.
+    m_pDoc->SetValue(ScAddress(1,1,0), 1);
+    m_pDoc->SetValue(ScAddress(1,2,0), 2);
+    m_pDoc->SetValue(ScAddress(2,1,0), 3);
+    m_pDoc->SetValue(ScAddress(2,2,0), 4);
+
+    m_pDoc->SetString(ScAddress(0,5,0), "=SUM(B2:C3)");
+    m_pDoc->SetString(ScAddress(0,6,0), "=SUM($B$2:$C$3)");
+
+    aPos = ScAddress(0,5,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B2:C3)", "Wrong formula in A6.");
+
+    aPos = ScAddress(0,6,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM($B$2:$C$3)", "Wrong formula in A7.");
+
+    // Insert a row at row 1.
+    m_pDoc->InsertRow(ScRange(0,0,0,m_pDoc->MaxCol(),0,0));
+
+    aPos = ScAddress(0,6,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B3:C4)", "Wrong formula in A7.");
+
+    aPos = ScAddress(0,7,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM($B$3:$C$4)", "Wrong formula in A8.");
+
+    // ... and back.
+    m_pDoc->DeleteRow(ScRange(0,0,0,m_pDoc->MaxCol(),0,0));
+
+    aPos = ScAddress(0,5,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B2:C3)", "Wrong formula in A6.");
+
+    aPos = ScAddress(0,6,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM($B$2:$C$3)", "Wrong formula in A7.");
+
+    // Insert columns B:C to shift only the value range.
+    m_pDoc->InsertCol(ScRange(1,0,0,2,m_pDoc->MaxRow(),0));
+
+    aPos = ScAddress(0,5,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(D2:E3)", "Wrong formula in A6.");
+
+    aPos = ScAddress(0,6,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM($D$2:$E$3)", "Wrong formula in A7.");
+
+    // ... and back.
+    m_pDoc->DeleteCol(ScRange(1,0,0,2,m_pDoc->MaxRow(),0));
+
+    aPos = ScAddress(0,5,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B2:C3)", "Wrong formula in A6.");
+
+    aPos = ScAddress(0,6,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM($B$2:$C$3)", "Wrong formula in A7.");
+
+    // Insert rows 5:6 to shift the formula cells only.
+    m_pDoc->InsertRow(ScRange(0,4,0,m_pDoc->MaxCol(),5,0));
+
+    aPos = ScAddress(0,7,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B2:C3)", "Wrong formula in A8.");
+
+    aPos = ScAddress(0,8,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM($B$2:$C$3)", "Wrong formula in A9.");
+
+    // ... and back.
+    m_pDoc->DeleteRow(ScRange(0,4,0,m_pDoc->MaxCol(),5,0));
+
+    aPos = ScAddress(0,5,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B2:C3)", "Wrong formula in A6.");
+
+    aPos = ScAddress(0,6,0);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM($B$2:$C$3)", "Wrong formula in A7.");
+
+    // Check the values of the formula cells in A6:A7.
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+
+    // Insert cells over B1:B2 to partially shift value range.
+    m_pDoc->InsertRow(ScRange(1,0,0,1,1,0));
+
+    // Check the values of the formula cells in A6:A7 again.
+    CPPUNIT_ASSERT_EQUAL(7.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    CPPUNIT_ASSERT_EQUAL(7.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+
+    // ... and shift them back.
+    m_pDoc->DeleteRow(ScRange(1,0,0,1,1,0));
+
+    // The formula cell results should be back too.
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+
+    // Delete rows 2:3 to completely remove the referenced range.
+    m_pDoc->DeleteRow(ScRange(0,1,0,m_pDoc->MaxCol(),2,0));
+
+    // Both A4 and A5 should show #REF! errors.
+    pFC = m_pDoc->GetFormulaCell(ScAddress(0,3,0));
+    CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC);
+    CPPUNIT_ASSERT_EQUAL(int(FormulaError::NoRef), static_cast<int>(pFC->GetErrCode()));
+
+    pFC = m_pDoc->GetFormulaCell(ScAddress(0,4,0));
+    CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC);
+    CPPUNIT_ASSERT_EQUAL(int(FormulaError::NoRef), static_cast<int>(pFC->GetErrCode()));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateRange()
+{
+    m_pDoc->InsertTab(0, "Formula");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    setExpandRefs(false);
+
+    // Set values to B2:C5.
+    m_pDoc->SetValue(ScAddress(1,1,0), 1);
+    m_pDoc->SetValue(ScAddress(1,2,0), 2);
+    m_pDoc->SetValue(ScAddress(1,3,0), 3);
+    m_pDoc->SetValue(ScAddress(1,4,0), 4);
+    m_pDoc->SetValue(ScAddress(2,1,0), 5);
+    m_pDoc->SetValue(ScAddress(2,2,0), 6);
+    m_pDoc->SetValue(ScAddress(2,3,0), 7);
+    m_pDoc->SetValue(ScAddress(2,4,0), 8);
+
+    // Set formula cells to A7 and A8.
+    m_pDoc->SetString(ScAddress(0,6,0), "=SUM(B2:C5)");
+    m_pDoc->SetString(ScAddress(0,7,0), "=SUM($B$2:$C$5)");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,6,0), "SUM(B2:C5)", "Wrong formula in A7.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,7,0), "SUM($B$2:$C$5)", "Wrong formula in A8.");
+
+    CPPUNIT_ASSERT_EQUAL(36.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+    CPPUNIT_ASSERT_EQUAL(36.0, m_pDoc->GetValue(ScAddress(0,7,0)));
+
+    // Delete row 3. This should shrink the range references by one row.
+    m_pDoc->DeleteRow(ScRange(0,2,0,m_pDoc->MaxCol(),2,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "SUM(B2:C4)", "Wrong formula in A6.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,6,0), "SUM($B$2:$C$4)", "Wrong formula in A7.");
+
+    CPPUNIT_ASSERT_EQUAL(28.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    CPPUNIT_ASSERT_EQUAL(28.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+
+    // Delete row 4 - bottom of range
+    m_pDoc->DeleteRow(ScRange(0,3,0,m_pDoc->MaxCol(),3,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,4,0), "SUM(B2:C3)", "Wrong formula in A5.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "SUM($B$2:$C$3)", "Wrong formula in A6.");
+
+    CPPUNIT_ASSERT_EQUAL(16.0, m_pDoc->GetValue(ScAddress(0,4,0)));
+    CPPUNIT_ASSERT_EQUAL(16.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+
+    // Delete row 2 - top of range
+    m_pDoc->DeleteRow(ScRange(0,1,0,m_pDoc->MaxCol(),1,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,3,0), "SUM(B2:C2)", "Wrong formula in A4.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,4,0), "SUM($B$2:$C$2)", "Wrong formula in A5.");
+
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,3,0)));
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,4,0)));
+
+    // Clear the range and start over.
+    clearRange(m_pDoc, ScRange(0,0,0,20,20,0));
+
+    // Fill C2:F3 with values.
+    m_pDoc->SetValue(ScAddress(2,1,0), 1);
+    m_pDoc->SetValue(ScAddress(3,1,0), 2);
+    m_pDoc->SetValue(ScAddress(4,1,0), 3);
+    m_pDoc->SetValue(ScAddress(5,1,0), 4);
+    m_pDoc->SetValue(ScAddress(2,2,0), 5);
+    m_pDoc->SetValue(ScAddress(3,2,0), 6);
+    m_pDoc->SetValue(ScAddress(4,2,0), 7);
+    m_pDoc->SetValue(ScAddress(5,2,0), 8);
+
+    // Set formulas to A2 and A3.
+    m_pDoc->SetString(ScAddress(0,1,0), "=SUM(C2:F3)");
+    m_pDoc->SetString(ScAddress(0,2,0), "=SUM($C$2:$F$3)");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C2:F3)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$2:$F$3)", "Wrong formula in A3.");
+
+    CPPUNIT_ASSERT_EQUAL(36.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+    CPPUNIT_ASSERT_EQUAL(36.0, m_pDoc->GetValue(ScAddress(0,2,0)));
+
+    // Delete column D.
+    m_pDoc->DeleteCol(ScRange(3,0,0,3,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C2:E3)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$2:$E$3)", "Wrong formula in A3.");
+
+    CPPUNIT_ASSERT_EQUAL(28.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+    CPPUNIT_ASSERT_EQUAL(28.0, m_pDoc->GetValue(ScAddress(0,2,0)));
+
+    // Delete column E - the right edge of reference range.
+    m_pDoc->DeleteCol(ScRange(4,0,0,4,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C2:D3)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$2:$D$3)", "Wrong formula in A3.");
+
+    CPPUNIT_ASSERT_EQUAL(16.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+    CPPUNIT_ASSERT_EQUAL(16.0, m_pDoc->GetValue(ScAddress(0,2,0)));
+
+    // Delete column C - the left edge of reference range.
+    m_pDoc->DeleteCol(ScRange(2,0,0,2,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C2:C3)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$2:$C$3)", "Wrong formula in A3.");
+
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,2,0)));
+
+    // Clear the range and start over.
+    clearRange(m_pDoc, ScRange(0,0,0,20,20,0));
+
+    // Disable expansion of range reference on insertion in adjacent areas.
+    setExpandRefs(false);
+
+    // Fill C2:D3 with values.
+    m_pDoc->SetValue(ScAddress(2,1,0), 1);
+    m_pDoc->SetValue(ScAddress(3,1,0), 2);
+    m_pDoc->SetValue(ScAddress(2,2,0), 3);
+    m_pDoc->SetValue(ScAddress(3,2,0), 4);
+
+    // Set formulas at A5 and A6.
+    m_pDoc->SetString(ScAddress(0,4,0), "=SUM(C2:D3)");
+    m_pDoc->SetString(ScAddress(0,5,0), "=SUM($C$2:$D$3)");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,4,0), "SUM(C2:D3)", "Wrong formula in A5.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "SUM($C$2:$D$3)", "Wrong formula in A6.");
+
+    // Insert a column at column C. This should simply shift the reference without expansion.
+    m_pDoc->InsertCol(ScRange(2,0,0,2,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,4,0), "SUM(D2:E3)", "Wrong formula in A5.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "SUM($D$2:$E$3)", "Wrong formula in A6.");
+
+    // Shift it back.
+    m_pDoc->DeleteCol(ScRange(2,0,0,2,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,4,0), "SUM(C2:D3)", "Wrong formula in A5.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "SUM($C$2:$D$3)", "Wrong formula in A6.");
+
+    // Insert at column D. This should expand the reference by one column length.
+    m_pDoc->InsertCol(ScRange(3,0,0,3,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,4,0), "SUM(C2:E3)", "Wrong formula in A5.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "SUM($C$2:$E$3)", "Wrong formula in A6.");
+
+    // Insert at column F. No expansion should occur since the edge expansion is turned off.
+    m_pDoc->InsertCol(ScRange(5,0,0,5,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,4,0), "SUM(C2:E3)", "Wrong formula in A5.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "SUM($C$2:$E$3)", "Wrong formula in A6.");
+
+    // Insert at row 2. No expansion should occur with edge expansion turned off.
+    m_pDoc->InsertRow(ScRange(0,1,0,m_pDoc->MaxCol(),1,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "SUM(C3:E4)", "Wrong formula in A6.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,6,0), "SUM($C$3:$E$4)", "Wrong formula in A7.");
+
+    // Insert at row 4 to expand the reference range.
+    m_pDoc->InsertRow(ScRange(0,3,0,m_pDoc->MaxCol(),3,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,6,0), "SUM(C3:E5)", "Wrong formula in A7.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,7,0), "SUM($C$3:$E$5)", "Wrong formula in A8.");
+
+    // Insert at row 6. No expansion with edge expansion turned off.
+    m_pDoc->InsertRow(ScRange(0,5,0,m_pDoc->MaxCol(),5,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,7,0), "SUM(C3:E5)", "Wrong formula in A8.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,8,0), "SUM($C$3:$E$5)", "Wrong formula in A9.");
+
+    // Clear the range and start over.
+    clearRange(m_pDoc, ScRange(0,0,0,20,20,0));
+
+    // Turn edge expansion on.
+    setExpandRefs(true);
+
+    // Fill C6:D7 with values.
+    m_pDoc->SetValue(ScAddress(2,5,0), 1);
+    m_pDoc->SetValue(ScAddress(2,6,0), 2);
+    m_pDoc->SetValue(ScAddress(3,5,0), 3);
+    m_pDoc->SetValue(ScAddress(3,6,0), 4);
+
+    // Set formulas at A2 and A3.
+    m_pDoc->SetString(ScAddress(0,1,0), "=SUM(C6:D7)");
+    m_pDoc->SetString(ScAddress(0,2,0), "=SUM($C$6:$D$7)");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C6:D7)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$6:$D$7)", "Wrong formula in A3.");
+
+    // Insert at column E. This should expand the reference range by one column.
+    m_pDoc->InsertCol(ScRange(4,0,0,4,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C6:E7)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$6:$E$7)", "Wrong formula in A3.");
+
+    // Insert at column C to edge-expand the reference range.
+    m_pDoc->InsertCol(ScRange(2,0,0,2,m_pDoc->MaxRow(),0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C6:F7)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$6:$F$7)", "Wrong formula in A3.");
+
+    // Insert at row 8 to edge-expand.
+    m_pDoc->InsertRow(ScRange(0,7,0,m_pDoc->MaxCol(),7,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C6:F8)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$6:$F$8)", "Wrong formula in A3.");
+
+    // Insert at row 6 to edge-expand.
+    m_pDoc->InsertRow(ScRange(0,5,0,m_pDoc->MaxCol(),5,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "SUM(C6:F9)", "Wrong formula in A2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,2,0), "SUM($C$6:$F$9)", "Wrong formula in A3.");
+
+    m_pDoc->InsertTab(1, "StickyRange");
+
+    // A3:A18 all possible combinations of relative and absolute addressing,
+    // leaving one row above and below unreferenced.
+    ScAddress aPos(0,2,1);
+    m_pDoc->SetString( aPos, "=B2:B1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=B2:B$1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=B2:$B1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=B2:$B$1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=B$2:B1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=B$2:B$1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=B$2:$B1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=B$2:$B$1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=$B2:B1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=$B2:B$1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=$B2:$B1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=$B2:$B$1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=$B$2:B1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=$B$2:B$1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=$B$2:$B1048575");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=$B$2:$B$1048575");
+    aPos.IncRow();
+    // A19 reference to two cells on one row.
+    m_pDoc->SetString( aPos, "=B1048575:C1048575");
+    aPos.IncRow();
+
+    // Insert 2 rows in the middle to shift bottom reference down and make it
+    // sticky.
+    m_pDoc->InsertRow( ScRange( 0, aPos.Row(), 1, m_pDoc->MaxCol(), aPos.Row()+1, 1));
+
+    // A3:A18 must not result in #REF! anywhere.
+    aPos.Set(0,2,1);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B2:B1048576", "Wrong reference in A3 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B2:B$1048576", "Wrong reference in A4 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B2:$B1048576", "Wrong reference in A5 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B2:$B$1048576", "Wrong reference in A6 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B$2:B1048576", "Wrong reference in A7 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B$2:B$1048576", "Wrong reference in A8 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B$2:$B1048576", "Wrong reference in A9 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B$2:$B$1048576", "Wrong reference in A10 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B2:B1048576", "Wrong reference in A11 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B2:B$1048576", "Wrong reference in A12 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B2:$B1048576", "Wrong reference in A13 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B2:$B$1048576", "Wrong reference in A14 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B$2:B1048576", "Wrong reference in A15 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B$2:B$1048576", "Wrong reference in A16 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B$2:$B1048576", "Wrong reference in A17 after insertion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B$2:$B$1048576", "Wrong reference in A18 after insertion.");
+    aPos.IncRow();
+
+    // A19 reference to one row shifted out should be #REF!
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B#REF!:C#REF!", "Wrong reference in A19 after insertion.");
+    // A19 enter reference to last row.
+    m_pDoc->SetString( aPos, "=B1048576:C1048576");
+    aPos.IncRow();
+
+    // Delete row 1 to shift top reference up, bottom reference stays sticky.
+    m_pDoc->DeleteRow(ScRange(0,0,1,m_pDoc->MaxCol(),0,1));
+
+    // Check sticky bottom references and display of entire column references,
+    // now in A2:A17.
+    aPos.Set(0,1,1);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B:B", "Wrong reference in A2 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B1:B$1048576", "Wrong reference in A3 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B:$B", "Wrong reference in A4 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B1:$B$1048576", "Wrong reference in A5 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B$1:B1048576", "Wrong reference in A6 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B:B", "Wrong reference in A7 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B$1:$B1048576", "Wrong reference in A8 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B:$B", "Wrong reference in A9 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B:B", "Wrong reference in A10 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B1:B$1048576", "Wrong reference in A11 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B:$B", "Wrong reference in A12 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B1:$B$1048576", "Wrong reference in A13 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B$1:B1048576", "Wrong reference in A14 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B:B", "Wrong reference in A15 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B$1:$B1048576", "Wrong reference in A16 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B:$B", "Wrong reference in A17 after deletion.");
+    aPos.IncRow();
+
+    // A18 reference to one last row should be shifted up.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B1048575:C1048575", "Wrong reference in A18 after deletion.");
+    aPos.IncRow();
+
+    // Insert 4 rows in the middle.
+    m_pDoc->InsertRow( ScRange( 0, aPos.Row(), 1, m_pDoc->MaxCol(), aPos.Row()+3, 1));
+    // Delete 2 rows in the middle.
+    m_pDoc->DeleteRow( ScRange( 0, aPos.Row(), 1, m_pDoc->MaxCol(), aPos.Row()+1, 1));
+
+    // References in A2:A17 must still be the same.
+    aPos.Set(0,1,1);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B:B", "Wrong reference in A2 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B1:B$1048576", "Wrong reference in A3 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B:$B", "Wrong reference in A4 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B1:$B$1048576", "Wrong reference in A5 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B$1:B1048576", "Wrong reference in A6 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B:B", "Wrong reference in A7 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B$1:$B1048576", "Wrong reference in A8 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "B:$B", "Wrong reference in A9 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B:B", "Wrong reference in A10 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B1:B$1048576", "Wrong reference in A11 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B:$B", "Wrong reference in A12 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B1:$B$1048576", "Wrong reference in A13 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B$1:B1048576", "Wrong reference in A14 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B:B", "Wrong reference in A15 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B$1:$B1048576", "Wrong reference in A16 after deletion.");
+    aPos.IncRow();
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "$B:$B", "Wrong reference in A17 after deletion.");
+    aPos.IncRow();
+
+    // Enter values in B1 and B1048576 (last row).
+    m_pDoc->SetValue( 1,0,1, 1.0);
+    m_pDoc->SetValue( 1,m_pDoc->MaxRow(),1, 2.0);
+    // Sticky reference including last row.
+    m_pDoc->SetString( 2,0,1, "=SUM(B:B)");
+    // Reference to last row.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("m_pDoc->MaxRow() changed, adapt unit test.", 1048575, int(m_pDoc->MaxRow()));
+    m_pDoc->SetString( 2,1,1, "=SUM(B1048576:C1048576)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong result in C1.", 3.0, m_pDoc->GetValue(2,0,1));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong result in C2.", 2.0, m_pDoc->GetValue(2,1,1));
+    // Delete last row.
+    m_pDoc->DeleteRow( ScRange( 0, m_pDoc->MaxRow(), 1, m_pDoc->MaxCol(), m_pDoc->MaxRow(), 1));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong result in C1.", 1.0, m_pDoc->GetValue(2,0,1));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Reference in C2 not invalidated.", OUString("#REF!"), m_pDoc->GetString(2,1,1));
+
+    // Enter values in A23 and AMJ23 (last column).
+    m_pDoc->SetValue( 0,22,1, 1.0);
+    m_pDoc->SetValue( m_pDoc->MaxCol(),22,1, 2.0);
+    // C3 with sticky reference including last column.
+    m_pDoc->SetString( 2,2,1, "=SUM(23:23)");
+    // C4 with reference to last column.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("m_pDoc->MaxCol() changed, adapt unit test.", 1023, int(m_pDoc->MaxCol()));
+    m_pDoc->SetString( 2,3,1, "=SUM(AMJ22:AMJ23)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong result in C3.", 3.0, m_pDoc->GetValue(2,2,1));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong result in C4.", 2.0, m_pDoc->GetValue(2,3,1));
+    // Delete last column.
+    m_pDoc->DeleteCol( ScRange( m_pDoc->MaxCol(), 0, 1, m_pDoc->MaxCol(), m_pDoc->MaxRow(), 1));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong result in C3.", 1.0, m_pDoc->GetValue(2,2,1));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Reference in C4 not invalidated.", OUString("#REF!"), m_pDoc->GetString(2,3,1));
+
+    m_pDoc->DeleteTab(1);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateSheets()
+{
+    m_pDoc->InsertTab(0, "Sheet1");
+    m_pDoc->InsertTab(1, "Sheet2");
+
+    OUString aName;
+    m_pDoc->GetName(0, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet1"), aName);
+    m_pDoc->GetName(1, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet2"), aName);
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    // Set values to B2:C3 on sheet Sheet1.
+    m_pDoc->SetValue(ScAddress(1,1,0), 1);
+    m_pDoc->SetValue(ScAddress(1,2,0), 2);
+    m_pDoc->SetValue(ScAddress(2,1,0), 3);
+    m_pDoc->SetValue(ScAddress(2,2,0), 4);
+
+    // Set formulas to B2 and B3 on sheet Sheet2.
+    m_pDoc->SetString(ScAddress(1,1,1), "=SUM(Sheet1.B2:C3)");
+    m_pDoc->SetString(ScAddress(1,2,1), "=SUM($Sheet1.$B$2:$C$3)");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,1), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,1), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Swap the sheets.
+    m_pDoc->MoveTab(0, 1);
+    m_pDoc->GetName(0, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet2"), aName);
+    m_pDoc->GetName(1, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet1"), aName);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,0), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Swap back.
+    m_pDoc->MoveTab(0, 1);
+    m_pDoc->GetName(0, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet1"), aName);
+    m_pDoc->GetName(1, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet2"), aName);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,1), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,1), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Insert a new sheet between the two.
+    m_pDoc->InsertTab(1, "Temp");
+
+    m_pDoc->GetName(1, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Temp"), aName);
+    m_pDoc->GetName(2, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet2"), aName);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,2), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,2), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Move the last sheet (Sheet2) to the first position.
+    m_pDoc->MoveTab(2, 0);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,0), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Move back.
+    m_pDoc->MoveTab(0, 2);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,2), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,2), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Move the "Temp" sheet to the last position.
+    m_pDoc->MoveTab(1, 2);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,1), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,1), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Move back.
+    m_pDoc->MoveTab(2, 1);
+
+    // Delete the temporary sheet.
+    m_pDoc->DeleteTab(1);
+
+    m_pDoc->GetName(1, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet2"), aName);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,1), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,1), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Insert a new sheet before the first one.
+    m_pDoc->InsertTab(0, "Temp");
+
+    m_pDoc->GetName(1, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet1"), aName);
+    m_pDoc->GetName(2, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet2"), aName);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,2), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,2), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Delete the temporary sheet.
+    m_pDoc->DeleteTab(0);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,1), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,1), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Append a bunch of sheets.
+    m_pDoc->InsertTab(2, "Temp1");
+    m_pDoc->InsertTab(3, "Temp2");
+    m_pDoc->InsertTab(4, "Temp3");
+
+    // Move these tabs around. This shouldn't affects the first 2 sheets.
+    m_pDoc->MoveTab(2, 4);
+    m_pDoc->MoveTab(3, 2);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,1), "SUM(Sheet1.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,1), "SUM($Sheet1.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    // Delete the temp sheets.
+    m_pDoc->DeleteTab(4);
+    m_pDoc->DeleteTab(3);
+    m_pDoc->DeleteTab(2);
+
+    // Delete Sheet1.
+    m_pDoc->DeleteTab(0);
+    m_pDoc->GetName(0, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Sheet2"), aName);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "SUM(#REF!.B2:C3)", "Wrong formula in Sheet2.B2.");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,0), "SUM($#REF!.$B$2:$C$3)", "Wrong formula in Sheet2.B3.");
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateInsertRows()
+{
+    setExpandRefs(false);
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Formula");
+
+    // Insert raw values in B2:B4.
+    m_pDoc->SetValue(ScAddress(1,1,0), 1.0);
+    m_pDoc->SetValue(ScAddress(1,2,0), 2.0);
+    m_pDoc->SetValue(ScAddress(1,3,0), 3.0);
+
+    // Insert a formula in B5 to sum up B2:B4.
+    m_pDoc->SetString(ScAddress(1,4,0), "=SUM(B2:B4)");
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(1,4,0)));
+
+    // Insert rows over rows 1:2.
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    rFunc.InsertCells(ScRange(0,0,0,m_pDoc->MaxCol(),1,0), &aMark, INS_INSROWS_BEFORE, false, true);
+
+    // The raw data should have shifted to B4:B6.
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(1,3,0)));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(1,4,0)));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(1,5,0)));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,6,0), "SUM(B4:B6)", "Wrong formula!");
+
+    // Clear and start over.
+    clearSheet(m_pDoc, 0);
+
+    // Set raw values in A4:A6.
+    m_pDoc->SetValue(ScAddress(0,3,0), 1.0);
+    m_pDoc->SetValue(ScAddress(0,4,0), 2.0);
+    m_pDoc->SetValue(ScAddress(0,5,0), 3.0);
+
+    // Set formula in A3 to reference A4:A6.
+    m_pDoc->SetString(ScAddress(0,2,0), "=MAX(A4:A6)");
+
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,2,0)));
+
+    // Insert 3 rows over 2:4.  This should push A3:A6 to A6:A9.
+    rFunc.InsertCells(ScRange(0,1,0,m_pDoc->MaxCol(),3,0), &aMark, INS_INSROWS_BEFORE, false, true);
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(0,5,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("This formula cell should not be an error.", 0, static_cast<int>(pFC->GetErrCode()));
+    ASSERT_DOUBLES_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "MAX(A7:A9)", "Wrong formula!");
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateSheetsDelete()
+{
+    m_pDoc->InsertTab(0, "Sheet1");
+    m_pDoc->InsertTab(1, "Sheet2");
+    m_pDoc->InsertTab(2, "Sheet3");
+    m_pDoc->InsertTab(3, "Sheet4");
+
+    m_pDoc->SetString(ScAddress(4,1,0), "=SUM(Sheet2.A4:Sheet4.A4)");
+    m_pDoc->SetString(ScAddress(4,2,0), "=SUM($Sheet2.A4:$Sheet4.A4)");
+    m_pDoc->DeleteTab(1);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(4,1,0), "SUM(Sheet3.A4:Sheet4.A4)", "Wrong Formula");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(4,2,0), "SUM($Sheet3.A4:$Sheet4.A4)", "Wrong Formula");
+
+    m_pDoc->InsertTab(1, "Sheet2");
+
+    m_pDoc->SetString(ScAddress(5,1,3), "=SUM(Sheet1.A5:Sheet3.A5)");
+    m_pDoc->SetString(ScAddress(5,2,3), "=SUM($Sheet1.A5:$Sheet3.A5)");
+    m_pDoc->DeleteTab(2);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(5,1,2), "SUM(Sheet1.A5:Sheet2.A5)", "Wrong Formula");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(5,2,2), "SUM($Sheet1.A5:$Sheet2.A5)", "Wrong Formula");
+
+    m_pDoc->InsertTab(2, "Sheet3");
+
+    m_pDoc->SetString(ScAddress(6,1,3), "=SUM(Sheet1.A6:Sheet3.A6)");
+    m_pDoc->SetString(ScAddress(6,2,3), "=SUM($Sheet1.A6:$Sheet3.A6)");
+    m_pDoc->DeleteTabs(0,3);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(6,1,0), "SUM(#REF!.A6:#REF!.A6)", "Wrong Formula");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(6,2,0), "SUM($#REF!.A6:$#REF!.A6)", "Wrong Formula");
+
+    m_pDoc->InsertTab(0, "Sheet1");
+    m_pDoc->InsertTab(1, "Sheet2");
+    m_pDoc->InsertTab(2, "Sheet3");
+
+    m_pDoc->SetString(ScAddress(1,1,1), "=SUM(Sheet1.A2:Sheet3.A2");
+    m_pDoc->SetString(ScAddress(2,1,1), "=SUM(Sheet1.A1:Sheet2.A1");
+    m_pDoc->SetString(ScAddress(3,1,1), "=SUM(Sheet2.A3:Sheet4.A3");
+
+    m_pDoc->SetString(ScAddress(1,2,1), "=SUM($Sheet1.A2:$Sheet3.A2");
+    m_pDoc->SetString(ScAddress(2,2,1), "=SUM($Sheet1.A1:$Sheet2.A1");
+    m_pDoc->SetString(ScAddress(3,2,1), "=SUM($Sheet2.A3:$Sheet4.A3");
+
+    m_pDoc->DeleteTab(2);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,1), "SUM(Sheet1.A2:Sheet2.A2)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,1,1), "SUM(Sheet1.A1:Sheet2.A1)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,1,1), "SUM(Sheet2.A3:Sheet4.A3)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,1), "SUM($Sheet1.A2:$Sheet2.A2)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,2,1), "SUM($Sheet1.A1:$Sheet2.A1)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,2,1), "SUM($Sheet2.A3:$Sheet4.A3)", "Wrong Formula");
+
+    m_pDoc->DeleteTab(0);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "SUM(Sheet2.A2:Sheet2.A2)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,1,0), "SUM(Sheet2.A1:Sheet2.A1)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,1,0), "SUM(Sheet2.A3:Sheet4.A3)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,0), "SUM($Sheet2.A2:$Sheet2.A2)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,2,0), "SUM($Sheet2.A1:$Sheet2.A1)", "Wrong Formula");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,2,0), "SUM($Sheet2.A3:$Sheet4.A3)", "Wrong Formula");
+
+    m_pDoc->DeleteTab(0);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateInsertColumns()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    setExpandRefs(false);
+
+    m_pDoc->InsertTab(0, "Formula");
+
+    // Set named range for B2 with absolute column and relative same row.
+    const ScAddress aNamePos(0,1,0);
+    bool bInserted = m_pDoc->InsertNewRangeName("RowRelativeRange", aNamePos, "$Formula.$B2");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Set named range for entire absolute column B.
+    bInserted = m_pDoc->InsertNewRangeName("EntireColumn", aNamePos, "$B:$B");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Set named range for entire absolute row 2.
+    bInserted = m_pDoc->InsertNewRangeName("EntireRow", aNamePos, "$2:$2");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Set values in B1:B3.
+    m_pDoc->SetValue(ScAddress(1,0,0), 1.0);
+    m_pDoc->SetValue(ScAddress(1,1,0), 2.0);
+    m_pDoc->SetValue(ScAddress(1,2,0), 3.0);
+
+    // Reference them in B4.
+    m_pDoc->SetString(ScAddress(1,3,0), "=SUM(B1:B3)");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(1,3,0)));
+
+    // Use named range in C2 to reference B2.
+    m_pDoc->SetString(ScAddress(2,1,0), "=RowRelativeRange");
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+
+    // Use named range in C3 to reference column B, values in B1,B2,B3,B4
+    m_pDoc->SetString(ScAddress(2,2,0), "=SUM(EntireColumn)");
+    CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(ScAddress(2,2,0)));
+
+    // Use named range in C4 to reference row 2, values in B2 and C2.
+    m_pDoc->SetString(ScAddress(2,3,0), "=SUM(EntireRow)");
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(2,3,0)));
+
+    // Insert columns over A:B.
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    rFunc.InsertCells(ScRange(0,0,0,1,m_pDoc->MaxRow(),0), &aMark, INS_INSCOLS_BEFORE, false, true);
+
+    // Now, the original column B has moved to column D.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,3,0), "SUM(D1:D3)", "Wrong formula in D4 after column insertion.");
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(3,3,0)));
+
+    // Check that the named reference points to the moved cell, now D2.
+    ScRangeData* pName = m_pDoc->GetRangeName()->findByUpperName("ROWRELATIVERANGE");
+    CPPUNIT_ASSERT(pName);
+    OUString aSymbol;
+    pName->GetSymbol(aSymbol, aNamePos, formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL(OUString("$Formula.$D2"), aSymbol);
+
+    // Check that the formula using the name, now in E2, still has the same result.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(4,1,0), "RowRelativeRange", "Wrong formula in E2 after column insertion.");
+
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(4,1,0)));
+
+    // Check that the named column reference points to the moved column, now D.
+    pName = m_pDoc->GetRangeName()->findByUpperName("ENTIRECOLUMN");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol(aSymbol, aNamePos, formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL(OUString("$D:$D"), aSymbol);
+
+    // Check that the formula using the name, now in E3, still has the same result.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(4,2,0), "SUM(EntireColumn)", "Wrong formula in E3 after column insertion.");
+
+    CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(ScAddress(4,2,0)));
+
+    // Check that the named row reference still points to the same entire row
+    // and does not have a #REF! error due to inserted columns.
+    pName = m_pDoc->GetRangeName()->findByUpperName("ENTIREROW");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol(aSymbol, aNamePos, formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL(OUString("$2:$2"), aSymbol);
+
+    // Check that the formula using the name, now in E4, still has the same result.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(4,3,0), "SUM(EntireRow)", "Wrong formula in E4 after column insertion.");
+
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(4,3,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateMove()
+{
+    m_pDoc->InsertTab(0, "Sheet1");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    // Set value to B4:B6.
+    m_pDoc->SetValue(ScAddress(1,3,0), 1);
+    m_pDoc->SetValue(ScAddress(1,4,0), 2);
+    m_pDoc->SetValue(ScAddress(1,5,0), 3);
+
+    // Set formulas to A9:A12 that references B4:B6.
+    m_pDoc->SetString(ScAddress(0,8,0), "=SUM(B4:B6)");
+    m_pDoc->SetString(ScAddress(0,9,0), "=SUM($B$4:$B$6)");
+    m_pDoc->SetString(ScAddress(0,10,0), "=B5");
+    m_pDoc->SetString(ScAddress(0,11,0), "=$B$6");
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(0,8,0));
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(0,9,0));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(0,10,0));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(0,11,0));
+
+    // Move B4:B6 to D4 (two columns to the right).
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(1,3,0,1,5,0), ScAddress(3,3,0), true, false, false, false);
+    CPPUNIT_ASSERT_MESSAGE("Failed to move B4:B6.", bMoved);
+
+    // The results of the formula cells that reference the moved range should remain the same.
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(0,8,0));
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(0,9,0));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(0,10,0));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(0,11,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,8,0), "SUM(D4:D6)", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,9,0), "SUM($D$4:$D$6)", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,10,0), "D5", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,11,0), "$D$6", "Wrong formula.");
+
+    // Move A9:A12 to B10:B13.
+    bMoved = rFunc.MoveBlock(ScRange(0,8,0,0,11,0), ScAddress(1,9,0), true, false, false, false);
+    CPPUNIT_ASSERT_MESSAGE("Failed to move A9:A12 to B10:B13", bMoved);
+
+    // The results of these formula cells should still stay the same.
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(1,9,0));
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(1,10,0));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(1,11,0));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(1,12,0));
+
+    // Displayed formulas should stay the same since the referenced range hasn't moved.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,9,0), "SUM(D4:D6)", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,10,0), "SUM($D$4:$D$6)", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,11,0), "D5", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,12,0), "$D$6", "Wrong formula.");
+
+    // The value cells are in D4:D6. Move D4:D5 to the right but leave D6
+    // where it is.
+    bMoved = rFunc.MoveBlock(ScRange(3,3,0,3,4,0), ScAddress(4,3,0), true, false, false, false);
+    CPPUNIT_ASSERT_MESSAGE("Failed to move D4:D5 to E4:E5", bMoved);
+
+    // Only the values of B10 and B11 should be updated.
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(1,9,0));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(1,10,0));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(1,11,0));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(1,12,0));
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,9,0), "SUM(D4:D6)", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,10,0), "SUM($D$4:$D$6)", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,11,0), "E5", "Wrong formula.");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,12,0), "$D$6", "Wrong formula.");
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateMoveUndo()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    // Set values in A1:A4.
+    m_pDoc->SetValue(ScAddress(0,0,0), 1.0);
+    m_pDoc->SetValue(ScAddress(0,1,0), 2.0);
+    m_pDoc->SetValue(ScAddress(0,2,0), 3.0);
+    m_pDoc->SetValue(ScAddress(0,3,0), 4.0);
+
+    // Set formulas with single cell references in A6:A8.
+    m_pDoc->SetString(ScAddress(0,5,0), "=A1");
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "A1", "Wrong formula.");
+
+    m_pDoc->SetString(ScAddress(0,6,0), "=A1+A2+A3");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,6,0), "A1+A2+A3", "Wrong formula.");
+
+    m_pDoc->SetString(ScAddress(0,7,0), "=A1+A3+A4");
+    CPPUNIT_ASSERT_EQUAL(8.0, m_pDoc->GetValue(ScAddress(0,7,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,7,0), "A1+A3+A4", "Wrong formula.");
+
+    // Set formulas with range references in A10:A12.
+    m_pDoc->SetString(ScAddress(0,9,0), "=SUM(A1:A2)");
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,9,0), "SUM(A1:A2)", "Wrong formula.");
+
+    m_pDoc->SetString(ScAddress(0,10,0), "=SUM(A1:A3)");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,10,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,10,0), "SUM(A1:A3)", "Wrong formula.");
+
+    m_pDoc->SetString(ScAddress(0,11,0), "=SUM(A1:A4)");
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,11,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,11,0), "SUM(A1:A4)", "Wrong formula.");
+
+    // Move A1:A3 to C1:C3. Note that A4 remains.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(0,0,0,0,2,0), ScAddress(2,0,0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "C1", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,6,0), "C1+C2+C3", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(8.0, m_pDoc->GetValue(ScAddress(0,7,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,7,0), "C1+C3+A4", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,9,0), "SUM(C1:C2)", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,10,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,10,0), "SUM(C1:C3)", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(0,11,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,11,0), "SUM(A1:A4)", "Wrong formula.");
+
+    // Undo the move.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+    pUndoMgr->Undo();
+
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,5,0), "A1", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,6,0), "A1+A2+A3", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(8.0, m_pDoc->GetValue(ScAddress(0,7,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,7,0), "A1+A3+A4", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,9,0), "SUM(A1:A2)", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,10,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,10,0), "SUM(A1:A3)", "Wrong formula.");
+
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,11,0)));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,11,0), "SUM(A1:A4)","Wrong formula." );
+
+    // Make sure the broadcasters are still valid by changing the value of A1.
+    m_pDoc->SetValue(ScAddress(0,0,0), 20);
+
+    CPPUNIT_ASSERT_EQUAL(20.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    CPPUNIT_ASSERT_EQUAL(25.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+    CPPUNIT_ASSERT_EQUAL(27.0, m_pDoc->GetValue(ScAddress(0,7,0)));
+
+    CPPUNIT_ASSERT_EQUAL(22.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+    CPPUNIT_ASSERT_EQUAL(25.0, m_pDoc->GetValue(ScAddress(0,10,0)));
+    CPPUNIT_ASSERT_EQUAL(29.0, m_pDoc->GetValue(ScAddress(0,11,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateMoveUndo2()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    std::vector<std::vector<const char*>> aData = {
+        { "1", "2", "=A2*10",      "=SUM(A1:B1)" },
+        { "3", "4", "=SUM(A2:B2)", "=SUM(A2:B2)" },
+        { "=SUM(A1:B1)" },
+    };
+
+    ScRange aOutRange = insertRangeData(m_pDoc, ScAddress(0,0,0), aData);
+
+    std::vector<std::vector<const char*>> aCheckInitial = {
+        { "1",     "2",    "30",     "3" },
+        { "3",     "4",     "7",     "7" },
+        { "3", nullptr, nullptr, nullptr },
+    };
+
+    bool bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "initial data");
+    CPPUNIT_ASSERT(bGood);
+
+    // D1:D2 should be grouped.
+    const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(3,0,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(SCROW(2), pFC->GetSharedLength());
+
+    // Drag A1:B1 into A2:B2 thereby overwriting the old A2:B2 content.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(0,0,0,1,0,0), ScAddress(0,1,0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    std::vector<std::vector<const char*>> aCheckAfter = {
+        { nullptr, nullptr,    "10",     "3" },
+        {     "1",     "2",     "3",     "3" },
+        {     "3", nullptr, nullptr, nullptr },
+    };
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "A1:B1 moved to A2:B2");
+    CPPUNIT_ASSERT(bGood);
+
+    // Undo the move.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+    pUndoMgr->Undo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "after undo");
+    CPPUNIT_ASSERT(bGood);
+
+    // D1:D2 should be grouped.
+    pFC = m_pDoc->GetFormulaCell(ScAddress(3,0,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(SCROW(2), pFC->GetSharedLength());
+
+    // Redo and check.
+    pUndoMgr->Redo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "after redo");
+    CPPUNIT_ASSERT(bGood);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateMoveUndo3NonShared()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    std::vector<std::vector<const char*>> aData = {
+        { "10",       nullptr,  nullptr },
+        { "=A1",      nullptr,  nullptr },
+        { "=A2+A1",   nullptr,  nullptr },
+    };
+
+    ScRange aOutRange = insertRangeData(m_pDoc, ScAddress(0,0,0), aData);
+
+    std::vector<std::vector<const char*>> aCheckInitial = {
+        { "10", nullptr,  nullptr },
+        { "10", nullptr,  nullptr },
+        { "20", nullptr,  nullptr },
+    };
+
+    bool bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "initial data");
+    CPPUNIT_ASSERT(bGood);
+
+    // Drag A2:A3 into C2:C3.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(0,1,0,0,2,0), ScAddress(2,1,0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    std::vector<std::vector<const char*>> aCheckAfter = {
+        { "10",    nullptr, nullptr},
+        { nullptr, nullptr, "10" },
+        { nullptr, nullptr, "20" },
+    };
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "A2:A3 moved to C2:C3");
+    CPPUNIT_ASSERT(bGood);
+
+    // Undo the move.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+    pUndoMgr->Undo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "after undo");
+    CPPUNIT_ASSERT(bGood);
+
+    // Redo and check.
+    pUndoMgr->Redo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "after redo");
+    CPPUNIT_ASSERT(bGood);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateMoveUndo3Shared()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    std::vector<std::vector<const char*>> aData = {
+        { "10",       nullptr,  nullptr },
+        { "=A1",      nullptr,  nullptr },
+        { "=A2+$A$1", nullptr,  nullptr },
+        { "=A3+$A$1", nullptr,  nullptr },
+    };
+
+    ScRange aOutRange = insertRangeData(m_pDoc, ScAddress(0,0,0), aData);
+
+    std::vector<std::vector<const char*>> aCheckInitial = {
+        { "10", nullptr,  nullptr },
+        { "10", nullptr,  nullptr },
+        { "20", nullptr,  nullptr },
+        { "30", nullptr,  nullptr },
+    };
+
+    bool bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "initial data");
+    CPPUNIT_ASSERT(bGood);
+
+    // A3:A4 should be grouped.
+    const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(0,2,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(SCROW(2), pFC->GetSharedLength());
+
+    // Drag A2:A4 into C2:C4.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(0,1,0,0,3,0), ScAddress(2,1,0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    std::vector<std::vector<const char*>> aCheckAfter = {
+        { "10",    nullptr, nullptr},
+        { nullptr, nullptr, "10" },
+        { nullptr, nullptr, "20" },
+        { nullptr, nullptr, "30" },
+    };
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "A2:A4 moved to C2:C4");
+    CPPUNIT_ASSERT(bGood);
+
+    // C3:C4 should be grouped.
+    pFC = m_pDoc->GetFormulaCell(ScAddress(2,2,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(SCROW(2), pFC->GetSharedLength());
+
+    // Undo the move.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+    pUndoMgr->Undo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "after undo");
+    CPPUNIT_ASSERT(bGood);
+
+    // A3:A4 should be grouped.
+    pFC = m_pDoc->GetFormulaCell(ScAddress(0,2,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(SCROW(2), pFC->GetSharedLength());
+
+    // Redo and check.
+    pUndoMgr->Redo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "after redo");
+    CPPUNIT_ASSERT(bGood);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateMoveUndoDependents()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    std::vector<std::vector<const char*>> aData = {
+        { "1"           },
+        { "22"          },
+        { "3"           },
+        { "4"           },
+        { "5"           },
+        { "=SUM(C1:C5)" },
+        { "=C6"         },
+    };
+
+    ScRange aOutRange = insertRangeData(m_pDoc, ScAddress(2,0,0), aData);
+
+    std::vector<std::vector<const char*>> aCheckInitial = {
+        { "1"   },
+        { "22"  },
+        { "3"   },
+        { "4"   },
+        { "5"   },
+        { "35"  },
+        { "35"  },
+    };
+
+    bool bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "initial data");
+    CPPUNIT_ASSERT(bGood);
+
+    // Drag C2 into D2.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(2, 1, 0, 2, 1, 0), ScAddress(3, 1, 0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    std::vector<std::vector<const char*>> aCheckAfter = {
+        { "1"     },
+        { nullptr },
+        { "3"     },
+        { "4"     },
+        { "5"     },
+        { "13"    },
+        { "13"    },
+    };
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "C2 moved to D2");
+    CPPUNIT_ASSERT(bGood);
+
+    // Undo the move.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+    pUndoMgr->Undo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "after undo");
+    CPPUNIT_ASSERT(bGood);
+
+    // Redo and check.
+    pUndoMgr->Redo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "after redo");
+    CPPUNIT_ASSERT(bGood);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateMoveUndo4()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    std::vector<std::vector<const char*>> aData = {
+        { "1",  nullptr,  "=B1", "=A1" },
+        { "2",  nullptr,  "=B2", "=A2" },
+    };
+
+    ScRange aOutRange = insertRangeData(m_pDoc, ScAddress(0,0,0), aData);
+
+    std::vector<std::vector<const char*>> aCheckInitial = {
+        { "1",  nullptr,  "0", "1" },
+        { "2",  nullptr,  "0", "2" },
+    };
+
+    bool bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "initial data");
+    CPPUNIT_ASSERT(bGood);
+
+    // Drag A1:A2 into B1:B2.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(0, 0, 0, 0, 1, 0), ScAddress(1, 0, 0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    std::vector<std::vector<const char*>> aCheckAfter = {
+        { nullptr, "1", "1", "1" },
+        { nullptr, "2", "2", "2" },
+    };
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "A1:A2 moved to B1:B2");
+    CPPUNIT_ASSERT(bGood);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,0,0), "B1", "Wrong formula"); // C1
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,1,0), "B2", "Wrong formula"); // C2
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,0,0), "B1", "Wrong formula"); // D1
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,1,0), "B2", "Wrong formula"); // D2
+
+    // Undo the move.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+    pUndoMgr->Undo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckInitial, "after undo");
+    CPPUNIT_ASSERT(bGood);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,0,0), "B1", "Wrong formula"); // C1
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,1,0), "B2", "Wrong formula"); // C2
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,0,0), "A1", "Wrong formula"); // D1
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,1,0), "A2", "Wrong formula"); // D2
+
+    // Redo and check.
+    pUndoMgr->Redo();
+
+    bGood = checkOutput(m_pDoc, aOutRange, aCheckAfter, "after redo");
+    CPPUNIT_ASSERT(bGood);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,0,0), "B1", "Wrong formula"); // C1
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(2,1,0), "B2", "Wrong formula"); // C2
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,0,0), "B1", "Wrong formula"); // D1
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(3,1,0), "B2", "Wrong formula"); // D2
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateMoveToSheet()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Sheet1");
+    m_pDoc->InsertTab(1, "Sheet2");
+
+    // Set values to A1:A2 on Sheet1, and B1:B2 to reference them.
+    m_pDoc->SetValue(ScAddress(0,0,0), 11);
+    m_pDoc->SetValue(ScAddress(0,1,0), 12);
+    m_pDoc->SetString(ScAddress(1,0,0), "=A1");
+    m_pDoc->SetString(ScAddress(1,1,0), "=A2");
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,0,0), "A1", "Wrong formula");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "A2", "Wrong formula");
+
+    CPPUNIT_ASSERT_EQUAL(11.0, m_pDoc->GetValue(ScAddress(1,0,0)));
+    CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(ScAddress(1,1,0)));
+
+    // Move A1:A2 on Sheet1 to B3:B4 on Sheet2.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(0,0,0,0,1,0), ScAddress(1,2,1), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,0,0), "Sheet2.B3", "Wrong formula");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "Sheet2.B4", "Wrong formula");
+
+    // Undo and check again.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    pUndoMgr->Undo();
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,0,0), "A1", "Wrong formula");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "A2", "Wrong formula");
+
+    // Redo and check.
+    pUndoMgr->Redo();
+
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,0,0), "Sheet2.B3", "Wrong formula");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "Sheet2.B4", "Wrong formula");
+
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateDeleteContent()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Test");
+
+    // Set value in B2.
+    m_pDoc->SetValue(ScAddress(1,1,0), 2.0);
+    // Set formula in C2 to reference B2.
+    m_pDoc->SetString(ScAddress(2,1,0), "=B2");
+
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+
+    // Delete B2.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SetMarkArea(ScAddress(1,1,0));
+    rFunc.DeleteContents(aMark, InsertDeleteFlags::CONTENTS, true, true);
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("B2 should be empty.", CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(1,1,0)));
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+
+    // Undo and check the result of C2.
+    pUndoMgr->Undo();
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(1,1,0))); // B2
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(2,1,0))); // C2
+
+    // Redo and check.
+    pUndoMgr->Redo();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("B2 should be empty.", CELLTYPE_NONE, m_pDoc->GetCellType(ScAddress(1,1,0)));
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateDeleteAndShiftLeft()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Test");
+
+    // Insert 1,2,3,4,5 in C1:G1.
+    for (SCCOL i = 0; i <= 4; ++i)
+        m_pDoc->SetValue(ScAddress(i+2,0,0), i+1);
+
+    // Insert formula in H1.
+    ScAddress aPos(7,0,0);
+    m_pDoc->SetString(aPos, "=SUM(C1:G1)");
+
+    CPPUNIT_ASSERT_EQUAL(15.0, m_pDoc->GetValue(aPos));
+
+    // Delete columns D:E (middle of the reference).
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bDeleted = rFunc.DeleteCells(ScRange(3,0,0,4,m_pDoc->MaxRow(),0), &aMark, DelCellCmd::CellsLeft, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    aPos.IncCol(-2);
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:E1)", "Wrong formula!");
+
+    // Undo and check.
+    SfxUndoManager* pUndo = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndo);
+
+    pUndo->Undo();
+    aPos.IncCol(2);
+    CPPUNIT_ASSERT_EQUAL(15.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:G1)", "Wrong formula!");
+
+    // Delete columns C:D (left end of the reference).
+    bDeleted = rFunc.DeleteCells(ScRange(2,0,0,3,m_pDoc->MaxRow(),0), &aMark, DelCellCmd::CellsLeft, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    aPos.IncCol(-2);
+    CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:E1)", "Wrong formula!");
+
+    // Undo and check again.
+    pUndo->Undo();
+    aPos.IncCol(2);
+    CPPUNIT_ASSERT_EQUAL(15.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:G1)", "Wrong formula!");
+
+    // Delete columns B:E (overlaps on the left).
+    bDeleted = rFunc.DeleteCells(ScRange(1,0,0,4,m_pDoc->MaxRow(),0), &aMark, DelCellCmd::CellsLeft, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    aPos.IncCol(-4);
+    CPPUNIT_ASSERT_EQUAL(9.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B1:C1)", "Wrong formula!");
+
+    // Undo and check again.
+    pUndo->Undo();
+    aPos.IncCol(4);
+    CPPUNIT_ASSERT_EQUAL(15.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:G1)", "Wrong formula!");
+
+    // Start over with a new scenario.
+    clearSheet(m_pDoc, 0);
+
+    // Insert 1,2,3,4,5,6 into C1:H1.
+    for (SCCOL i = 0; i <= 5; ++i)
+        m_pDoc->SetValue(ScAddress(i+2,0,0), i+1);
+
+    // Set formula in B1.
+    aPos = ScAddress(1,0,0);
+    m_pDoc->SetString(aPos, "=SUM(C1:H1)");
+    CPPUNIT_ASSERT_EQUAL(21.0, m_pDoc->GetValue(aPos));
+
+    // Delete columns F:H (right end of the reference).
+    bDeleted = rFunc.DeleteCells(ScRange(5,0,0,7,m_pDoc->MaxRow(),0), &aMark, DelCellCmd::CellsLeft, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:E1)", "Wrong formula!");
+
+    // Undo and check.
+    pUndo->Undo();
+    CPPUNIT_ASSERT_EQUAL(21.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:H1)", "Wrong formula!");
+
+    // Delete columns G:I (overlaps on the right).
+    bDeleted = rFunc.DeleteCells(ScRange(6,0,0,8,m_pDoc->MaxRow(),0), &aMark, DelCellCmd::CellsLeft, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:F1)", "Wrong formula!");
+
+    // Undo and check again.
+    pUndo->Undo();
+    CPPUNIT_ASSERT_EQUAL(21.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(C1:H1)", "Wrong formula!");
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateDeleteAndShiftLeft2()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Test");
+
+    std::vector<std::vector<const char*>> aData = {
+        { "1", "=COUNT($A$1:$A$4)", "=COUNT(A1)" },
+        { "2", "=COUNT($A$1:$A$4)", "=COUNT(A2)" },
+        { "3", "=COUNT($A$1:$A$4)", "=COUNT(A3)" },
+        { "4", "=COUNT($A$1:$A$4)", "=COUNT(A4)" },
+    };
+
+    insertRangeData(m_pDoc, ScAddress(), aData);
+
+    auto funcCheckOriginal = [&]()
+    {
+        CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,0,0))); // A1
+        CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(0,1,0))); // A2
+        CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,2,0))); // A3
+        CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(0,3,0))); // A4
+
+        CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(1,0,0))); // B1
+        CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(1,1,0))); // B2
+        CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(1,2,0))); // B3
+        CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(1,3,0))); // B4
+
+        CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(2,0,0))); // C1
+        CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(2,1,0))); // C2
+        CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(2,2,0))); // C3
+        CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(2,3,0))); // C4
+    };
+
+    auto funcCheckDeleted = [&]()
+    {
+        CPPUNIT_ASSERT_EQUAL(OUString("#REF!"), m_pDoc->GetString(ScAddress(0,0,0))); // A1
+        CPPUNIT_ASSERT_EQUAL(OUString("#REF!"), m_pDoc->GetString(ScAddress(0,1,0))); // A2
+        CPPUNIT_ASSERT_EQUAL(OUString("#REF!"), m_pDoc->GetString(ScAddress(0,2,0))); // A3
+        CPPUNIT_ASSERT_EQUAL(OUString("#REF!"), m_pDoc->GetString(ScAddress(0,3,0))); // A4
+
+        CPPUNIT_ASSERT_EQUAL(OUString("#REF!"), m_pDoc->GetString(ScAddress(1,0,0))); // B1
+        CPPUNIT_ASSERT_EQUAL(OUString("#REF!"), m_pDoc->GetString(ScAddress(1,1,0))); // B2
+        CPPUNIT_ASSERT_EQUAL(OUString("#REF!"), m_pDoc->GetString(ScAddress(1,2,0))); // B3
+        CPPUNIT_ASSERT_EQUAL(OUString("#REF!"), m_pDoc->GetString(ScAddress(1,3,0))); // B4
+    };
+
+    funcCheckOriginal();
+
+    // Delete Column A.
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bDeleted = rFunc.DeleteCells(ScRange(0,0,0,0,m_pDoc->MaxRow(),0), &aMark, DelCellCmd::CellsLeft, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    funcCheckDeleted();
+
+    // Undo and check.
+    SfxUndoManager* pUndo = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndo);
+
+    pUndo->Undo();
+    funcCheckOriginal();
+
+    // Redo and check.
+    pUndo->Redo();
+    funcCheckDeleted();
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateDeleteAndShiftUp()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Test");
+
+    // Insert 1,2,3,4,5 in A3:A7.
+    for (SCROW i = 0; i <= 4; ++i)
+        m_pDoc->SetValue(ScAddress(0,i+2,0), i+1);
+
+    // Insert formula in A8.
+    ScAddress aPos(0,7,0);
+    m_pDoc->SetString(aPos, "=SUM(A3:A7)");
+
+    CPPUNIT_ASSERT_EQUAL(15.0, m_pDoc->GetValue(aPos));
+
+    // Delete rows 4:5 (middle of the reference).
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bDeleted = rFunc.DeleteCells(ScRange(0,3,0,m_pDoc->MaxCol(),4,0), &aMark, DelCellCmd::CellsUp, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    aPos.IncRow(-2);
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A5)", "Wrong formula!");
+
+    // Undo and check.
+    SfxUndoManager* pUndo = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndo);
+
+    pUndo->Undo();
+    aPos.IncRow(2);
+    CPPUNIT_ASSERT_EQUAL(15.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A7)", "Wrong formula!");
+
+    // Delete rows 3:4 (top end of the reference).
+    bDeleted = rFunc.DeleteCells(ScRange(0,2,0,m_pDoc->MaxCol(),3,0), &aMark, DelCellCmd::CellsUp, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    aPos.IncRow(-2);
+    CPPUNIT_ASSERT_EQUAL(12.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A5)", "Wrong formula!");
+
+    // Undo and check again.
+    pUndo->Undo();
+    aPos.IncRow(2);
+    CPPUNIT_ASSERT_EQUAL(15.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A7)", "Wrong formula!");
+
+    // Delete rows 2:5 (overlaps on the top).
+    bDeleted = rFunc.DeleteCells(ScRange(0,1,0,m_pDoc->MaxCol(),4,0), &aMark, DelCellCmd::CellsUp, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    aPos.IncRow(-4);
+    CPPUNIT_ASSERT_EQUAL(9.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A2:A3)", "Wrong formula!");
+
+    // Undo and check again.
+    pUndo->Undo();
+    aPos.IncRow(4);
+    CPPUNIT_ASSERT_EQUAL(15.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A7)", "Wrong formula!");
+
+    // Start over with a new scenario.
+    clearSheet(m_pDoc, 0);
+
+    // Insert 1,2,3,4,5,6 into A3:A8.
+    for (SCROW i = 0; i <= 5; ++i)
+        m_pDoc->SetValue(ScAddress(0,i+2,0), i+1);
+
+    // Set formula in B1.
+    aPos = ScAddress(0,1,0);
+    m_pDoc->SetString(aPos, "=SUM(A3:A8)");
+    CPPUNIT_ASSERT_EQUAL(21.0, m_pDoc->GetValue(aPos));
+
+    // Delete rows 6:8 (bottom end of the reference).
+    bDeleted = rFunc.DeleteCells(ScRange(0,5,0,m_pDoc->MaxCol(),7,0), &aMark, DelCellCmd::CellsUp, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A5)", "Wrong formula!");
+
+    // Undo and check.
+    pUndo->Undo();
+    CPPUNIT_ASSERT_EQUAL(21.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A8)", "Wrong formula!");
+
+    // Delete rows 7:9 (overlaps on the bottom).
+    bDeleted = rFunc.DeleteCells(ScRange(0,6,0,m_pDoc->MaxCol(),8,0), &aMark, DelCellCmd::CellsUp, true);
+    CPPUNIT_ASSERT(bDeleted);
+
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A6)", "Wrong formula!");
+
+    // Undo and check again.
+    pUndo->Undo();
+    CPPUNIT_ASSERT_EQUAL(21.0, m_pDoc->GetValue(aPos));
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A3:A8)", "Wrong formula!");
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateName()
+{
+    m_pDoc->InsertTab(0, "Formula");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    // Fill C2:C5 with values.
+    m_pDoc->SetValue(ScAddress(2,1,0), 1);
+    m_pDoc->SetValue(ScAddress(2,2,0), 2);
+    m_pDoc->SetValue(ScAddress(2,3,0), 3);
+    m_pDoc->SetValue(ScAddress(2,4,0), 4);
+
+    // Add a named expression that references the immediate left cell.
+    ScRangeName* pGlobalNames = m_pDoc->GetRangeName();
+    CPPUNIT_ASSERT_MESSAGE("Failed to obtain global named expression object.", pGlobalNames);
+    ScRangeData* pName = new ScRangeData(
+        m_pDoc, "ToLeft", "RC[-1]", ScAddress(2,1,0),
+        ScRangeData::Type::Name, formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1);
+
+    bool bInserted = pGlobalNames->insert(pName);
+    CPPUNIT_ASSERT_MESSAGE("Failed to insert a new name.", bInserted);
+
+    // Insert formulas in D2:D5 using the named expression.
+    m_pDoc->SetString(ScAddress(3,1,0), "=ToLeft");
+    m_pDoc->SetString(ScAddress(3,2,0), "=ToLeft");
+    m_pDoc->SetString(ScAddress(3,3,0), "=ToLeft");
+    m_pDoc->SetString(ScAddress(3,4,0), "=ToLeft");
+
+    // Make sure the results are correct.
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(3,1,0));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(3,2,0));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(3,3,0));
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(3,4,0));
+
+    // Push cells in column C down by one cell.
+    m_pDoc->InsertRow(ScRange(2,0,0,2,0,0));
+
+    // Make sure the results change accordingly.
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(3,1,0));
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(3,2,0));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(3,3,0));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(3,4,0));
+
+    // Move cells back.
+    m_pDoc->DeleteRow(ScRange(2,0,0,2,0,0));
+
+    // Make sure the results are back as well.
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(3,1,0));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(3,2,0));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(3,3,0));
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(3,4,0));
+
+    // Fill B10:B12 with values.
+    m_pDoc->SetValue(ScAddress(1,9,0), 10);
+    m_pDoc->SetValue(ScAddress(1,10,0), 11);
+    m_pDoc->SetValue(ScAddress(1,11,0), 12);
+
+    // Insert a new named expression that references these values as absolute range.
+    pName = new ScRangeData(
+        m_pDoc, "MyRange", "$B$10:$B$12", ScAddress(0,0,0), ScRangeData::Type::Name, formula::FormulaGrammar::GRAM_NATIVE);
+    bInserted = pGlobalNames->insert(pName);
+    CPPUNIT_ASSERT_MESSAGE("Failed to insert a new name.", bInserted);
+
+    // Set formula at C8 that references this named expression.
+    m_pDoc->SetString(ScAddress(2,7,0), "=SUM(MyRange)");
+    CPPUNIT_ASSERT_EQUAL(33.0, m_pDoc->GetValue(ScAddress(2,7,0)));
+
+    // Shift B10:B12 to right by 2 columns.
+    m_pDoc->InsertCol(ScRange(1,9,0,2,11,0));
+
+    // This should shift the absolute range B10:B12 that MyRange references.
+    pName = pGlobalNames->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT_MESSAGE("Failed to find named expression 'MyRange' in the global scope.", pName);
+    OUString aExpr;
+    pName->GetSymbol(aExpr);
+    CPPUNIT_ASSERT_EQUAL(OUString("$D$10:$D$12"), aExpr);
+
+    // This move shouldn't affect the value of C8.
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(2,7,0));
+    CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC);
+    CPPUNIT_ASSERT_EQUAL(33.0, m_pDoc->GetValue(ScAddress(2,7,0)));
+
+    // Update the value of D10 and make sure C8 gets updated.
+    m_pDoc->SetValue(ScAddress(3,9,0), 20);
+    CPPUNIT_ASSERT_EQUAL(43.0, m_pDoc->GetValue(ScAddress(2,7,0)));
+
+    // Insert a new sheet before the current.
+    m_pDoc->InsertTab(0, "New");
+    OUString aName;
+    m_pDoc->GetName(1, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Formula"), aName);
+
+    pName = pGlobalNames->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT_MESSAGE("Failed to find named expression 'MyRange' in the global scope.", pName);
+
+    m_pDoc->SetValue(ScAddress(3,9,1), 10);
+    CPPUNIT_ASSERT_EQUAL(33.0, m_pDoc->GetValue(ScAddress(2,7,1)));
+
+    // Delete the inserted sheet, which will shift the 'Formula' sheet to the left.
+    m_pDoc->DeleteTab(0);
+
+    aName.clear();
+    m_pDoc->GetName(0, aName);
+    CPPUNIT_ASSERT_EQUAL(OUString("Formula"), aName);
+
+    pName = pGlobalNames->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT_MESSAGE("Failed to find named expression 'MyRange' in the global scope.", pName);
+
+    m_pDoc->SetValue(ScAddress(3,9,0), 11);
+    CPPUNIT_ASSERT_EQUAL(34.0, m_pDoc->GetValue(ScAddress(2,7,0)));
+
+    // Clear all and start over.
+    clearRange(m_pDoc, ScRange(0,0,0,100,100,0));
+    pGlobalNames->clear();
+
+    pName = new ScRangeData(
+        m_pDoc, "MyRange", "$B$1:$C$6", ScAddress(0,0,0), ScRangeData::Type::Name, formula::FormulaGrammar::GRAM_NATIVE);
+    bInserted = pGlobalNames->insert(pName);
+    CPPUNIT_ASSERT_MESSAGE("Failed to insert a new name.", bInserted);
+    pName->GetSymbol(aExpr);
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$1:$C$6"), aExpr);
+
+    // Insert range of cells to shift right. The range partially overlaps the named range.
+    m_pDoc->InsertCol(ScRange(2,4,0,3,8,0));
+
+    // This should not alter the range.
+    pName->GetSymbol(aExpr);
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$1:$C$6"), aExpr);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateNameMove()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Test");
+
+    // Set values to B2:B4.
+    m_pDoc->SetValue(ScAddress(1,1,0), 1.0);
+    m_pDoc->SetValue(ScAddress(1,2,0), 2.0);
+    m_pDoc->SetValue(ScAddress(1,3,0), 3.0);
+
+    // Set named range for B2:B4.
+    bool bInserted = m_pDoc->InsertNewRangeName("MyRange", ScAddress(0,0,0), "$Test.$B$2:$B$4");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Set formula in A10.
+    m_pDoc->SetString(ScAddress(0,9,0), "=SUM(MyRange)");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+
+    ScRangeData* pData = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pData);
+    OUString aSymbol;
+    pData->GetSymbol(aSymbol, m_pDoc->GetGrammar());
+    CPPUNIT_ASSERT_EQUAL(OUString("$Test.$B$2:$B$4"), aSymbol);
+
+    // Move B2:B4 to D3.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    bool bMoved = rFunc.MoveBlock(ScRange(1,1,0,1,3,0), ScAddress(3,2,0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    // The named range should have moved as well.
+    pData->GetSymbol(aSymbol, m_pDoc->GetGrammar());
+    CPPUNIT_ASSERT_EQUAL(OUString("$Test.$D$3:$D$5"), aSymbol);
+
+    // The value of A10 should remain unchanged.
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+
+    // Undo and check.
+    pUndoMgr->Undo();
+
+    pData = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pData);
+    pData->GetSymbol(aSymbol, m_pDoc->GetGrammar());
+    CPPUNIT_ASSERT_EQUAL(OUString("$Test.$B$2:$B$4"), aSymbol);
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+
+    // Redo and check.
+    pUndoMgr->Redo();
+
+    pData = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pData);
+    pData->GetSymbol(aSymbol, m_pDoc->GetGrammar());
+    CPPUNIT_ASSERT_EQUAL(OUString("$Test.$D$3:$D$5"), aSymbol);
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+
+    // Undo again to bring it back to the initial condition, and clear the undo buffer.
+    pUndoMgr->Undo();
+    pUndoMgr->Clear();
+
+    // Add an identical formula to A11 and make a formula group over A10:A11.
+    m_pDoc->SetString(ScAddress(0,10,0), "=SUM(MyRange)");
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(0,9,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(9), pFC->GetSharedTopRow());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedLength());
+
+    // Move B2:B4 to D3 again.
+    bMoved = rFunc.MoveBlock(ScRange(1,1,0,1,3,0), ScAddress(3,2,0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    // Values of A10 and A11 should remain the same.
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,9,0)));
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,10,0)));
+
+    // Clear and start over.
+    clearSheet(m_pDoc, 0);
+    m_pDoc->GetRangeName()->clear();
+
+    // Set value to B2.
+    m_pDoc->SetValue(ScAddress(1,1,0), 2.0);
+
+    // Define B2 as 'MyCell'.
+    bInserted = m_pDoc->InsertNewRangeName("MyCell", ScAddress(0,0,0), "$Test.$B$2");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Set formula to B3 that references B2 via MyCell.
+    m_pDoc->SetString(ScAddress(1,2,0), "=MyCell*2");
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(1,2,0)));
+
+    // Move B2 to D2.
+    bMoved = rFunc.MoveBlock(ScRange(1,1,0,1,1,0), ScAddress(3,1,0), true, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+
+    // Value in B3 should remain unchanged.
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(1,2,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateNameExpandRef()
+{
+    setExpandRefs(true);
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Test");
+
+    bool bInserted = m_pDoc->InsertNewRangeName("MyRange", ScAddress(0,0,0), "$A$1:$A$3");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Set values to A1:A3.
+    m_pDoc->SetValue(ScAddress(0,0,0), 1.0);
+    m_pDoc->SetValue(ScAddress(0,1,0), 2.0);
+    m_pDoc->SetValue(ScAddress(0,2,0), 3.0);
+
+    m_pDoc->SetString(ScAddress(0,5,0), "=SUM(MyRange)");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+
+    // Insert a new row at row 4, which should expand the named range to A1:A4.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    rFunc.InsertCells(ScRange(0,3,0,m_pDoc->MaxCol(),3,0), &aMark, INS_INSROWS_BEFORE, false, true);
+    ScRangeData* pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+    OUString aSymbol;
+    pName->GetSymbol(aSymbol, m_pDoc->GetGrammar());
+    CPPUNIT_ASSERT_EQUAL(OUString("$A$1:$A$4"), aSymbol);
+
+    // Make sure the listening area has been expanded as well.  Note the
+    // formula cell has been pushed downward by one cell.
+    m_pDoc->SetValue(ScAddress(0,3,0), 4.0);
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+
+    // Insert a new column at column 2, which should not expand the named
+    // range as it is only one column wide.
+    rFunc.InsertCells(ScRange(1,0,0,1,m_pDoc->MaxRow(),0), &aMark, INS_INSCOLS_BEFORE, false, true);
+    pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol(aSymbol, m_pDoc->GetGrammar());
+    CPPUNIT_ASSERT_EQUAL(OUString("$A$1:$A$4"), aSymbol);
+
+    // Make sure the referenced area has not changed.
+    m_pDoc->SetValue(ScAddress(0,3,0), 2.0);
+    CPPUNIT_ASSERT_EQUAL(8.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+    m_pDoc->SetValue(ScAddress(1,3,0), 2.0);
+    CPPUNIT_ASSERT_EQUAL(8.0, m_pDoc->GetValue(ScAddress(0,6,0)));
+
+    // Clear the document and start over.
+    m_pDoc->GetRangeName()->clear();
+    clearSheet(m_pDoc, 0);
+
+    // Set values to B4:B6.
+    m_pDoc->SetValue(ScAddress(1,3,0), 1.0);
+    m_pDoc->SetValue(ScAddress(1,4,0), 2.0);
+    m_pDoc->SetValue(ScAddress(1,5,0), 3.0);
+
+    bInserted = m_pDoc->InsertNewRangeName("MyRange", ScAddress(0,0,0), "$B$4:$B$6");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Set formula to A1.
+    m_pDoc->SetString(ScAddress(0,0,0), "=SUM(MyRange)");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(0,0,0));
+
+    // Insert rows over 3:5 which should expand the range by 3 rows.
+    rFunc.InsertCells(ScRange(0,2,0,m_pDoc->MaxCol(),4,0), &aMark, INS_INSROWS_BEFORE, false, true);
+
+    pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+
+    pName->GetSymbol(aSymbol, m_pDoc->GetGrammar());
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$4:$B$9"), aSymbol);
+
+    // Clear the document and start over.
+    m_pDoc->GetRangeName()->clear();
+    clearSheet(m_pDoc, 0);
+
+    // Set values to A1:A3.
+    m_pDoc->SetValue(ScAddress(0,0,0), 1.0);
+    m_pDoc->SetValue(ScAddress(0,1,0), 2.0);
+    m_pDoc->SetValue(ScAddress(0,2,0), 3.0);
+
+    // Name A1:A3 'MyData'.
+    bInserted = m_pDoc->InsertNewRangeName("MyData", ScAddress(0,0,0), "$A$1:$A$3");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Set formulas to C1:C2 and E1.
+    m_pDoc->SetString(ScAddress(2,0,0), "=SUM(MyData)");
+    m_pDoc->SetString(ScAddress(2,1,0), "=SUM(MyData)");
+    m_pDoc->SetString(ScAddress(4,0,0), "=SUM(MyData)");
+
+    // C1:C2 should be shared.
+    const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(2,0,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(0), pFC->GetSharedTopRow());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedLength());
+
+    // E1 should not be shared.
+    pFC = m_pDoc->GetFormulaCell(ScAddress(4,0,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT(!pFC->IsShared());
+
+    // Check the results.
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(2,0,0)));
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(4,0,0)));
+
+    // Insert a new row at row 3.  This should expand MyData to A1:A4.
+    rFunc.InsertCells(ScRange(0,2,0,m_pDoc->MaxCol(),2,0), &aMark, INS_INSROWS_BEFORE, false, true);
+
+    // Set new value to A3.
+    m_pDoc->SetValue(ScAddress(0,2,0), 4.0);
+
+    // Check the results again.
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(2,0,0)));
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(4,0,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateNameExpandRef2()
+{
+    setExpandRefs(true);
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Test");
+
+    bool bInserted = m_pDoc->InsertNewRangeName("MyRange", ScAddress(0,0,0), "$A$1:$B$3");
+    CPPUNIT_ASSERT(bInserted);
+
+    // Insert a new row at row 4, which should expand the named range to A1:A4.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+
+    // Insert a new column at column 3, which should expand the named
+    rFunc.InsertCells(ScRange(1,0,0,1,m_pDoc->MaxRow(),0), &aMark, INS_INSCOLS_BEFORE, false, true);
+    ScRangeData* pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+    OUString aSymbol;
+    pName->GetSymbol(aSymbol, m_pDoc->GetGrammar());
+    CPPUNIT_ASSERT_EQUAL(OUString("$A$1:$C$3"), aSymbol);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateNameDeleteRow()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    // Insert a new name 'MyRange' to reference B2:B4.
+    bool bInserted = m_pDoc->InsertNewRangeName("MyRange", ScAddress(0,0,0), "$B$2:$B$4");
+    CPPUNIT_ASSERT(bInserted);
+
+    const ScRangeData* pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+
+    sc::TokenStringContext aCxt(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH);
+    const ScTokenArray* pCode = pName->GetCode();
+    OUString aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$2:$B$4"), aExpr);
+
+    // Insert a new name 'MyAddress' to reference $B$3. Note absolute row.
+    bInserted = m_pDoc->InsertNewRangeName("MyAddress", ScAddress(0,0,0), "$B$3");
+    CPPUNIT_ASSERT(bInserted);
+
+    const ScRangeData* pName2 = m_pDoc->GetRangeName()->findByUpperName("MYADDRESS");
+    CPPUNIT_ASSERT(pName2);
+
+    sc::TokenStringContext aCxt2(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH);
+    const ScTokenArray* pCode2 = pName2->GetCode();
+    OUString aExpr2 = pCode2->CreateString(aCxt2, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$3"), aExpr2);
+
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+
+    // Delete row 3.
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    rFunc.DeleteCells(ScRange(0,2,0,m_pDoc->MaxCol(),2,0), &aMark, DelCellCmd::CellsUp, true);
+
+    // The reference in the 'MyRange' name should get updated to B2:B3.
+    aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$2:$B$3"), aExpr);
+
+    // The reference in the 'MyAddress' name should get updated to $B$#REF!.
+    aExpr2 = pCode2->CreateString(aCxt2, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$#REF!"), aExpr2);
+
+    // Delete row 3 again.
+    rFunc.DeleteCells(ScRange(0,2,0,m_pDoc->MaxCol(),2,0), &aMark, DelCellCmd::CellsUp, true);
+    aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$2:$B$2"), aExpr);
+
+    // Undo and check.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+
+    pUndoMgr->Undo();
+
+    pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+    pCode = pName->GetCode();
+
+    aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$2:$B$3"), aExpr);
+
+    // Undo again and check.
+    pUndoMgr->Undo();
+
+    pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+    pCode = pName->GetCode();
+
+    aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$2:$B$4"), aExpr);
+
+    // Delete row 2-3.
+    rFunc.DeleteCells(ScRange(0,1,0,m_pDoc->MaxCol(),2,0), &aMark, DelCellCmd::CellsUp, true);
+
+    aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$2:$B$2"), aExpr);
+
+    // Undo and check.
+    pUndoMgr->Undo();
+
+    pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+    pCode = pName->GetCode();
+
+    aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$2:$B$4"), aExpr);
+
+    pName2 = m_pDoc->GetRangeName()->findByUpperName("MYADDRESS");
+    CPPUNIT_ASSERT(pName2);
+    pCode2 = pName2->GetCode();
+
+    aExpr2 = pCode2->CreateString(aCxt2, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$3"), aExpr2);
+
+    m_pDoc->InsertTab(1, "test2");
+
+    ScMarkData aMark2(MAXROW, MAXCOL);
+    aMark2.SelectOneTable(1);
+    rFunc.DeleteCells(ScRange(0,2,1,m_pDoc->MaxCol(),2,1), &aMark2, DelCellCmd::CellsUp, true);
+
+    pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+    pCode = pName->GetCode();
+
+    aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$2:$B$4"), aExpr);
+
+    pName2 = m_pDoc->GetRangeName()->findByUpperName("MYADDRESS");
+    CPPUNIT_ASSERT(pName2);
+    pCode2 = pName2->GetCode();
+
+    // Deleting a range the 'MyAddress' name points into due to its implicit
+    // relative sheet reference to the sheet where used does not invalidate
+    // the named expression because when updating the sheet reference is
+    // relative to its base position on sheet 0 (same for the 'MyRange' range,
+    // which is the reason why it is not updated either).
+    // This is a tad confusing...
+    aExpr2 = pCode2->CreateString(aCxt2, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$B$3"), aExpr2);
+
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateNameCopySheet()
+{
+    m_pDoc->InsertTab(0, "Test");
+    m_pDoc->InsertTab(1, "Test2");
+
+    bool bInserted = m_pDoc->InsertNewRangeName("RED", ScAddress(0,0,0), "$Test.$B$2");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName("BLUE", ScAddress(0,0,0), "$Test.$B$3");
+    CPPUNIT_ASSERT(bInserted);
+    m_pDoc->SetValue(1, 1, 0, 1);
+    m_pDoc->SetValue(1, 2, 0, 2);
+
+    // insert formula into Test2 that is =RED+BLUE
+    m_pDoc->SetString(ScAddress(2,2,1), "=RED+BLUE");
+
+    double nVal = m_pDoc->GetValue(2, 2, 1);
+    CPPUNIT_ASSERT_EQUAL(3.0, nVal);
+    m_pDoc->CopyTab(1, 0);
+
+    nVal = m_pDoc->GetValue(2, 2, 2);
+    CPPUNIT_ASSERT_EQUAL(3.0, nVal);
+
+    nVal = m_pDoc->GetValue(2, 2, 0);
+    CPPUNIT_ASSERT_EQUAL(3.0, nVal);
+
+    m_pDoc->SetValue(1, 1, 1, 3);
+
+    nVal = m_pDoc->GetValue(2, 2, 2);
+    CPPUNIT_ASSERT_EQUAL(5.0, nVal);
+
+    nVal = m_pDoc->GetValue(2, 2, 0);
+    CPPUNIT_ASSERT_EQUAL(5.0, nVal);
+
+    m_pDoc->DeleteTab(2);
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+
+    m_pDoc->InsertTab(0, "Test1");
+    // Global name referencing sheet Test1.
+    bInserted = m_pDoc->InsertNewRangeName("sheetnumber", ScAddress(0,0,0), "$Test1.$A$1");
+    CPPUNIT_ASSERT(bInserted);
+    m_pDoc->SetString(ScAddress(0,0,0), "=SHEET()");
+    m_pDoc->SetString(ScAddress(1,0,0), "=sheetnumber");
+    nVal = m_pDoc->GetValue(1,0,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Sheet number should be 1", 1.0, nVal);
+
+    // Copy sheet after.
+    m_pDoc->CopyTab(0, 1);
+    nVal = m_pDoc->GetValue(1,0,1);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("New sheet number should be 2", 2.0, nVal);
+    nVal = m_pDoc->GetValue(1,0,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Org sheet number should be 1", 1.0, nVal);
+    const ScRangeData* pName = m_pDoc->GetRangeName(1)->findByUpperName("SHEETNUMBER");
+    CPPUNIT_ASSERT_MESSAGE("New sheet-local name should exist", pName);
+
+    // Copy sheet before, shifting following now two sheets.
+    m_pDoc->CopyTab(0, 0);
+    nVal = m_pDoc->GetValue(1,0,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("New sheet number should be 1", 1.0, nVal);
+    pName = m_pDoc->GetRangeName(0)->findByUpperName("SHEETNUMBER");
+    CPPUNIT_ASSERT_MESSAGE("New sheet-local name should exist", pName);
+    nVal = m_pDoc->GetValue(1,0,1);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Org sheet number should be 2", 2.0, nVal);
+    pName = m_pDoc->GetRangeName(1)->findByUpperName("SHEETNUMBER");
+    CPPUNIT_ASSERT_MESSAGE("Org sheet-local name should not exist", !pName);
+    nVal = m_pDoc->GetValue(1,0,2);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Old sheet number should be 3", 3.0, nVal);
+    pName = m_pDoc->GetRangeName(2)->findByUpperName("SHEETNUMBER");
+    CPPUNIT_ASSERT_MESSAGE("Old sheet-local name should exist", pName);
+
+    m_pDoc->DeleteTab(2);
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+
+    m_pDoc->InsertTab(0, "Test2");
+    // Local name referencing sheet Test2.
+    bInserted = m_pDoc->GetRangeName(0)->insert( new ScRangeData( m_pDoc, "localname", "$Test2.$A$1"));
+    CPPUNIT_ASSERT(bInserted);
+    m_pDoc->SetString(ScAddress(0,0,0), "=SHEET()");
+    m_pDoc->SetString(ScAddress(1,0,0), "=localname");
+    nVal = m_pDoc->GetValue(1,0,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Localname sheet number should be 1", 1.0, nVal);
+
+    // Insert sheet before and shift sheet with local name.
+    m_pDoc->InsertTab(0, "Test1");
+    pName = m_pDoc->GetRangeName(1)->findByUpperName("LOCALNAME");
+    CPPUNIT_ASSERT_MESSAGE("Org sheet-local name should exist", pName);
+    nVal = m_pDoc->GetValue(1,0,1);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Localname sheet number should be 2", 2.0, nVal);
+
+    // Copy sheet before, shifting following now two sheets.
+    m_pDoc->CopyTab(1, 0);
+    pName = m_pDoc->GetRangeName(0)->findByUpperName("LOCALNAME");
+    CPPUNIT_ASSERT_MESSAGE("New sheet-local name should exist", pName);
+    nVal = m_pDoc->GetValue(1,0,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("New sheet number should be 1", 1.0, nVal);
+    pName = m_pDoc->GetRangeName(1)->findByUpperName("LOCALNAME");
+    CPPUNIT_ASSERT_MESSAGE("Old sheet-local name should not exist", !pName);
+    pName = m_pDoc->GetRangeName(2)->findByUpperName("LOCALNAME");
+    CPPUNIT_ASSERT_MESSAGE("Org sheet-local name should exist", pName);
+    nVal = m_pDoc->GetValue(1,0,2);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("New sheet number should be 3", 3.0, nVal);
+
+    m_pDoc->DeleteTab(2);
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+    m_pDoc->SetRangeName(nullptr);
+
+    // Test nested names during copying sheet.
+
+    m_pDoc->InsertTab(0, "Test2");
+    ScAddress aPos(0,0,0);
+    bInserted = m_pDoc->InsertNewRangeName( "global", aPos, "$Test2.$A$1");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( aPos.Tab(), "local", aPos, "$Test2.$A$2");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( "global_global", aPos, "global*100");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( "global_local", aPos, "local*1000");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( "global_unused", aPos, "$Test2.$A$1");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( "global_unused_noref", aPos, "42");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( aPos.Tab(), "local_global", aPos, "global*10000");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( aPos.Tab(), "local_local", aPos, "local*100000");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( aPos.Tab(), "local_unused", aPos, "$Test2.$A$2");
+    CPPUNIT_ASSERT(bInserted);
+    bInserted = m_pDoc->InsertNewRangeName( aPos.Tab(), "local_unused_noref", aPos, "23");
+    CPPUNIT_ASSERT(bInserted);
+
+    m_pDoc->SetString(aPos, "=SHEET()");
+    aPos.IncRow();
+    m_pDoc->SetString(aPos, "=A1*10+SHEET()");
+    aPos.IncRow();
+    m_pDoc->SetString(aPos, "=global_global");
+    aPos.IncRow();
+    m_pDoc->SetString(aPos, "=global_local");
+    aPos.IncRow();
+    m_pDoc->SetString(aPos, "=local_global");
+    aPos.IncRow();
+    m_pDoc->SetString(aPos, "=local_local");
+
+    testFormulaRefUpdateNameCopySheetCheckTab( 0, false);
+
+    // Copy sheet after.
+    m_pDoc->CopyTab(0, 1);
+    testFormulaRefUpdateNameCopySheetCheckTab( 0, false);
+    testFormulaRefUpdateNameCopySheetCheckTab( 1, true);
+
+    // Copy sheet before, shifting following now two sheets.
+    m_pDoc->CopyTab(1, 0);
+    testFormulaRefUpdateNameCopySheetCheckTab( 0, true);
+    testFormulaRefUpdateNameCopySheetCheckTab( 1, false);
+    testFormulaRefUpdateNameCopySheetCheckTab( 2, true);
+
+    m_pDoc->DeleteTab(2);
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateNameCopySheetCheckTab( SCTAB nTab, bool bCheckNames )
+{
+    if (bCheckNames)
+    {
+        const ScRangeData* pName;
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("GLOBAL");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name GLOBAL should exist", pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("LOCAL");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name LOCAL should exist", pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("GLOBAL_GLOBAL");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name GLOBAL_GLOBAL should exist", pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("GLOBAL_LOCAL");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name GLOBAL_LOCAL should exist", pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("GLOBAL_UNUSED");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name GLOBAL_UNUSED should exist", pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("GLOBAL_UNUSED_NOREF");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name GLOBAL_UNUSED_NOREF should not exist", !pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("LOCAL_GLOBAL");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name LOCAL_GLOBAL should exist", pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("LOCAL_LOCAL");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name LOCAL_LOCAL should exist", pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("LOCAL_UNUSED");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name LOCAL_UNUSED should exist", pName);
+        pName = m_pDoc->GetRangeName(nTab)->findByUpperName("LOCAL_UNUSED_NOREF");
+        CPPUNIT_ASSERT_MESSAGE("Sheet-local name LOCAL_UNUSED_NOREF should exist", pName);
+    }
+
+    ScAddress aPos(0,0,0);
+    aPos.SetRow(0);
+    aPos.SetTab(nTab);
+    int nSheet = nTab + 1;
+    CPPUNIT_ASSERT_EQUAL( 1.0 * nSheet, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL( 11.0 * nSheet, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL( 100.0 * nSheet, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL( 11000.0 * nSheet, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL( 10000.0 * nSheet, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL( 1100000.0 * nSheet, m_pDoc->GetValue(aPos));
+}
+
+void Test::testFormulaRefUpdateSheetLocalMove()
+{
+    SCTAB nSheet1 = 0;
+    SCTAB nSheet2 = 1;
+    m_pDoc->InsertTab( nSheet1, "Sheet1");
+    m_pDoc->InsertTab( nSheet2, "Sheet2");
+
+    ScAddress aPos(0,0,nSheet1);
+    bool bOk;
+    bOk = m_pDoc->InsertNewRangeName( 0, "MyCell", aPos, "$Sheet1.$B$2");
+    CPPUNIT_ASSERT(bOk);
+    aPos.SetTab(nSheet2);
+    bOk = m_pDoc->InsertNewRangeName( 1, "MyCell", aPos, "$Sheet2.$B$2");
+    CPPUNIT_ASSERT(bOk);
+
+    aPos.SetTab(nSheet1);
+    aPos.IncCol();
+    m_pDoc->SetString( aPos, "x");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "1.0");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=MyCell");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Sheet1.B3", 1.0, m_pDoc->GetValue(aPos));
+
+    aPos.SetTab(nSheet2);
+    aPos.SetRow(1);
+    m_pDoc->SetString( aPos, "2.0");
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=MyCell");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Sheet2.B3", 2.0, m_pDoc->GetValue(aPos));
+
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    OUString aFormula;
+
+    // Move Sheet1.B1 ("x") to Sheet2.B1
+    bOk = rFunc.MoveBlock( ScRange(1,0,nSheet1,1,0,nSheet1), ScAddress(1,0,nSheet2), true, false, false, false);
+    CPPUNIT_ASSERT(bOk);
+    // Results not changed.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move x: Sheet1.B3", 1.0, m_pDoc->GetValue(ScAddress(1,2,nSheet1)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move x: Sheet2.B3", 2.0, m_pDoc->GetValue(ScAddress(1,2,nSheet2)));
+    // Formulas not changed.
+    m_pDoc->GetFormula( 1,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move x: Sheet1.B3", OUString("=MyCell"), aFormula);
+    m_pDoc->GetFormula( 1,2,nSheet2, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move x: Sheet2.B3", OUString("=MyCell"), aFormula);
+
+    // Move Sheet2.B2 ("2.0") to Sheet1.C2
+    bOk = rFunc.MoveBlock( ScRange(1,1,nSheet2,1,1,nSheet2), ScAddress(2,1,nSheet1), true, false, false, false);
+    CPPUNIT_ASSERT(bOk);
+    // Results not changed.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move 2.0: Sheet1.B3", 1.0, m_pDoc->GetValue(ScAddress(1,2,nSheet1)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move 2.0: Sheet2.B3", 2.0, m_pDoc->GetValue(ScAddress(1,2,nSheet2)));
+    // Formulas not changed.
+    m_pDoc->GetFormula( 1,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move 2.0: Sheet1.B3", OUString("=MyCell"), aFormula);
+    m_pDoc->GetFormula( 1,2,nSheet2, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move 2.0: Sheet2.B3", OUString("=MyCell"), aFormula);
+
+    ScRangeData* pName;
+
+    // Check that the sheet-local named reference points to the moved cell, now
+    // Sheet1.C2
+    pName = m_pDoc->GetRangeName(nSheet2)->findByUpperName("MYCELL");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol( aFormula, ScAddress(), formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move 2.0: Sheet2 sheet-local name", OUString("$Sheet1.$C$2"), aFormula);
+
+    // Move Sheet2.B3 ("=MyCell") to Sheet1.C3
+    bOk = rFunc.MoveBlock( ScRange(1,2,nSheet2,1,2,nSheet2), ScAddress(2,2,nSheet1), true, false, false, false);
+    CPPUNIT_ASSERT(bOk);
+    // Results changed.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move =MyCell: Sheet1.B3", 1.0, m_pDoc->GetValue(ScAddress(1,2,nSheet1)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move =MyCell: Sheet2.B3", 0.0, m_pDoc->GetValue(ScAddress(1,2,nSheet2)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move =MyCell: Sheet1.C3", 2.0, m_pDoc->GetValue(ScAddress(2,2,nSheet1)));
+    // One formula identical, one adjusted.
+    m_pDoc->GetFormula( 1,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move =MyCell: Sheet1.B3", OUString("=MyCell"), aFormula);
+    m_pDoc->GetFormula( 2,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move =MyCell: Sheet1.C3", OUString("=Sheet2.MyCell"), aFormula);
+
+    // Check that the sheet-local named reference in Sheet1 still points to the
+    // original cell Sheet1.B2
+    pName = m_pDoc->GetRangeName(nSheet1)->findByUpperName("MYCELL");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol( aFormula, ScAddress(), formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move =MyCell: Sheet1 sheet-local name", OUString("$Sheet1.$B$2"), aFormula);
+
+    // Check that the sheet-local named reference in Sheet2 still points to the
+    // moved cell, now Sheet1.C2
+    pName = m_pDoc->GetRangeName(nSheet2)->findByUpperName("MYCELL");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol( aFormula, ScAddress(), formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Move =MyCell: Sheet2 sheet-local name", OUString("$Sheet1.$C$2"), aFormula);
+
+    // Insert sheet before the others.
+    m_pDoc->InsertTab(0, "Sheet0");
+    ++nSheet1;
+    ++nSheet2;
+
+    // Nothing changed.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Insert Sheet0: Sheet1.B3", 1.0, m_pDoc->GetValue(ScAddress(1,2,nSheet1)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Insert Sheet0: Sheet1.C3", 2.0, m_pDoc->GetValue(ScAddress(2,2,nSheet1)));
+    m_pDoc->GetFormula( 1,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Insert Sheet0: Sheet1.B3", OUString("=MyCell"), aFormula);
+    m_pDoc->GetFormula( 2,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Insert Sheet0: Sheet1.C3", OUString("=Sheet2.MyCell"), aFormula);
+    pName = m_pDoc->GetRangeName(nSheet1)->findByUpperName("MYCELL");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol( aFormula, ScAddress(), formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Insert Sheet0: Sheet1 sheet-local name", OUString("$Sheet1.$B$2"), aFormula);
+    pName = m_pDoc->GetRangeName(nSheet2)->findByUpperName("MYCELL");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol( aFormula, ScAddress(), formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Insert Sheet0: Sheet2 sheet-local name", OUString("$Sheet1.$C$2"), aFormula);
+
+    // Delete sheet before the others.
+    m_pDoc->DeleteTab(0);
+    --nSheet1;
+    --nSheet2;
+
+    // Nothing changed.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet0: Sheet1.B3", 1.0, m_pDoc->GetValue(ScAddress(1,2,nSheet1)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet0: Sheet1.C3", 2.0, m_pDoc->GetValue(ScAddress(2,2,nSheet1)));
+    m_pDoc->GetFormula( 1,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet0: Sheet1.B3", OUString("=MyCell"), aFormula);
+    m_pDoc->GetFormula( 2,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet0: Sheet1.C3", OUString("=Sheet2.MyCell"), aFormula);
+    pName = m_pDoc->GetRangeName(nSheet1)->findByUpperName("MYCELL");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol( aFormula, ScAddress(), formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet0: Sheet1 sheet-local name", OUString("$Sheet1.$B$2"), aFormula);
+    pName = m_pDoc->GetRangeName(nSheet2)->findByUpperName("MYCELL");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol( aFormula, ScAddress(), formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet0: Sheet2 sheet-local name", OUString("$Sheet1.$C$2"), aFormula);
+
+    // Delete last sheet with sheet-local name.
+    m_pDoc->DeleteTab(nSheet2);
+
+    // XXX we *could* analyze whether the expression points to a different
+    // sheet and then move the name to a remaining sheet. If so, adapt this
+    // test.
+    // Nothing changed except the sheet-local name and its use.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet2: Sheet1.B3", 1.0, m_pDoc->GetValue(ScAddress(1,2,nSheet1)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet2: Sheet1.C3", 0.0, m_pDoc->GetValue(ScAddress(2,2,nSheet1)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet2: Sheet1.C3", OUString("#NAME?"), m_pDoc->GetString(ScAddress(2,2,nSheet1)));
+    m_pDoc->GetFormula( 1,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet2: Sheet1.B3", OUString("=MyCell"), aFormula);
+    m_pDoc->GetFormula( 2,2,nSheet1, aFormula);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet2: Sheet1.C3", OUString("=#NAME?"), aFormula);
+    pName = m_pDoc->GetRangeName(nSheet1)->findByUpperName("MYCELL");
+    CPPUNIT_ASSERT(pName);
+    pName->GetSymbol( aFormula, ScAddress(), formula::FormulaGrammar::GRAM_ENGLISH);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Delete Sheet2: Sheet1 sheet-local name", OUString("$Sheet1.$B$2"), aFormula);
+    CPPUNIT_ASSERT(!m_pDoc->GetRangeName(nSheet2));
+    nSheet2 = -1;
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateNameDelete()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    // Insert a new name 'MyRange' to reference B1
+    bool bInserted = m_pDoc->InsertNewRangeName("MyRange", ScAddress(0,0,0), "$Test.$B$1");
+    CPPUNIT_ASSERT(bInserted);
+
+    const ScRangeData* pName = m_pDoc->GetRangeName()->findByUpperName("MYRANGE");
+    CPPUNIT_ASSERT(pName);
+
+    m_pDoc->DeleteCol(1, 0, 3, 0, 0, 1);
+    const ScTokenArray* pCode = pName->GetCode();
+    sc::TokenStringContext aCxt(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH);
+    OUString aExpr = pCode->CreateString(aCxt, ScAddress(0,0,0));
+    CPPUNIT_ASSERT_EQUAL(OUString("$Test.$B$1"), aExpr);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaRefUpdateValidity()
+{
+    struct {
+
+        bool checkList( std::vector<ScTypedStrData>& rList )
+        {
+            double aExpected[] = { 1.0, 2.0, 3.0 }; // must be sorted.
+            size_t nCheckSize = SAL_N_ELEMENTS(aExpected);
+
+            if (rList.size() != nCheckSize)
+            {
+                cerr << "List size is not what is expected." << endl;
+                return false;
+            }
+
+            std::sort(rList.begin(), rList.end(), ScTypedStrData::LessCaseSensitive());
+
+            for (size_t i = 0; i < nCheckSize; ++i)
+            {
+                if (aExpected[i] != rList[i].GetValue())
+                {
+                    cerr << "Incorrect value at position " << i
+                        << ": expected=" << aExpected[i] << ", actual=" << rList[i].GetValue() << endl;
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+    } aCheck;
+
+    setExpandRefs(false);
+    setCalcAsShown(m_pDoc, true);
+
+    m_pDoc->InsertTab(0, "Formula");
+
+    // Set values in C2:C4.
+    m_pDoc->SetValue(ScAddress(2,1,0), 1.0);
+    m_pDoc->SetValue(ScAddress(2,2,0), 2.0);
+    m_pDoc->SetValue(ScAddress(2,3,0), 3.0);
+
+    // Set validity in A2.
+    ScValidationData aData(
+        SC_VALID_LIST, ScConditionMode::Equal, "C2:C4", "", m_pDoc, ScAddress(0,1,0), "", "",
+        m_pDoc->GetGrammar(), m_pDoc->GetGrammar());
+
+    sal_uLong nIndex = m_pDoc->AddValidationEntry(aData);
+    SfxUInt32Item aItem(ATTR_VALIDDATA, nIndex);
+
+    ScPatternAttr aNewAttrs(
+        std::make_unique<SfxItemSet>(*m_pDoc->GetPool(), svl::Items<ATTR_PATTERN_START, ATTR_PATTERN_END>{}));
+    aNewAttrs.GetItemSet().Put(aItem);
+
+    m_pDoc->ApplyPattern(0, 1, 0, aNewAttrs);
+
+    const ScValidationData* pData = m_pDoc->GetValidationEntry(nIndex);
+    CPPUNIT_ASSERT(pData);
+
+    // Make sure the list is correct.
+    std::vector<ScTypedStrData> aList;
+    pData->FillSelectionList(aList, ScAddress(0,1,0));
+    bool bGood = aCheck.checkList(aList);
+    CPPUNIT_ASSERT_MESSAGE("Initial list is incorrect.", bGood);
+
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+
+    // Insert a new column at Column B, to move the list from C2:C4 to D2:D4.
+    bool bInserted = rFunc.InsertCells(ScRange(1,0,0,1,m_pDoc->MaxRow(),0), &aMark, INS_INSCOLS_BEFORE, true, true);
+    CPPUNIT_ASSERT_MESSAGE("Column insertion failed.", bInserted);
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(3,1,0)));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(3,2,0)));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(3,3,0)));
+
+    // Check the list values again.
+    aList.clear();
+    pData->FillSelectionList(aList, ScAddress(0,1,0));
+    bGood = aCheck.checkList(aList);
+    CPPUNIT_ASSERT_MESSAGE("List content is incorrect after column insertion.", bGood);
+
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+
+    // Undo and check the list content again.  The list moves back to C2:C4 after the undo.
+    pUndoMgr->Undo();
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(2,2,0)));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(2,3,0)));
+
+    aList.clear();
+    pData->FillSelectionList(aList, ScAddress(0,1,0));
+    bGood = aCheck.checkList(aList);
+    CPPUNIT_ASSERT_MESSAGE("List content is incorrect after undo of column insertion.", bGood);
+
+    // Move C2:C4 to E5:E7.
+    bool bMoved = rFunc.MoveBlock(ScRange(2,1,0,2,3,0), ScAddress(4,4,0), false, true, false, true);
+    CPPUNIT_ASSERT(bMoved);
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(4,4,0)));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(4,5,0)));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(4,6,0)));
+
+    // Check the list again after the move.
+    aList.clear();
+    pData->FillSelectionList(aList, ScAddress(0,1,0));
+    bGood = aCheck.checkList(aList);
+    CPPUNIT_ASSERT_MESSAGE("List content is incorrect after moving C2:C4 to E5:E7.", bGood);
+
+    // Undo the move and check.  The list should be back to C2:C4.
+    pUndoMgr->Undo();
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(2,2,0)));
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(2,3,0)));
+
+    aList.clear();
+    pData->FillSelectionList(aList, ScAddress(0,1,0));
+    bGood = aCheck.checkList(aList);
+    CPPUNIT_ASSERT_MESSAGE("List content is incorrect after undo of the move.", bGood);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testTokenArrayRefUpdateMove()
+{
+    m_pDoc->InsertTab(0, "Sheet1");
+    m_pDoc->InsertTab(1, "Sheet2");
+
+    ScAddress aPos(0,0,0); // A1
+
+    sc::TokenStringContext aCxt(m_pDoc, m_pDoc->GetGrammar());
+
+    // Emulate cell movement from Sheet1.C3 to Sheet2.C3.
+    sc::RefUpdateContext aRefCxt(*m_pDoc);
+    aRefCxt.meMode = URM_MOVE;
+    aRefCxt.maRange = ScAddress(2,2,1); // C3 on Sheet2.
+    aRefCxt.mnTabDelta = -1;
+
+    std::vector<OUString> aTests = {
+        "B1*C1",
+        "SUM(B1:C1)",
+        "$Sheet1.B1",
+        "SUM(Sheet1.B1:Sheet2.B1)"
+    };
+
+    // Since C3 is not referenced in any of the above formulas, moving C3 from
+    // Sheet1 to Sheet2 should NOT change the displayed formula string at all.
+
+    for (const OUString& aTest : aTests)
+    {
+        ScCompiler aComp(m_pDoc, aPos, m_pDoc->GetGrammar());
+        std::unique_ptr<ScTokenArray> pArray(aComp.CompileString(aTest));
+
+        OUString aStr = pArray->CreateString(aCxt, aPos);
+
+        CPPUNIT_ASSERT_EQUAL(aTest, aStr);
+
+        // This formula cell isn't moving its position. The displayed formula
+        // string should not change.
+        pArray->AdjustReferenceOnMove(aRefCxt, aPos, aPos);
+
+        aStr = pArray->CreateString(aCxt, aPos);
+        CPPUNIT_ASSERT_EQUAL(aTest, aStr);
+    }
+
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testMultipleOperations()
+{
+    m_pDoc->InsertTab(0, "MultiOp");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    // Insert the reference formula at top row.
+    m_pDoc->SetValue(ScAddress(0,0,0), 1);
+    m_pDoc->SetString(ScAddress(1,0,0), "=A1*10");
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(1,0,0)));
+
+    // Insert variable inputs in A3:A5.
+    m_pDoc->SetValue(ScAddress(0,2,0), 2);
+    m_pDoc->SetValue(ScAddress(0,3,0), 3);
+    m_pDoc->SetValue(ScAddress(0,4,0), 4);
+
+    // Set multiple operations range.
+    ScTabOpParam aParam;
+    aParam.aRefFormulaCell = ScRefAddress(1,0,0);
+    aParam.aRefFormulaEnd = aParam.aRefFormulaCell;
+    aParam.aRefColCell = ScRefAddress(0,0,0);
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SetMarkArea(ScRange(0,2,0,1,4,0)); // Select A3:B5.
+    m_pDoc->InsertTableOp(aParam, 0, 2, 1, 4, aMark);
+    CPPUNIT_ASSERT_EQUAL(20.0, m_pDoc->GetValue(1,2,0));
+    CPPUNIT_ASSERT_EQUAL(30.0, m_pDoc->GetValue(1,3,0));
+    CPPUNIT_ASSERT_EQUAL(40.0, m_pDoc->GetValue(1,4,0));
+
+    // Clear A3:B5.
+    clearRange(m_pDoc, ScRange(0,2,0,1,4,0));
+
+    // This time, use indirect reference formula cell.
+    m_pDoc->SetString(ScAddress(2,0,0), "=B1"); // C1 simply references B1.
+    CPPUNIT_ASSERT_EQUAL(10.0, m_pDoc->GetValue(ScAddress(2,0,0)));
+
+    // Insert variable inputs in A3:A5.
+    m_pDoc->SetValue(ScAddress(0,2,0), 3);
+    m_pDoc->SetValue(ScAddress(0,3,0), 4);
+    m_pDoc->SetValue(ScAddress(0,4,0), 5);
+
+    // Set multiple operations range again, but this time, we'll use C1 as the reference formula.
+    aParam.aRefFormulaCell.Set(2,0,0,false,false,false);
+    aParam.aRefFormulaEnd = aParam.aRefFormulaCell;
+    m_pDoc->InsertTableOp(aParam, 0, 2, 1, 4, aMark);
+    CPPUNIT_ASSERT_EQUAL(30.0, m_pDoc->GetValue(1,2,0));
+    CPPUNIT_ASSERT_EQUAL(40.0, m_pDoc->GetValue(1,3,0));
+    CPPUNIT_ASSERT_EQUAL(50.0, m_pDoc->GetValue(1,4,0));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncCOLUMN()
+{
+    m_pDoc->InsertTab(0, "Formula");
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->SetString(ScAddress(5,10,0), "=COLUMN()");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(5,10,0)));
+
+    m_pDoc->SetString(ScAddress(0,1,0), "=F11");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+
+    // Move the formula cell with COLUMN() function to change its value.
+    m_pDoc->InsertCol(ScRange(5,0,0,5,m_pDoc->MaxRow(),0));
+    CPPUNIT_ASSERT_EQUAL(7.0, m_pDoc->GetValue(ScAddress(6,10,0)));
+
+    // The cell that references the moved cell should update its value as well.
+    CPPUNIT_ASSERT_EQUAL(7.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+
+    // Move the column in the other direction.
+    m_pDoc->DeleteCol(ScRange(5,0,0,5,m_pDoc->MaxRow(),0));
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(5,10,0)));
+
+    // The cell that references the moved cell should update its value as well.
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncCOUNT()
+{
+    m_pDoc->InsertTab(0, "Formula");
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->SetValue(ScAddress(0,0,0), 2); // A1
+    m_pDoc->SetValue(ScAddress(0,1,0), 4); // A2
+    m_pDoc->SetValue(ScAddress(0,2,0), 6); // A3
+
+    ScAddress aPos(1,0,0);
+    m_pDoc->SetString(aPos, "=COUNT(A1:A3)");
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString(aPos, "=COUNT(A1:A3;2)");
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString(aPos, "=COUNT(A1:A3;2;4)");
+    CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString(aPos, "=COUNT(A1:A3;2;4;6)");
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(aPos));
+
+    // Matrix in C1.
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(2, 0, 2, 0, aMark, "=COUNT(SEARCH(\"a\";{\"a\";\"b\";\"a\"}))");
+    // Check that the #VALUE! error of "a" not found in "b" is not counted.
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(2,0,0)));
+
+    // Matrix in C3.
+    m_pDoc->InsertMatrixFormula(2, 2, 2, 2, aMark, "=COUNTA(SEARCH(\"a\";{\"a\";\"b\";\"a\"}))");
+    // Check that the #VALUE! error of "a" not found in "b" is counted.
+    CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(2,2,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncCOUNTBLANK()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Formula");
+
+    const char* aData[][4] = {
+        { "1", nullptr, "=B1", "=\"\"" },
+        { "2", nullptr, "=B2", "=\"\"" },
+        { "A", nullptr, "=B3", "=\"\"" },
+        { "B", nullptr, "=B4", "=D3" },
+        {   nullptr, nullptr, "=B5", "=D4" },
+        { "=COUNTBLANK(A1:A5)", "=COUNTBLANK(B1:B5)", "=COUNTBLANK(C1:C5)", "=COUNTBLANK(D1:D5)" }
+    };
+
+    ScAddress aPos(0,0,0);
+    ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+    CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(ScAddress(1,5,0)));
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(2,5,0)));
+    CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(ScAddress(3,5,0)));
+
+    // Test single cell reference cases.
+
+    clearSheet(m_pDoc, 0);
+
+    const char* aData2[][2] = {
+        { "1",     "=COUNTBLANK(A1)" },
+        { "A",     "=COUNTBLANK(A2)" },
+        {   nullptr,     "=COUNTBLANK(A3)" },
+        { "=\"\"", "=COUNTBLANK(A4)" },
+        { "=A4"  , "=COUNTBLANK(A5)" },
+    };
+
+    aRange = insertRangeData(m_pDoc, aPos, aData2, SAL_N_ELEMENTS(aData2));
+    CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(1,0,0)));
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(1,1,0)));
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(1,2,0)));
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(1,3,0)));
+    CPPUNIT_ASSERT_EQUAL(1.0, m_pDoc->GetValue(ScAddress(1,4,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncROW()
+{
+    m_pDoc->InsertTab(0, "Formula");
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->SetString(ScAddress(5,10,0), "=ROW()");
+    CPPUNIT_ASSERT_EQUAL(11.0, m_pDoc->GetValue(ScAddress(5,10,0)));
+
+    m_pDoc->SetString(ScAddress(0,1,0), "=F11");
+    CPPUNIT_ASSERT_EQUAL(11.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+
+    // Insert 2 new rows at row 4.
+    m_pDoc->InsertRow(ScRange(0,3,0,m_pDoc->MaxCol(),4,0));
+    CPPUNIT_ASSERT_EQUAL(13.0, m_pDoc->GetValue(ScAddress(5,12,0)));
+
+    // The cell that references the moved cell should update its value as well.
+    CPPUNIT_ASSERT_EQUAL(13.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+
+    // Delete 2 rows to move it back.
+    m_pDoc->DeleteRow(ScRange(0,3,0,m_pDoc->MaxCol(),4,0));
+
+    CPPUNIT_ASSERT_EQUAL(11.0, m_pDoc->GetValue(ScAddress(5,10,0)));
+
+    // The cell that references the moved cell should update its value as well.
+    CPPUNIT_ASSERT_EQUAL(11.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+
+    // Clear sheet and start over.
+    clearSheet(m_pDoc, 0);
+
+    m_pDoc->SetString(ScAddress(0,1,0), "=ROW(A5)");
+    m_pDoc->SetString(ScAddress(1,1,0), "=ROW(B5)");
+    m_pDoc->SetString(ScAddress(1,2,0), "=ROW(B6)");
+    CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+    CPPUNIT_ASSERT_EQUAL(5.0, m_pDoc->GetValue(ScAddress(1,1,0)));
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(1,2,0)));
+
+    // B2:B3 should be shared.
+    const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(1,1,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(1), pFC->GetSharedTopRow());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedLength());
+
+    // Insert a new row at row 4.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    rFunc.InsertCells(ScRange(0,3,0,m_pDoc->MaxCol(),3,0), &aMark, INS_INSROWS_BEFORE, false, true);
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(0,1,0), "ROW(A6)", "Wrong formula!");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,1,0), "ROW(B6)", "Wrong formula!");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,2,0), "ROW(B7)", "Wrong formula!");
+
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(1,1,0)));
+    CPPUNIT_ASSERT_EQUAL(7.0, m_pDoc->GetValue(ScAddress(1,2,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncSUM()
+{
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc.
+
+    // Single argument case.
+    m_pDoc->SetValue(ScAddress(0,0,0), 1);
+    m_pDoc->SetValue(ScAddress(0,1,0), 1);
+    m_pDoc->SetString(ScAddress(0,2,0), "=SUM(A1:A2)");
+    m_pDoc->CalcAll();
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(0,2,0)));
+
+    // Multiple argument case.
+    m_pDoc->SetValue(ScAddress(0,0,0), 1);
+    m_pDoc->SetValue(ScAddress(0,1,0), 22);
+    m_pDoc->SetValue(ScAddress(0,2,0), 4);
+    m_pDoc->SetValue(ScAddress(0,3,0), 5);
+    m_pDoc->SetValue(ScAddress(0,4,0), 6);
+
+    m_pDoc->SetValue(ScAddress(1,0,0), 3);
+    m_pDoc->SetValue(ScAddress(1,1,0), 4);
+    m_pDoc->SetValue(ScAddress(1,2,0), 5);
+    m_pDoc->SetValue(ScAddress(1,3,0), 6);
+    m_pDoc->SetValue(ScAddress(1,4,0), 7);
+
+    m_pDoc->SetString(ScAddress(3,0,0), "=SUM(A1:A2;B1:B2)");
+    m_pDoc->SetString(ScAddress(3,1,0), "=SUM(A2:A3;B2:B3)");
+    m_pDoc->SetString(ScAddress(3,2,0), "=SUM(A3:A4;B3:B4)");
+    CPPUNIT_ASSERT_EQUAL(30.0, m_pDoc->GetValue(ScAddress(3,0,0)));
+    CPPUNIT_ASSERT_EQUAL(35.0, m_pDoc->GetValue(ScAddress(3,1,0)));
+    CPPUNIT_ASSERT_EQUAL(20.0, m_pDoc->GetValue(ScAddress(3,2,0)));
+
+    // Clear and start over.
+    clearRange(m_pDoc, ScRange(0,0,0,3,m_pDoc->MaxRow(),0));
+
+    // SUM needs to take the first error in case the range contains an error.
+    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);
+    m_pDoc->SetString(ScAddress(0,3,0), "=SUM(A1:A3)");
+    CPPUNIT_ASSERT_EQUAL(111.0, m_pDoc->GetValue(ScAddress(0,3,0)));
+
+    // Set #DIV/0! error to A3. A4 should also inherit this error.
+    m_pDoc->SetString(ScAddress(0,2,0), "=1/0");
+    FormulaError nErr = m_pDoc->GetErrCode(ScAddress(0,2,0));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Cell should have a division by zero error.",
+                           int(FormulaError::DivisionByZero), static_cast<int>(nErr));
+    nErr = m_pDoc->GetErrCode(ScAddress(0,3,0));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUM should have also inherited a div-by-zero error.",
+                           int(FormulaError::DivisionByZero), static_cast<int>(nErr));
+
+    // Set #NA! to A2. A4 should now inherit this error.
+    m_pDoc->SetString(ScAddress(0,1,0), "=NA()");
+    nErr = m_pDoc->GetErrCode(ScAddress(0,1,0));
+    CPPUNIT_ASSERT_MESSAGE("A2 should be an error.", nErr != FormulaError::NONE);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A4 should have inherited the same error as A2.",
+                           static_cast<int>(nErr), static_cast<int>(m_pDoc->GetErrCode(ScAddress(0,3,0))));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncPRODUCT()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto recalc.
+
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", m_pDoc->InsertTab(0, "foo"));
+
+    ScAddress aPos(3, 0, 0);
+    m_pDoc->SetValue(0, 0, 0, 3.0); // A1
+    m_pDoc->SetString(aPos, "=PRODUCT(A1)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", 3.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, -3.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", -3.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=PRODUCT(B1)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 10.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", 10.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=PRODUCT(A1:C3)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", -30.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 1, 0, -1.0); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", 30.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 0, 0, 4.0); // C1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", 120.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, -2.0); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", -240.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 1, 0, 8.0); // C2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT failed", -1920.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 2, 0, 0.2); // A3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of PRODUCT failed", -384.0, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(1, 2, 0, -0.25); // B3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of PRODUCT failed", 96.0, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(2, 2, 0, -0.125); // C3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of PRODUCT failed", -12.0, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(2, 2, 0, 0.0); // C3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of PRODUCT failed", 0.0, m_pDoc->GetValue(aPos), 10e-4);
+
+    m_pDoc->SetString(aPos, "=PRODUCT({2;3;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT with inline array failed", 24.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=PRODUCT({2;-2;2})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT with inline array failed", -8.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=PRODUCT({8;0.125;-1})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT with inline array failed", -1.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=PRODUCT({2;3};{4;5})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT with inline array failed", 120.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=PRODUCT({10;-8};{3;-1};{15;30};{7})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT with inline array failed", 756000.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=PRODUCT({10;-0.1;8};{0.125;4;0.25;2};{0.5};{1};{-1})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of PRODUCT with inline array failed", 1.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncSUMPRODUCT()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto recalc.
+
+    ScAddress aPos(0,0,0);
+    m_pDoc->SetString(aPos, "=SUMPRODUCT(B1:B3;C1:C3)");
+    CPPUNIT_ASSERT_EQUAL(0.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(2,0,0),  1.0); // C1
+    CPPUNIT_ASSERT_EQUAL(0.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(1,0,0),  1.0); // B1
+    CPPUNIT_ASSERT_EQUAL(1.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(1,1,0),  2.0); // B2
+    CPPUNIT_ASSERT_EQUAL(1.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(2,1,0),  3.0); // C2
+    CPPUNIT_ASSERT_EQUAL(7.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(2,2,0), -2.0); // C3
+    CPPUNIT_ASSERT_EQUAL(7.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(1,2,0),  5.0); // B3
+    CPPUNIT_ASSERT_EQUAL(-3.0, m_pDoc->GetValue(aPos));
+
+    // Force an error in C2 and test ForcedArray matrix error propagation.
+    m_pDoc->SetString( 2, 1, 0, "=1/0");
+    FormulaError nError = m_pDoc->GetErrCode(aPos);
+    CPPUNIT_ASSERT_MESSAGE("Formula result should be a propagated error", nError != FormulaError::NONE);
+
+    // Test ForceArray propagation of SUMPRODUCT parameters to ABS and + operator.
+    // => ABS({-3,4})*({-3,4}+{-3,4}) => {3,4}*{-6,8} => {-18,32} => 14
+    m_pDoc->SetValue(ScAddress(4,0,0), -3.0); // E1
+    m_pDoc->SetValue(ScAddress(4,1,0),  4.0); // E2
+    // Non-intersecting formula in F3.
+    m_pDoc->SetString(ScAddress(5,2,0), "=SUMPRODUCT(ABS(E1:E2);E1:E2+E1:E2)");
+    CPPUNIT_ASSERT_EQUAL(14.0, m_pDoc->GetValue(ScAddress(5,2,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncSUMXMY2()
+{
+    m_pDoc->InsertTab(0, "Test SumXMY2");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto recalc.
+
+    ScAddress aPos(0,0,0);
+    m_pDoc->SetString(aPos, "=SUMXMY2(B1:B3;C1:C3)");
+    CPPUNIT_ASSERT_EQUAL(0.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(1,0,0),  1.0); // B1
+    CPPUNIT_ASSERT_EQUAL(1.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(1,1,0),  2.0); // B2
+    CPPUNIT_ASSERT_EQUAL(5.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(1,2,0),  3.0); // B3
+    CPPUNIT_ASSERT_EQUAL(14.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(2,0,0), -1.0); // C1
+    CPPUNIT_ASSERT_EQUAL(17.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(2,1,0),  3.0); // C2
+    CPPUNIT_ASSERT_EQUAL(14.0,  m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(ScAddress(2,2,0),  1.0); // C3
+    CPPUNIT_ASSERT_EQUAL(9.0,  m_pDoc->GetValue(aPos));
+
+    double result = 0.0;
+    m_pDoc->SetString(0, 4, 0, "=SUMXMY2({2;3;4};{4;3;2})");
+    m_pDoc->GetValue(0, 4, 0, result);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of SUMXMY2 with inline arrays failed", 8.0, result);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncMIN()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto recalc.
+    m_pDoc->InsertTab(0, "Formula");
+
+    // A1:A2
+    m_pDoc->SetString(ScAddress(0,0,0), "a");
+    m_pDoc->SetString(ScAddress(0,1,0), "b");
+
+    // B1:B2
+    m_pDoc->SetValue(ScAddress(1,0,0), 1.0);
+    m_pDoc->SetValue(ScAddress(1,1,0), 2.0);
+
+    // Matrix in C1:C2.
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(2, 0, 2, 1, aMark, "=MIN(IF(A1:A2=\"c\";B1:B2))");
+
+    // Formula cell in C1:C2 should be a 1x2 matrix array.
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(2,0,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("This formula should be an array.", ScMatrixMode::Formula, pFC->GetMatrixFlag());
+
+    SCCOL nCols;
+    SCROW nRows;
+    pFC->GetMatColsRows(nCols, nRows);
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), nCols);
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), nRows);
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Formula in C1 is invalid.", 0, static_cast<int>(m_pDoc->GetErrCode(ScAddress(2,0,0))));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Formula in C2 is invalid.", 0, static_cast<int>(m_pDoc->GetErrCode(ScAddress(2,1,0))));
+
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(2,0,0)));
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+
+    // Inline array input (A4).
+    m_pDoc->SetString(ScAddress(0,3,0), "=MIN({-2;4;3})");
+    CPPUNIT_ASSERT_EQUAL(-2.0, m_pDoc->GetValue(ScAddress(0,3,0)));
+
+    // Add more values to B3:B4.
+    m_pDoc->SetValue(ScAddress(1,2,0),  20.0);
+    m_pDoc->SetValue(ScAddress(1,3,0), -20.0);
+
+    // Get the MIN of B1:B4.
+    m_pDoc->SetString(ScAddress(2,4,0), "=MIN(B1:B4)");
+    CPPUNIT_ASSERT_EQUAL(-20.0, m_pDoc->GetValue(ScAddress(2,4,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncN()
+{
+    OUString const aTabName("foo");
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, aTabName));
+
+    double result;
+
+    // Clear the area first.
+    clearRange(m_pDoc, ScRange(0, 0, 0, 1, 20, 0));
+
+    // Put values to reference.
+    double val = 0;
+    m_pDoc->SetValue(0, 0, 0, val);
+    m_pDoc->SetString(0, 2, 0, "Text");
+    val = 1;
+    m_pDoc->SetValue(0, 3, 0, val);
+    val = -1;
+    m_pDoc->SetValue(0, 4, 0, val);
+    val = 12.3;
+    m_pDoc->SetValue(0, 5, 0, val);
+    m_pDoc->SetString(0, 6, 0, "'12.3");
+
+    // Cell references
+    m_pDoc->SetString(1, 0, 0, "=N(A1)");
+    m_pDoc->SetString(1, 1, 0, "=N(A2)");
+    m_pDoc->SetString(1, 2, 0, "=N(A3)");
+    m_pDoc->SetString(1, 3, 0, "=N(A4)");
+    m_pDoc->SetString(1, 4, 0, "=N(A5)");
+    m_pDoc->SetString(1, 5, 0, "=N(A6)");
+    m_pDoc->SetString(1, 6, 0, "=N(A9)");
+
+    // In-line values
+    m_pDoc->SetString(1, 7, 0, "=N(0)");
+    m_pDoc->SetString(1, 8, 0, "=N(1)");
+    m_pDoc->SetString(1, 9, 0, "=N(-1)");
+    m_pDoc->SetString(1, 10, 0, "=N(123)");
+    m_pDoc->SetString(1, 11, 0, "=N(\"\")");
+    m_pDoc->SetString(1, 12, 0, "=N(\"12\")");
+    m_pDoc->SetString(1, 13, 0, "=N(\"foo\")");
+
+    // Range references
+    m_pDoc->SetString(2, 2, 0, "=N(A1:A8)");
+    m_pDoc->SetString(2, 3, 0, "=N(A1:A8)");
+    m_pDoc->SetString(2, 4, 0, "=N(A1:A8)");
+    m_pDoc->SetString(2, 5, 0, "=N(A1:A8)");
+
+    // Calculate and check the results.
+    m_pDoc->CalcAll();
+    double checks1[] = {
+        0, 0,  0,    1, -1, 12.3, 0, // cell reference
+        0, 1, -1, 123,  0,    0, 0   // in-line values
+    };
+    for (size_t i = 0; i < SAL_N_ELEMENTS(checks1); ++i)
+    {
+        m_pDoc->GetValue(1, i, 0, result);
+        bool bGood = result == checks1[i];
+        if (!bGood)
+        {
+            cerr << "row " << (i+1) << ": expected=" << checks1[i] << " actual=" << result << endl;
+            CPPUNIT_ASSERT_MESSAGE("Unexpected result for N", false);
+        }
+    }
+    double checks2[] = {
+        0, 1, -1, 12.3               // range references
+    };
+    for (size_t i = 0; i < SAL_N_ELEMENTS(checks2); ++i)
+    {
+        m_pDoc->GetValue(1, i+2, 0, result);
+        bool bGood = result == checks2[i];
+        if (!bGood)
+        {
+            cerr << "row " << (i+2+1) << ": expected=" << checks2[i] << " actual=" << result << endl;
+            CPPUNIT_ASSERT_MESSAGE("Unexpected result for N", false);
+        }
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncCOUNTIF()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    // COUNTIF (test case adopted from OOo i#36381)
+
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+
+    // Empty A1:A39 first.
+    clearRange(m_pDoc, ScRange(0, 0, 0, 0, 40, 0));
+
+    // Raw data (rows 1 through 9)
+    const char* aData[] = {
+        "1999",
+        "2000",
+        "0",
+        "0",
+        "0",
+        "2002",
+        "2001",
+        "X",
+        "2002"
+    };
+
+    SCROW nRows = SAL_N_ELEMENTS(aData);
+    for (SCROW i = 0; i < nRows; ++i)
+        m_pDoc->SetString(0, i, 0, OUString::createFromAscii(aData[i]));
+
+    printRange(m_pDoc, ScRange(0, 0, 0, 0, 8, 0), "data range for COUNTIF");
+
+    // formulas and results
+    static const struct {
+        const char* pFormula; double fResult;
+    } aChecks[] = {
+        { "=COUNTIF(A1:A12;1999)",       1 },
+        { "=COUNTIF(A1:A12;2002)",       2 },
+        { "=COUNTIF(A1:A12;1998)",       0 },
+        { "=COUNTIF(A1:A12;\">=1999\")", 5 },
+        { "=COUNTIF(A1:A12;\">1999\")",  4 },
+        { "=COUNTIF(A1:A12;\"<2001\")",  5 },
+        { "=COUNTIF(A1:A12;\">0\")",     5 },
+        { "=COUNTIF(A1:A12;\">=0\")",    8 },
+        { "=COUNTIF(A1:A12;0)",          3 },
+        { "=COUNTIF(A1:A12;\"X\")",      1 },
+        { "=COUNTIF(A1:A12;)",           3 }
+    };
+
+    nRows = SAL_N_ELEMENTS(aChecks);
+    for (SCROW i = 0; i < nRows; ++i)
+    {
+        SCROW nRow = 20 + i;
+        m_pDoc->SetString(0, nRow, 0, OUString::createFromAscii(aChecks[i].pFormula));
+    }
+
+    for (SCROW i = 0; i < nRows; ++i)
+    {
+        double result;
+        SCROW nRow = 20 + i;
+        m_pDoc->GetValue(0, nRow, 0, result);
+        bool bGood = result == aChecks[i].fResult;
+        if (!bGood)
+        {
+            cerr << "row " << (nRow+1) << ": formula" << aChecks[i].pFormula
+                << "  expected=" << aChecks[i].fResult << "  actual=" << result << endl;
+            CPPUNIT_ASSERT_MESSAGE("Unexpected result for COUNTIF", false);
+        }
+    }
+
+    // Don't count empty strings when searching for a number.
+
+    // Clear A1:A2.
+    clearRange(m_pDoc, ScRange(0, 0, 0, 0, 1, 0));
+
+    m_pDoc->SetString(0, 0, 0, "=\"\"");
+    m_pDoc->SetString(0, 1, 0, "=COUNTIF(A1;1)");
+
+    double result = m_pDoc->GetValue(0, 1, 0);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("We shouldn't count empty string as valid number.", 0.0, result);
+
+    // Another test case adopted from fdo#77039.
+    clearSheet(m_pDoc, 0);
+
+    // Set formula cells with blank results in A1:A4.
+    for (SCROW i = 0; i <=3; ++i)
+        m_pDoc->SetString(ScAddress(0,i,0), "=\"\"");
+
+    // Insert formula into A5 to count all cells with empty strings.
+    m_pDoc->SetString(ScAddress(0,4,0), "=COUNTIF(A1:A4;\"\"");
+
+    // We should correctly count with empty string key.
+    CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(0,4,0)));
+
+    // Another test case adopted from tdf#99291, empty array elements should
+    // not match empty cells, but cells with 0.
+    clearSheet(m_pDoc, 0);
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(0,0, 0,1, aMark, "=COUNTIF(B1:B5;C1:C2)");
+    // As we will be testing for 0.0 values, check that formulas are actually present.
+    OUString aFormula;
+    m_pDoc->GetFormula(0,0,0, aFormula);
+    CPPUNIT_ASSERT_EQUAL(OUString("{=COUNTIF(B1:B5;C1:C2)}"), aFormula);
+    m_pDoc->GetFormula(0,1,0, aFormula);
+    CPPUNIT_ASSERT_EQUAL(OUString("{=COUNTIF(B1:B5;C1:C2)}"), aFormula);
+    // The 0.0 results expected.
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(0,0,0)));
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+    // 0.0 in B2, 1.0 in B3 and B4
+    m_pDoc->SetValue( ScAddress(1,1,0), 0.0);
+    m_pDoc->SetValue( ScAddress(1,2,0), 1.0);
+    m_pDoc->SetValue( ScAddress(1,3,0), 1.0);
+    // Matched by 0.0 produced by empty cell in array, and 1.0 in C2.
+    m_pDoc->SetValue( ScAddress(2,1,0), 1.0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("One cell with 0.0",  1.0, m_pDoc->GetValue(ScAddress(0,0,0)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Two cells with 1.0", 2.0, m_pDoc->GetValue(ScAddress(0,1,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncIF()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Formula");
+
+    m_pDoc->SetString(ScAddress(0,0,0), "=IF(B1=2;\"two\";\"not two\")");
+    CPPUNIT_ASSERT_EQUAL(OUString("not two"), m_pDoc->GetString(ScAddress(0,0,0)));
+    m_pDoc->SetValue(ScAddress(1,0,0), 2.0);
+    CPPUNIT_ASSERT_EQUAL(OUString("two"), m_pDoc->GetString(ScAddress(0,0,0)));
+    m_pDoc->SetValue(ScAddress(1,0,0), 3.0);
+    CPPUNIT_ASSERT_EQUAL(OUString("not two"), m_pDoc->GetString(ScAddress(0,0,0)));
+
+    // Test nested IF in array/matrix if the nested IF condition is a scalar.
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(0,2, 1,2, aMark, "=IF({1;0};IF(1;23);42)");
+    // Results must be 23 and 42.
+    CPPUNIT_ASSERT_EQUAL(23.0, m_pDoc->GetValue(ScAddress(0,2,0)));
+    CPPUNIT_ASSERT_EQUAL(42.0, m_pDoc->GetValue(ScAddress(1,2,0)));
+
+    // Test nested IF in array/matrix if nested IF conditions are range
+    // references, data in A5:C8, matrix formula in D4 so there is no
+    // implicit intersection between formula and ranges.
+    {
+        const char* aData[][3] = {
+            { "1", "1", "16" },
+            { "0", "1", "32" },
+            { "1", "0", "64" },
+            { "0", "0", "128" }
+        };
+        ScAddress aPos(0,4,0);
+        ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+        CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+    }
+    m_pDoc->InsertMatrixFormula(3,3, 3,3, aMark, "=SUM(IF(A5:A8;IF(B5:B8;C5:C8;0);0))");
+    // Result must be 16, only the first row matches all criteria.
+    CPPUNIT_ASSERT_EQUAL(16.0, m_pDoc->GetValue(ScAddress(3,3,0)));
+
+    // A11:B11
+    // Test nested IF in array/matrix if the nested IF has no Else path.
+    m_pDoc->InsertMatrixFormula(0,10, 1,10, aMark, "=IF(IF({1;0};12);34;56)");
+    // Results must be 34 and 56.
+    CPPUNIT_ASSERT_EQUAL(34.0, m_pDoc->GetValue(ScAddress(0,10,0)));
+    CPPUNIT_ASSERT_EQUAL(56.0, m_pDoc->GetValue(ScAddress(1,10,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncCHOOSE()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Formula");
+
+    m_pDoc->SetString(ScAddress(0,0,0), "=CHOOSE(B1;\"one\";\"two\";\"three\")");
+    FormulaError nError = m_pDoc->GetErrCode(ScAddress(0,0,0));
+    CPPUNIT_ASSERT_MESSAGE("Formula result should be an error since B1 is still empty.", nError != FormulaError::NONE);
+    m_pDoc->SetValue(ScAddress(1,0,0), 1.0);
+    CPPUNIT_ASSERT_EQUAL(OUString("one"), m_pDoc->GetString(ScAddress(0,0,0)));
+    m_pDoc->SetValue(ScAddress(1,0,0), 2.0);
+    CPPUNIT_ASSERT_EQUAL(OUString("two"), m_pDoc->GetString(ScAddress(0,0,0)));
+    m_pDoc->SetValue(ScAddress(1,0,0), 3.0);
+    CPPUNIT_ASSERT_EQUAL(OUString("three"), m_pDoc->GetString(ScAddress(0,0,0)));
+    m_pDoc->SetValue(ScAddress(1,0,0), 4.0);
+    nError = m_pDoc->GetErrCode(ScAddress(0,0,0));
+    CPPUNIT_ASSERT_MESSAGE("Formula result should be an error due to out-of-bound input..", nError != FormulaError::NONE);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncIFERROR()
+{
+    // IFERROR/IFNA (fdo#56124)
+
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+
+    // Empty A1:A39 first.
+    clearRange(m_pDoc, ScRange(0, 0, 0, 0, 40, 0));
+
+    // Raw data (rows 1 through 12)
+    const char* aData[] = {
+        "1",
+        "e",
+        "=SQRT(4)",
+        "=SQRT(-2)",
+        "=A4",
+        "=1/0",
+        "=NA()",
+        "bar",
+        "4",
+        "gee",
+        "=1/0",
+        "23"
+    };
+
+    SCROW nRows = SAL_N_ELEMENTS(aData);
+    for (SCROW i = 0; i < nRows; ++i)
+        m_pDoc->SetString(0, i, 0, OUString::createFromAscii(aData[i]));
+
+    printRange(m_pDoc, ScRange(0, 0, 0, 0, nRows-1, 0), "data range for IFERROR/IFNA");
+
+    // formulas and results
+    static const struct {
+        const char* pFormula; const char* pResult;
+    } aChecks[] = {
+        { "=IFERROR(A1;9)",                         "1" },
+        { "=IFERROR(A2;9)",                         "e" },
+        { "=IFERROR(A3;9)",                         "2" },
+        { "=IFERROR(A4;-7)",                       "-7" },
+        { "=IFERROR(A5;-7)",                       "-7" },
+        { "=IFERROR(A6;-7)",                       "-7" },
+        { "=IFERROR(A7;-7)",                       "-7" },
+        { "=IFNA(A6;9)",                      "#DIV/0!" },
+        { "=IFNA(A7;-7)",                          "-7" },
+        { "=IFNA(VLOOKUP(\"4\";A8:A10;1;0);-2)",    "4" },
+        { "=IFNA(VLOOKUP(\"fop\";A8:A10;1;0);-2)", "-2" },
+        { "{=IFERROR(3*A11:A12;1998)}[0]",       "1998" },  // um... this is not the correct way to insert a
+        { "{=IFERROR(3*A11:A12;1998)}[1]",         "69" }   // matrix formula, just a place holder, see below
+    };
+
+    nRows = SAL_N_ELEMENTS(aChecks);
+    for (SCROW i = 0; i < nRows-2; ++i)
+    {
+        SCROW nRow = 20 + i;
+        m_pDoc->SetString(0, nRow, 0, OUString::createFromAscii(aChecks[i].pFormula));
+    }
+
+    // Create a matrix range in last two rows of the range above, actual data
+    // of the placeholders.
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(0, 20 + nRows-2, 0, 20 + nRows-1, aMark, "=IFERROR(3*A11:A12;1998)");
+
+    m_pDoc->CalcAll();
+
+    for (SCROW i = 0; i < nRows; ++i)
+    {
+        SCROW nRow = 20 + i;
+        OUString aResult = m_pDoc->GetString(0, nRow, 0);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE(
+            aChecks[i].pFormula, OUString::createFromAscii( aChecks[i].pResult), aResult);
+    }
+
+    const SCCOL nCols = 3;
+    const char* aData2[][nCols] = {
+        { "1", "2",    "3" },
+        { "4", "=1/0", "6" },
+        { "7", "8",    "9" }
+    };
+    const char* aCheck2[][nCols] = {
+        { "1", "2",    "3" },
+        { "4", "Error","6" },
+        { "7", "8",    "9" }
+    };
+
+    // Data in C1:E3
+    ScAddress aPos(2,0,0);
+    ScRange aRange = insertRangeData(m_pDoc, aPos, aData2, SAL_N_ELEMENTS(aData2));
+    CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+
+    // Array formula in F4:H6
+    const SCROW nElems2 = SAL_N_ELEMENTS(aCheck2);
+    const SCCOL nStartCol = aPos.Col() + nCols;
+    const SCROW nStartRow = aPos.Row() + nElems2;
+    m_pDoc->InsertMatrixFormula( nStartCol, nStartRow, nStartCol+nCols-1, nStartRow+nElems2-1, aMark,
+            "=IFERROR(C1:E3;\"Error\")");
+
+    m_pDoc->CalcAll();
+
+    for (SCCOL nCol = nStartCol; nCol < nStartCol + nCols; ++nCol)
+    {
+        for (SCROW nRow = nStartRow; nRow < nStartRow + nElems2; ++nRow)
+        {
+            OUString aResult = m_pDoc->GetString( nCol, nRow, 0);
+            CPPUNIT_ASSERT_EQUAL_MESSAGE( "IFERROR array result",
+                    OUString::createFromAscii( aCheck2[nRow-nStartRow][nCol-nStartCol]), aResult);
+        }
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncSHEET()
+{
+    OUString const aTabName1("test1");
+    OUString const aTabName2("test2");
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (SC_TAB_APPEND, aTabName1));
+
+    m_pDoc->SetString(0, 0, 0, "=SHEETS()");
+    m_pDoc->CalcFormulaTree(false, false);
+    double original;
+    m_pDoc->GetValue(0, 0, 0, original);
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("result of SHEETS() should equal the number of sheets, but doesn't.",
+                           static_cast<SCTAB>(original), m_pDoc->GetTableCount());
+
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (SC_TAB_APPEND, aTabName2));
+
+    double modified;
+    m_pDoc->GetValue(0, 0, 0, modified);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("result of SHEETS() did not get updated after sheet insertion.",
+                           1.0, modified - original);
+
+    SCTAB nTabCount = m_pDoc->GetTableCount();
+    m_pDoc->DeleteTab(--nTabCount);
+
+    m_pDoc->GetValue(0, 0, 0, modified);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("result of SHEETS() did not get updated after sheet removal.",
+                           0.0, modified - original);
+
+    m_pDoc->DeleteTab(--nTabCount);
+}
+
+void Test::testFuncNOW()
+{
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+
+    double val = 1;
+    m_pDoc->SetValue(0, 0, 0, val);
+    m_pDoc->SetString(0, 1, 0, "=IF(A1>0;NOW();0");
+    double now1;
+    m_pDoc->GetValue(0, 1, 0, now1);
+    CPPUNIT_ASSERT_MESSAGE("Value of NOW() should be positive.", now1 > 0.0);
+
+    val = 0;
+    m_pDoc->SetValue(0, 0, 0, val);
+    m_pDoc->CalcFormulaTree(false, false);
+    double zero;
+    m_pDoc->GetValue(0, 1, 0, zero);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Result should equal the 3rd parameter of IF, which is zero.", 0.0, zero);
+
+    val = 1;
+    m_pDoc->SetValue(0, 0, 0, val);
+    m_pDoc->CalcFormulaTree(false, false);
+    double now2;
+    m_pDoc->GetValue(0, 1, 0, now2);
+    CPPUNIT_ASSERT_MESSAGE("Result should be the value of NOW() again.", (now2 - now1) >= 0.0);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncNUMBERVALUE()
+{
+    // NUMBERVALUE fdo#57180
+
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+
+    // Empty A1:A39 first.
+    clearRange(m_pDoc, ScRange(0, 0, 0, 0, 40, 0));
+
+    // Raw data (rows 1 through 6)
+    const char* aData[] = {
+        "1ag9a9b9",
+        "1ag34 5g g6  78b9%%",
+        "1 234d56E-2",
+        "d4",
+        "54.4",
+        "1a2b3e1%"
+    };
+
+    SCROW nRows = SAL_N_ELEMENTS(aData);
+    for (SCROW i = 0; i < nRows; ++i)
+        m_pDoc->SetString(0, i, 0, OUString::createFromAscii(aData[i]));
+
+    printRange(m_pDoc, ScRange(0, 0, 0, 0, nRows - 1, 0), "data range for NUMBERVALUE");
+
+    // formulas and results
+    static const struct {
+        const char* pFormula; const char* pResult;
+    } aChecks[] = {
+        { "=NUMBERVALUE(A1;\"b\";\"ag\")",  "199.9" },
+        { "=NUMBERVALUE(A2;\"b\";\"ag\")",  "134.56789" },
+        { "=NUMBERVALUE(A2;\"b\";\"g\")",   "#VALUE!" },
+        { "=NUMBERVALUE(A3;\"d\")",         "12.3456" },
+        { "=NUMBERVALUE(A4;\"d\";\"foo\")", "0.4" },
+        { "=NUMBERVALUE(A4;)",              "Err:502" },
+        { "=NUMBERVALUE(A5;)",              "Err:502" },
+        { "=NUMBERVALUE(A6;\"b\";\"a\")",   "1.23" }
+    };
+
+    nRows = SAL_N_ELEMENTS(aChecks);
+    for (SCROW i = 0; i < nRows; ++i)
+    {
+        SCROW nRow = 20 + i;
+        m_pDoc->SetString(0, nRow, 0, OUString::createFromAscii(aChecks[i].pFormula));
+    }
+    m_pDoc->CalcAll();
+
+    for (SCROW i = 0; i < nRows; ++i)
+    {
+        SCROW nRow = 20 + i;
+        OUString aResult = m_pDoc->GetString(0, nRow, 0);
+        CPPUNIT_ASSERT_EQUAL_MESSAGE(
+            aChecks[i].pFormula, OUString::createFromAscii( aChecks[i].pResult), aResult);
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncLEN()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Formula");
+
+    // Leave A1:A3 empty, and insert an array of LEN in B1:B3 that references
+    // these empty cells.
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(1, 0, 1, 2, aMark, "=LEN(A1:A3)");
+
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(1,0,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("This formula should be a matrix origin.",
+                           ScMatrixMode::Formula, pFC->GetMatrixFlag());
+
+    // This should be a 1x3 matrix.
+    SCCOL nCols = -1;
+    SCROW nRows = -1;
+    pFC->GetMatColsRows(nCols, nRows);
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCCOL>(1), nCols);
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(3), nRows);
+
+    // LEN value should be 0 for an empty cell.
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(1,0,0)));
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(1,1,0)));
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(ScAddress(1,2,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncLOOKUP()
+{
+    FormulaGrammarSwitch aFGSwitch(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH_XL_R1C1);
+
+    m_pDoc->InsertTab(0, "Test");
+
+    // Raw data
+    const char* aData[][2] = {
+        { "=CONCATENATE(\"A\")", "1" },
+        { "=CONCATENATE(\"B\")", "2" },
+        { "=CONCATENATE(\"C\")", "3" },
+        { nullptr, nullptr } // terminator
+    };
+
+    // Insert raw data into A1:B3.
+    for (SCROW i = 0; aData[i][0]; ++i)
+    {
+        m_pDoc->SetString(0, i, 0, OUString::createFromAscii(aData[i][0]));
+        m_pDoc->SetString(1, i, 0, OUString::createFromAscii(aData[i][1]));
+    }
+
+    const char* aData2[][2] = {
+        { "A", "=LOOKUP(RC[-1];R1C1:R3C1;R1C2:R3C2)" },
+        { "B", "=LOOKUP(RC[-1];R1C1:R3C1;R1C2:R3C2)" },
+        { "C", "=LOOKUP(RC[-1];R1C1:R3C1;R1C2:R3C2)" },
+        { nullptr, nullptr } // terminator
+    };
+
+    // Insert check formulas into A5:B7.
+    for (SCROW i = 0; aData2[i][0]; ++i)
+    {
+        m_pDoc->SetString(0, i+4, 0, OUString::createFromAscii(aData2[i][0]));
+        m_pDoc->SetString(1, i+4, 0, OUString::createFromAscii(aData2[i][1]));
+    }
+
+    printRange(m_pDoc, ScRange(0,4,0,1,6,0), "Data range for LOOKUP.");
+
+    // Values for B5:B7 should be 1, 2, and 3.
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("This formula should not have an error code.", 0, static_cast<int>(m_pDoc->GetErrCode(ScAddress(1,4,0))));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("This formula should not have an error code.", 0, static_cast<int>(m_pDoc->GetErrCode(ScAddress(1,5,0))));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("This formula should not have an error code.", 0, static_cast<int>(m_pDoc->GetErrCode(ScAddress(1,6,0))));
+
+    ASSERT_DOUBLES_EQUAL(1.0, m_pDoc->GetValue(ScAddress(1,4,0)));
+    ASSERT_DOUBLES_EQUAL(2.0, m_pDoc->GetValue(ScAddress(1,5,0)));
+    ASSERT_DOUBLES_EQUAL(3.0, m_pDoc->GetValue(ScAddress(1,6,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncLOOKUParrayWithError()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true);
+    m_pDoc->InsertTab(0, "Test");
+
+    std::vector<std::vector<const char*>> aData = {
+        { "x", "y", "z" },
+        { "a", "b", "c" }
+    };
+    insertRangeData(m_pDoc, ScAddress(2,1,0), aData);               // C2:E3
+    m_pDoc->SetString(0,0,0, "=LOOKUP(2;1/(C2:E2<>\"\");C3:E3)");   // A1
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should find match for last column.", OUString("c"), m_pDoc->GetString(0,0,0));
+    m_pDoc->SetString(4,1,0, "");                                   // E2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should find match for second last column.", OUString("b"), m_pDoc->GetString(0,0,0));
+
+    m_pDoc->SetString(6,1,0, "one");                                // G2
+    m_pDoc->SetString(6,5,0, "two");                                // G6
+    // Creates an interim array {1,#DIV/0!,#DIV/0!,#DIV/0!,1,#DIV/0!,#DIV/0!,#DIV/0!}
+    m_pDoc->SetString(7,8,0, "=LOOKUP(2;1/(NOT(ISBLANK(G2:G9)));G2:G9)"); // H9
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should find match for last row.", OUString("two"), m_pDoc->GetString(7,8,0));
+
+    // Lookup on empty range.
+    m_pDoc->SetString(9,8,0, "=LOOKUP(2;1/(NOT(ISBLANK(I2:I9)));I2:I9)"); // J9
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should find no match.", OUString("#N/A"), m_pDoc->GetString(9,8,0));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncVLOOKUP()
+{
+    // VLOOKUP
+
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+
+    // Clear A1:F40.
+    clearRange(m_pDoc, ScRange(0, 0, 0, 5, 39, 0));
+
+    // Raw data
+    const char* aData[][2] = {
+        { "Key", "Val" },
+        {  "10",   "3" },
+        {  "20",   "4" },
+        {  "30",   "5" },
+        {  "40",   "6" },
+        {  "50",   "7" },
+        {  "60",   "8" },
+        {  "70",   "9" },
+        {   "B",  "10" },
+        {   "B",  "11" },
+        {   "C",  "12" },
+        {   "D",  "13" },
+        {   "E",  "14" },
+        {   "F",  "15" },
+        { nullptr, nullptr } // terminator
+    };
+
+    // Insert raw data into A1:B14.
+    for (SCROW i = 0; aData[i][0]; ++i)
+    {
+        m_pDoc->SetString(0, i, 0, OUString::createFromAscii(aData[i][0]));
+        m_pDoc->SetString(1, i, 0, OUString::createFromAscii(aData[i][1]));
+    }
+
+    printRange(m_pDoc, ScRange(0, 0, 0, 1, 13, 0), "raw data for VLOOKUP");
+
+    // Formula data
+    static const struct {
+        const char* pLookup; const char* pFormula; const char* pRes;
+    } aChecks[] = {
+        { "Lookup",  "Formula", nullptr },
+        { "12",      "=VLOOKUP(D2;A2:B14;2;1)",     "3" },
+        { "29",      "=VLOOKUP(D3;A2:B14;2;1)",     "4" },
+        { "31",      "=VLOOKUP(D4;A2:B14;2;1)",     "5" },
+        { "45",      "=VLOOKUP(D5;A2:B14;2;1)",     "6" },
+        { "56",      "=VLOOKUP(D6;A2:B14;2;1)",     "7" },
+        { "65",      "=VLOOKUP(D7;A2:B14;2;1)",     "8" },
+        { "78",      "=VLOOKUP(D8;A2:B14;2;1)",     "9" },
+        { "Andy",    "=VLOOKUP(D9;A2:B14;2;1)",  "#N/A" },
+        { "Bruce",   "=VLOOKUP(D10;A2:B14;2;1)",   "11" },
+        { "Charlie", "=VLOOKUP(D11;A2:B14;2;1)",   "12" },
+        { "David",   "=VLOOKUP(D12;A2:B14;2;1)",   "13" },
+        { "Edward",  "=VLOOKUP(D13;A2:B14;2;1)",   "14" },
+        { "Frank",   "=VLOOKUP(D14;A2:B14;2;1)",   "15" },
+        { "Henry",   "=VLOOKUP(D15;A2:B14;2;1)",   "15" },
+        { "100",     "=VLOOKUP(D16;A2:B14;2;1)",    "9" },
+        { "1000",    "=VLOOKUP(D17;A2:B14;2;1)",    "9" },
+        { "Zena",    "=VLOOKUP(D18;A2:B14;2;1)",   "15" }
+    };
+
+    // Insert formula data into D1:E18.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+    {
+        m_pDoc->SetString(3, i, 0, OUString::createFromAscii(aChecks[i].pLookup));
+        m_pDoc->SetString(4, i, 0, OUString::createFromAscii(aChecks[i].pFormula));
+    }
+    m_pDoc->CalcAll();
+    printRange(m_pDoc, ScRange(3, 0, 0, 4, 17, 0), "formula data for VLOOKUP");
+
+    // Verify results.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+    {
+        if (i == 0)
+            // Skip the header row.
+            continue;
+
+        OUString aRes = m_pDoc->GetString(4, i, 0);
+        bool bGood = aRes.equalsAscii(aChecks[i].pRes);
+        if (!bGood)
+        {
+            cerr << "row " << (i+1) << ": lookup value='" << aChecks[i].pLookup
+                << "'  expected='" << aChecks[i].pRes << "' actual='" << aRes << "'" << endl;
+            CPPUNIT_ASSERT_MESSAGE("Unexpected result for VLOOKUP", false);
+        }
+    }
+
+    // Clear the sheet and start over.
+    clearSheet(m_pDoc, 0);
+
+    // Lookup on sorted data interspersed with empty cells.
+
+    // A1:B8 is the search range.
+    m_pDoc->SetValue(ScAddress(0,2,0), 1.0);
+    m_pDoc->SetValue(ScAddress(0,4,0), 2.0);
+    m_pDoc->SetValue(ScAddress(0,7,0), 4.0);
+    m_pDoc->SetString(ScAddress(1,2,0), "One");
+    m_pDoc->SetString(ScAddress(1,4,0), "Two");
+    m_pDoc->SetString(ScAddress(1,7,0), "Four");
+
+    // D1:D5 contain match values.
+    m_pDoc->SetValue(ScAddress(3,0,0), 1.0);
+    m_pDoc->SetValue(ScAddress(3,1,0), 2.0);
+    m_pDoc->SetValue(ScAddress(3,2,0), 3.0);
+    m_pDoc->SetValue(ScAddress(3,3,0), 4.0);
+    m_pDoc->SetValue(ScAddress(3,4,0), 5.0);
+
+    // E1:E5 contain formulas.
+    m_pDoc->SetString(ScAddress(4,0,0), "=VLOOKUP(D1;$A$1:$B$8;2)");
+    m_pDoc->SetString(ScAddress(4,1,0), "=VLOOKUP(D2;$A$1:$B$8;2)");
+    m_pDoc->SetString(ScAddress(4,2,0), "=VLOOKUP(D3;$A$1:$B$8;2)");
+    m_pDoc->SetString(ScAddress(4,3,0), "=VLOOKUP(D4;$A$1:$B$8;2)");
+    m_pDoc->SetString(ScAddress(4,4,0), "=VLOOKUP(D5;$A$1:$B$8;2)");
+    m_pDoc->CalcAll();
+
+    // Check the formula results in E1:E5.
+    CPPUNIT_ASSERT_EQUAL(OUString("One"), m_pDoc->GetString(ScAddress(4,0,0)));
+    CPPUNIT_ASSERT_EQUAL(OUString("Two"), m_pDoc->GetString(ScAddress(4,1,0)));
+    CPPUNIT_ASSERT_EQUAL(OUString("Two"), m_pDoc->GetString(ScAddress(4,2,0)));
+    CPPUNIT_ASSERT_EQUAL(OUString("Four"), m_pDoc->GetString(ScAddress(4,3,0)));
+    CPPUNIT_ASSERT_EQUAL(OUString("Four"), m_pDoc->GetString(ScAddress(4,4,0)));
+
+    // Start over again.
+    clearSheet(m_pDoc, 0);
+
+    // Set A,B,...,G to A1:A7.
+    m_pDoc->SetString(ScAddress(0,0,0), "A");
+    m_pDoc->SetString(ScAddress(0,1,0), "B");
+    m_pDoc->SetString(ScAddress(0,2,0), "C");
+    m_pDoc->SetString(ScAddress(0,3,0), "D");
+    m_pDoc->SetString(ScAddress(0,4,0), "E");
+    m_pDoc->SetString(ScAddress(0,5,0), "F");
+    m_pDoc->SetString(ScAddress(0,6,0), "G");
+
+    // Set the formula in C1.
+    m_pDoc->SetString(ScAddress(2,0,0), "=VLOOKUP(\"C\";A1:A16;1)");
+    CPPUNIT_ASSERT_EQUAL(OUString("C"), m_pDoc->GetString(ScAddress(2,0,0)));
+
+
+    // A21:E24, test position dependent implicit intersection as argument to a
+    // scalar value parameter in a function that has a ReferenceOrForceArray
+    // type parameter somewhere else and formula is not in array mode,
+    // VLOOKUP(Value;ReferenceOrForceArray;...)
+    const char* aData2[][5] = {
+        { "1", "one",   "3", "=VLOOKUP(C21:C24;A21:B24;2;0)", "three" },
+        { "2", "two",   "1", "=VLOOKUP(C21:C24;A21:B24;2;0)", "one"   },
+        { "3", "three", "4", "=VLOOKUP(C21:C24;A21:B24;2;0)", "four"  },
+        { "4", "four",  "2", "=VLOOKUP(C21:C24;A21:B24;2;0)", "two"   }
+    };
+
+    ScAddress aPos2(0,20,0);
+    ScRange aRange2 = insertRangeData(m_pDoc, aPos2, aData2, SAL_N_ELEMENTS(aData2));
+    CPPUNIT_ASSERT_EQUAL(aPos2, aRange2.aStart);
+
+    aPos2.SetCol(3);    // column D formula results
+    for (size_t i=0; i < SAL_N_ELEMENTS(aData2); ++i)
+    {
+        CPPUNIT_ASSERT_EQUAL( OUString::createFromAscii( aData2[i][4]), m_pDoc->GetString(aPos2));
+        aPos2.IncRow();
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+namespace {
+
+struct StrStrCheck {
+    const char* pVal;
+    const char* pRes;
+};
+
+}
+
+template<size_t DataSize, size_t FormulaSize, int Type>
+static void runTestMATCH(ScDocument* pDoc, const char* aData[DataSize], const StrStrCheck aChecks[FormulaSize])
+{
+    size_t nDataSize = DataSize;
+    for (size_t i = 0; i < nDataSize; ++i)
+        pDoc->SetString(0, i, 0, OUString::createFromAscii(aData[i]));
+
+    for (size_t i = 0; i < FormulaSize; ++i)
+    {
+        pDoc->SetString(1, i, 0, OUString::createFromAscii(aChecks[i].pVal));
+
+        OUStringBuffer aBuf;
+        aBuf.append("=MATCH(B");
+        aBuf.append(static_cast<sal_Int32>(i+1));
+        aBuf.append(";A1:A");
+        aBuf.append(static_cast<sal_Int32>(nDataSize));
+        aBuf.append(";");
+        aBuf.append(static_cast<sal_Int32>(Type));
+        aBuf.append(")");
+        OUString aFormula = aBuf.makeStringAndClear();
+        pDoc->SetString(2, i, 0, aFormula);
+    }
+
+    pDoc->CalcAll();
+    Test::printRange(pDoc, ScRange(0, 0, 0, 2, FormulaSize-1, 0), "MATCH");
+
+    // verify the results.
+    for (size_t i = 0; i < FormulaSize; ++i)
+    {
+        OUString aStr = pDoc->GetString(2, i, 0);
+        if (!aStr.equalsAscii(aChecks[i].pRes))
+        {
+            cerr << "row " << (i+1) << ": expected='" << aChecks[i].pRes << "' actual='" << aStr << "'"
+                " criterion='" << aChecks[i].pVal << "'" << endl;
+            CPPUNIT_ASSERT_MESSAGE("Unexpected result for MATCH", false);
+        }
+    }
+}
+
+template<size_t DataSize, size_t FormulaSize, int Type>
+static void runTestHorizontalMATCH(ScDocument* pDoc, const char* aData[DataSize], const StrStrCheck aChecks[FormulaSize])
+{
+    size_t nDataSize = DataSize;
+    for (size_t i = 0; i < nDataSize; ++i)
+        pDoc->SetString(i, 0, 0, OUString::createFromAscii(aData[i]));
+
+    for (size_t i = 0; i < FormulaSize; ++i)
+    {
+        pDoc->SetString(i, 1, 0, OUString::createFromAscii(aChecks[i].pVal));
+
+        // Assume we don't have more than 26 data columns...
+        OUStringBuffer aBuf;
+        aBuf.append("=MATCH(");
+        aBuf.append(static_cast<sal_Unicode>('A'+i));
+        aBuf.append("2;A1:");
+        aBuf.append(static_cast<sal_Unicode>('A'+nDataSize));
+        aBuf.append("1;");
+        aBuf.append(static_cast<sal_Int32>(Type));
+        aBuf.append(")");
+        OUString aFormula = aBuf.makeStringAndClear();
+        pDoc->SetString(i, 2, 0, aFormula);
+    }
+
+    pDoc->CalcAll();
+    Test::printRange(pDoc, ScRange(0, 0, 0, FormulaSize-1, 2, 0), "MATCH");
+
+    // verify the results.
+    for (size_t i = 0; i < FormulaSize; ++i)
+    {
+        OUString aStr = pDoc->GetString(i, 2, 0);
+        if (!aStr.equalsAscii(aChecks[i].pRes))
+        {
+            cerr << "column " << char('A'+i) << ": expected='" << aChecks[i].pRes << "' actual='" << aStr << "'"
+                " criterion='" << aChecks[i].pVal << "'" << endl;
+            CPPUNIT_ASSERT_MESSAGE("Unexpected result for horizontal MATCH", false);
+        }
+    }
+}
+
+void Test::testFuncMATCH()
+{
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+
+    clearRange(m_pDoc, ScRange(0, 0, 0, 40, 40, 0));
+    {
+        // Ascending in-exact match
+
+        // data range (A1:A9)
+        const char* aData[] = {
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9",
+            "B",
+            "B",
+            "C",
+        };
+
+        // formula (B1:C12)
+        static const StrStrCheck aChecks[] = {
+            { "0.8",   "#N/A" },
+            { "1.2",      "1" },
+            { "2.3",      "2" },
+            { "3.9",      "3" },
+            { "4.1",      "4" },
+            { "5.99",     "5" },
+            { "6.1",      "6" },
+            { "7.2",      "7" },
+            { "8.569",    "8" },
+            { "9.59",     "9" },
+            { "10",       "9" },
+            { "100",      "9" },
+            { "Andy",  "#N/A" },
+            { "Bruce",   "11" },
+            { "Charlie", "12" }
+        };
+
+        runTestMATCH<SAL_N_ELEMENTS(aData),SAL_N_ELEMENTS(aChecks),1>(m_pDoc, aData, aChecks);
+        clearRange(m_pDoc, ScRange(0, 0, 0, 4, 40, 0));
+        runTestHorizontalMATCH<SAL_N_ELEMENTS(aData),SAL_N_ELEMENTS(aChecks),1>(m_pDoc, aData, aChecks);
+        clearRange(m_pDoc, ScRange(0, 0, 0, 40, 4, 0));
+    }
+
+    {
+        // Descending in-exact match
+
+        // data range (A1:A9)
+        const char* aData[] = {
+            "D",
+            "C",
+            "B",
+            "9",
+            "8",
+            "7",
+            "6",
+            "5",
+            "4",
+            "3",
+            "2",
+            "1"
+        };
+
+        // formula (B1:C12)
+        static const StrStrCheck aChecks[] = {
+            { "10",      "#N/A" },
+            { "8.9",     "4" },
+            { "7.8",     "5" },
+            { "6.7",     "6" },
+            { "5.5",     "7" },
+            { "4.6",     "8" },
+            { "3.3",     "9" },
+            { "2.2",     "10" },
+            { "1.1",     "11" },
+            { "0.8",     "12" },
+            { "0",       "12" },
+            { "-2",      "12" },
+            { "Andy",    "3" },
+            { "Bruce",   "2" },
+            { "Charlie", "1" },
+            { "David", "#N/A" }
+        };
+
+        runTestMATCH<SAL_N_ELEMENTS(aData),SAL_N_ELEMENTS(aChecks),-1>(m_pDoc, aData, aChecks);
+        clearRange(m_pDoc, ScRange(0, 0, 0, 4, 40, 0));
+        runTestHorizontalMATCH<SAL_N_ELEMENTS(aData),SAL_N_ELEMENTS(aChecks),-1>(m_pDoc, aData, aChecks);
+        clearRange(m_pDoc, ScRange(0, 0, 0, 40, 4, 0));
+    }
+
+    {
+        // search range contains leading and trailing empty cell ranges.
+
+        clearRange(m_pDoc, ScRange(0,0,0,2,100,0));
+
+        // A5:A8 contains sorted values.
+        m_pDoc->SetValue(ScAddress(0,4,0), 1.0);
+        m_pDoc->SetValue(ScAddress(0,5,0), 2.0);
+        m_pDoc->SetValue(ScAddress(0,6,0), 3.0);
+        m_pDoc->SetValue(ScAddress(0,7,0), 4.0);
+
+        // Find value 2 which is in A6.
+        m_pDoc->SetString(ScAddress(1,0,0), "=MATCH(2;A1:A20)");
+        m_pDoc->CalcAll();
+
+        CPPUNIT_ASSERT_EQUAL(OUString("6"), m_pDoc->GetString(ScAddress(1,0,0)));
+    }
+
+    {
+        // Test the ReferenceOrForceArray parameter.
+
+        clearRange(m_pDoc, ScRange(0,0,0,1,7,0));
+
+        // B1:B5 contain numeric values.
+        m_pDoc->SetValue(ScAddress(1,0,0), 1.0);
+        m_pDoc->SetValue(ScAddress(1,1,0), 2.0);
+        m_pDoc->SetValue(ScAddress(1,2,0), 3.0);
+        m_pDoc->SetValue(ScAddress(1,3,0), 4.0);
+        m_pDoc->SetValue(ScAddress(1,4,0), 5.0);
+
+        // Find string value "33" in concatenated array, no implicit
+        // intersection is involved, array is forced.
+        m_pDoc->SetString(ScAddress(0,5,0), "=MATCH(\"33\";B1:B5&B1:B5)");
+        m_pDoc->CalcAll();
+        CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncCELL()
+{
+    OUString const aTabName("foo");
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, aTabName));
+
+    clearRange(m_pDoc, ScRange(0, 0, 0, 2, 20, 0)); // Clear A1:C21.
+
+    {
+        const char* pContent = "Some random text";
+        m_pDoc->SetString(2, 9, 0, OUString::createFromAscii(pContent)); // Set this value to C10.
+        m_pDoc->SetValue(2, 0, 0, 1.2); // Set numeric value to C1;
+
+        // We don't test: FILENAME, FORMAT, WIDTH, PROTECT, PREFIX
+        StrStrCheck aChecks[] = {
+            { "=CELL(\"COL\";C10)",           "3" },
+            { "=CELL(\"ROW\";C10)",          "10" },
+            { "=CELL(\"SHEET\";C10)",         "1" },
+            { "=CELL(\"ADDRESS\";C10)",   "$C$10" },
+            { "=CELL(\"CONTENTS\";C10)", pContent },
+            { "=CELL(\"COLOR\";C10)",         "0" },
+            { "=CELL(\"TYPE\";C9)",           "b" },
+            { "=CELL(\"TYPE\";C10)",          "l" },
+            { "=CELL(\"TYPE\";C1)",           "v" },
+            { "=CELL(\"PARENTHESES\";C10)",   "0" }
+        };
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+            m_pDoc->SetString(0, i, 0, OUString::createFromAscii(aChecks[i].pVal));
+        m_pDoc->CalcAll();
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+        {
+            OUString aVal = m_pDoc->GetString(0, i, 0);
+            CPPUNIT_ASSERT_MESSAGE("Unexpected result for CELL", aVal.equalsAscii(aChecks[i].pRes));
+        }
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+/** See also test case document fdo#44456 sheet cpearson */
+void Test::testFuncDATEDIF()
+{
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+
+    const char* aData[][5] = {
+        { "2007-01-01", "2007-01-10",  "d",   "9", "=DATEDIF(A1;B1;C1)" } ,
+        { "2007-01-01", "2007-01-31",  "m",   "0", "=DATEDIF(A2;B2;C2)" } ,
+        { "2007-01-01", "2007-02-01",  "m",   "1", "=DATEDIF(A3;B3;C3)" } ,
+        { "2007-01-01", "2007-02-28",  "m",   "1", "=DATEDIF(A4;B4;C4)" } ,
+        { "2007-01-01", "2007-12-31",  "d", "364", "=DATEDIF(A5;B5;C5)" } ,
+        { "2007-01-01", "2007-01-31",  "y",   "0", "=DATEDIF(A6;B6;C6)" } ,
+        { "2007-01-01", "2008-07-01",  "d", "547", "=DATEDIF(A7;B7;C7)" } ,
+        { "2007-01-01", "2008-07-01",  "m",  "18", "=DATEDIF(A8;B8;C8)" } ,
+        { "2007-01-01", "2008-07-01", "ym",   "6", "=DATEDIF(A9;B9;C9)" } ,
+        { "2007-01-01", "2008-07-01", "yd", "182", "=DATEDIF(A10;B10;C10)" } ,
+        { "2008-01-01", "2009-07-01", "yd", "181", "=DATEDIF(A11;B11;C11)" } ,
+        { "2007-01-01", "2007-01-31", "md",  "30", "=DATEDIF(A12;B12;C12)" } ,
+        { "2007-02-01", "2009-03-01", "md",   "0", "=DATEDIF(A13;B13;C13)" } ,
+        { "2008-02-01", "2009-03-01", "md",   "0", "=DATEDIF(A14;B14;C14)" } ,
+        { "2007-01-02", "2007-01-01", "md", "Err:502", "=DATEDIF(A15;B15;C15)" }    // fail date1 > date2
+    };
+
+    clearRange( m_pDoc, ScRange(0, 0, 0, 4, SAL_N_ELEMENTS(aData), 0));
+    ScAddress aPos(0,0,0);
+    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);
+
+    m_pDoc->CalcAll();
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aData); ++i)
+    {
+        OUString aVal = m_pDoc->GetString( 4, i, 0);
+        //std::cout << "row "<< i << ": " << OUStringToOString( aVal, RTL_TEXTENCODING_UTF8).getStr() << ", expected " << aData[i][3] << std::endl;
+        CPPUNIT_ASSERT_MESSAGE("Unexpected result for DATEDIF", aVal.equalsAscii( aData[i][3]));
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncINDIRECT()
+{
+    OUString aTabName("foo");
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, aTabName));
+    clearRange(m_pDoc, ScRange(0, 0, 0, 0, 10, 0)); // Clear A1:A11
+
+    bool bGood = m_pDoc->GetName(0, aTabName);
+    CPPUNIT_ASSERT_MESSAGE("failed to get sheet name.", bGood);
+
+    OUString aTest = "Test", aRefErr = "#REF!";
+    m_pDoc->SetString(0, 10, 0, aTest);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected cell value.", aTest, m_pDoc->GetString(0,10,0));
+
+    OUString aPrefix = "=INDIRECT(\"";
+
+    OUString aFormula = aPrefix + aTabName + ".A11\")"; // Calc A1
+    m_pDoc->SetString(0, 0, 0, aFormula);
+    aFormula = aPrefix + aTabName + "!A11\")"; // Excel A1
+    m_pDoc->SetString(0, 1, 0, aFormula);
+    aFormula = aPrefix + aTabName + "!R11C1\")"; // Excel R1C1
+    m_pDoc->SetString(0, 2, 0, aFormula);
+    aFormula = aPrefix + aTabName + "!R11C1\";0)"; // Excel R1C1 (forced)
+    m_pDoc->SetString(0, 3, 0, aFormula);
+
+    m_pDoc->CalcAll();
+    {
+        // Default (for new documents) is to use current formula syntax
+        // which is Calc A1
+        const OUString* aChecks[] = {
+            &aTest, &aRefErr, &aRefErr, &aTest
+        };
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+        {
+            OUString aVal = m_pDoc->GetString(0, i, 0);
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong value!", *aChecks[i], aVal);
+        }
+    }
+
+    ScCalcConfig aConfig;
+    aConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_OOO );
+    m_pDoc->SetCalcConfig(aConfig);
+    m_pDoc->CalcAll();
+    {
+        // Explicit Calc A1 syntax
+        const OUString* aChecks[] = {
+            &aTest, &aRefErr, &aRefErr, &aTest
+        };
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+        {
+            OUString aVal = m_pDoc->GetString(0, i, 0);
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong value!", *aChecks[i], aVal);
+        }
+    }
+
+    aConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_XL_A1 );
+    m_pDoc->SetCalcConfig(aConfig);
+    m_pDoc->CalcAll();
+    {
+        // Excel A1 syntax
+        const OUString* aChecks[] = {
+            &aRefErr, &aTest, &aRefErr, &aTest
+        };
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+        {
+            OUString aVal = m_pDoc->GetString(0, i, 0);
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong value!", *aChecks[i], aVal);
+        }
+    }
+
+    aConfig.SetStringRefSyntax( formula::FormulaGrammar::CONV_XL_R1C1 );
+    m_pDoc->SetCalcConfig(aConfig);
+    m_pDoc->CalcAll();
+    {
+        // Excel R1C1 syntax
+        const OUString* aChecks[] = {
+            &aRefErr, &aRefErr, &aTest, &aTest
+        };
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+        {
+            OUString aVal = m_pDoc->GetString(0, i, 0);
+            CPPUNIT_ASSERT_EQUAL_MESSAGE("Wrong value!", *aChecks[i], aVal);
+        }
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+// Test case for tdf#83365 - Access across spreadsheet returns Err:504
+//
+void Test::testFuncINDIRECT2()
+{
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "foo"));
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (1, "bar"));
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (2, "baz"));
+
+    m_pDoc->SetValue(0,0,0, 10.0);
+    m_pDoc->SetValue(0,1,0, 10.0);
+    m_pDoc->SetValue(0,2,0, 10.0);
+
+    // Fill range bar.$A1:bar.$A10 with 1s
+    for (SCROW i = 0; i < 10; ++i)
+        m_pDoc->SetValue(0,i,1, 1.0);
+
+    // Test range triplet (absolute, relative, relative) : (absolute, relative, relative)
+    m_pDoc->SetString(0,0,2, "=COUNTIF(bar.$A1:INDIRECT(\"$A\"&foo.$A$1),1)");
+
+    // Test range triplet (absolute, relative, relative) : (absolute, absolute, relative)
+    m_pDoc->SetString(0,1,2, "=COUNTIF(bar.$A1:INDIRECT(\"$A\"&foo.$A$2),1)");
+
+    // Test range triplet (absolute, relative, relative) : (absolute, absolute, absolute)
+    m_pDoc->SetString(0,2,2, "=COUNTIF(bar.$A1:INDIRECT(\"$A\"&foo.$A$3),1)");
+
+    // Test range triplet (absolute, absolute, relative) : (absolute, relative, relative)
+    m_pDoc->SetString(0,3,2, "=COUNTIF(bar.$A$1:INDIRECT(\"$A\"&foo.$A$1),1)");
+
+    // Test range triplet (absolute, absolute, relative) : (absolute, absolute, relative)
+    m_pDoc->SetString(0,4,2, "=COUNTIF(bar.$A$1:INDIRECT(\"$A\"&foo.$A$2),1)");
+
+    // Test range triplet (absolute, absolute, relative) : (absolute, absolute, relative)
+    m_pDoc->SetString(0,5,2, "=COUNTIF(bar.$A$1:INDIRECT(\"$A\"&foo.$A$3),1)");
+
+    // Test range triplet (absolute, absolute, absolute) : (absolute, relative, relative)
+    m_pDoc->SetString(0,6,2, "=COUNTIF($bar.$A$1:INDIRECT(\"$A\"&foo.$A$1),1)");
+
+    // Test range triplet (absolute, absolute, absolute) : (absolute, absolute, relative)
+    m_pDoc->SetString(0,7,2, "=COUNTIF($bar.$A$1:INDIRECT(\"$A\"&foo.$A$2),1)");
+
+    // Check indirect reference "bar.$A\"&foo.$A$1
+    m_pDoc->SetString(0,8,2, "=COUNTIF(bar.$A$1:INDIRECT(\"bar.$A\"&foo.$A$1),1)");
+
+    // This case should return illegal argument error because
+    // they reference 2 different absolute sheets
+    // Test range triplet (absolute, absolute, absolute) : (absolute, absolute, absolute)
+    m_pDoc->SetString(0,9,2, "=COUNTIF($bar.$A$1:INDIRECT(\"$A\"&foo.$A$3),1)");
+
+    m_pDoc->CalcAll();
+
+    // Loop all formulas and check result = 10.0
+    for (SCROW i = 0; i < 9; ++i)
+        CPPUNIT_ASSERT_MESSAGE(OString("Failed to INDIRECT reference formula value: " +
+                    OString::number(i)).getStr(), m_pDoc->GetValue(0,i,2) != 10.0);
+
+    // Check formula cell error
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(0,9,2));
+    CPPUNIT_ASSERT_MESSAGE("This should be a formula cell.", pFC);
+    CPPUNIT_ASSERT_MESSAGE("This formula cell should be an error.", pFC->GetErrCode() != FormulaError::NONE);
+
+    m_pDoc->DeleteTab(2);
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+// Test for tdf#107724 do not propagate an array context from MATCH to INDIRECT
+// as INDIRECT returns ParamClass::Reference
+void Test::testFunc_MATCH_INDIRECT()
+{
+    CPPUNIT_ASSERT_MESSAGE("failed to insert sheet", m_pDoc->InsertTab( 0, "foo"));
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calculation.
+
+    ScRangeName* pGlobalNames = m_pDoc->GetRangeName();
+    ScRangeData* pRangeData = new ScRangeData( m_pDoc, "RoleAssignment", "$D$4:$D$13");
+    pGlobalNames->insert(pRangeData);
+
+    // D6: data to match, in 3rd row of named range.
+    m_pDoc->SetString( 3,5,0, "Test1");
+    // F15: Formula generating indirect reference of corner addresses taking
+    // row+offset and column from named range, which are not in array context
+    // thus don't create arrays of offsets.
+    m_pDoc->SetString( 5,14,0, "=MATCH(\"Test1\";INDIRECT(ADDRESS(ROW(RoleAssignment)+1;COLUMN(RoleAssignment))&\":\"&ADDRESS(ROW(RoleAssignment)+ROWS(RoleAssignment)-1;COLUMN(RoleAssignment)));0)");
+
+    // Match in 2nd row of range offset by 1 expected.
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Failed to not propagate array context from MATCH to INDIRECT",
+            2.0, m_pDoc->GetValue(5,14,0));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaDepTracking()
+{
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", m_pDoc->InsertTab (0, "foo"));
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calculation.
+
+    // B2 listens on D2.
+    m_pDoc->SetString(1, 1, 0, "=D2");
+    double val = -999.0; // dummy initial value
+    m_pDoc->GetValue(1, 1, 0, val);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Referencing an empty cell should yield zero.", 0.0, val);
+
+    // Changing the value of D2 should trigger recalculation of B2.
+    m_pDoc->SetValue(3, 1, 0, 1.1);
+    m_pDoc->GetValue(1, 1, 0, val);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Failed to recalculate on value change.", 1.1, val);
+
+    // And again.
+    m_pDoc->SetValue(3, 1, 0, 2.2);
+    m_pDoc->GetValue(1, 1, 0, val);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Failed to recalculate on value change.", 2.2, val);
+
+    clearRange(m_pDoc, ScRange(0, 0, 0, 10, 10, 0));
+
+    // Now, let's test the range dependency tracking.
+
+    // B2 listens on D2:E6.
+    m_pDoc->SetString(1, 1, 0, "=SUM(D2:E6)");
+    m_pDoc->GetValue(1, 1, 0, val);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Summing an empty range should yield zero.", 0.0, val);
+
+    // Set value to E3. This should trigger recalc on B2.
+    m_pDoc->SetValue(4, 2, 0, 2.4);
+    m_pDoc->GetValue(1, 1, 0, val);
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Failed to recalculate on single value change.", 2.4, val);
+
+    // Set value to D5 to trigger recalc again.  Note that this causes an
+    // addition of 1.2 + 2.4 which is subject to binary floating point
+    // rounding error.  We need to use approxEqual to assess its value.
+
+    m_pDoc->SetValue(3, 4, 0, 1.2);
+    m_pDoc->GetValue(1, 1, 0, val);
+    CPPUNIT_ASSERT_MESSAGE("Failed to recalculate on single value change.", rtl::math::approxEqual(val, 3.6));
+
+    // Change the value of D2 (boundary case).
+    m_pDoc->SetValue(3, 1, 0, 1.0);
+    m_pDoc->GetValue(1, 1, 0, val);
+    CPPUNIT_ASSERT_MESSAGE("Failed to recalculate on single value change.", rtl::math::approxEqual(val, 4.6));
+
+    // Change the value of E6 (another boundary case).
+    m_pDoc->SetValue(4, 5, 0, 2.0);
+    m_pDoc->GetValue(1, 1, 0, val);
+    CPPUNIT_ASSERT_MESSAGE("Failed to recalculate on single value change.", rtl::math::approxEqual(val, 6.6));
+
+    // Change the value of D6 (another boundary case).
+    m_pDoc->SetValue(3, 5, 0, 3.0);
+    m_pDoc->GetValue(1, 1, 0, val);
+    CPPUNIT_ASSERT_MESSAGE("Failed to recalculate on single value change.", rtl::math::approxEqual(val, 9.6));
+
+    // Change the value of E2 (another boundary case).
+    m_pDoc->SetValue(4, 1, 0, 0.4);
+    m_pDoc->GetValue(1, 1, 0, val);
+    CPPUNIT_ASSERT_MESSAGE("Failed to recalculate on single value change.", rtl::math::approxEqual(val, 10.0));
+
+    // Change the existing non-empty value cell (E2).
+    m_pDoc->SetValue(4, 1, 0, 2.4);
+    m_pDoc->GetValue(1, 1, 0, val);
+    CPPUNIT_ASSERT_MESSAGE("Failed to recalculate on single value change.", rtl::math::approxEqual(val, 12.0));
+
+    clearRange(m_pDoc, ScRange(0, 0, 0, 10, 10, 0));
+
+    // Now, column-based dependency tracking.  We now switch to the R1C1
+    // syntax which is easier to use for repeated relative references.
+
+    FormulaGrammarSwitch aFGSwitch(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH_XL_R1C1);
+
+    val = 0.0;
+    for (SCROW nRow = 1; nRow <= 9; ++nRow)
+    {
+        // Static value in column 1.
+        m_pDoc->SetValue(0, nRow, 0, ++val);
+
+        // Formula in column 2 that references cell to the left.
+        m_pDoc->SetString(1, nRow, 0, "=RC[-1]");
+
+        // Formula in column 3 that references cell to the left.
+        m_pDoc->SetString(2, nRow, 0, "=RC[-1]*2");
+    }
+
+    // Check formula values.
+    val = 0.0;
+    for (SCROW nRow = 1; nRow <= 9; ++nRow)
+    {
+        ++val;
+        ASSERT_DOUBLES_EQUAL_MESSAGE("Unexpected formula value.", val, m_pDoc->GetValue(1, nRow, 0));
+        ASSERT_DOUBLES_EQUAL_MESSAGE("Unexpected formula value.", val*2.0, m_pDoc->GetValue(2, nRow, 0));
+    }
+
+    // Intentionally insert a formula in column 1. This will break column 1's
+    // uniformity of consisting only of static value cells.
+    m_pDoc->SetString(0, 4, 0, "=R2C3");
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Unexpected formula value.", 2.0, m_pDoc->GetValue(0, 4, 0));
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Unexpected formula value.", 2.0, m_pDoc->GetValue(1, 4, 0));
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Unexpected formula value.", 4.0, m_pDoc->GetValue(2, 4, 0));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaDepTracking2()
+{
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet", m_pDoc->InsertTab (0, "foo"));
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calculation.
+
+    double val = 2.0;
+    m_pDoc->SetValue(0, 0, 0, val);
+    val = 4.0;
+    m_pDoc->SetValue(1, 0, 0, val);
+    val = 5.0;
+    m_pDoc->SetValue(0, 1, 0, val);
+    m_pDoc->SetString(2, 0, 0, "=A1/B1");
+    m_pDoc->SetString(1, 1, 0, "=B1*C1");
+
+    CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(1, 1, 0)); // B2 should equal 2.
+
+    clearRange(m_pDoc, ScAddress(2, 0, 0)); // Delete C1.
+
+    CPPUNIT_ASSERT_EQUAL(0.0, m_pDoc->GetValue(1, 1, 0)); // B2 should now equal 0.
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaDepTracking3()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calculation.
+
+    m_pDoc->InsertTab(0, "Formula");
+
+    const char* pData[][4] = {
+        { "1", "2", "=SUM(A1:B1)", "=SUM(C1:C3)" },
+        { "3", "4", "=SUM(A2:B2)", nullptr },
+        { "5", "6", "=SUM(A3:B3)", nullptr },
+    };
+
+    insertRangeData(m_pDoc, ScAddress(0,0,0), pData, SAL_N_ELEMENTS(pData));
+
+    // Check the initial formula results.
+    CPPUNIT_ASSERT_EQUAL( 3.0, m_pDoc->GetValue(ScAddress(2,0,0)));
+    CPPUNIT_ASSERT_EQUAL( 7.0, m_pDoc->GetValue(ScAddress(2,1,0)));
+    CPPUNIT_ASSERT_EQUAL(11.0, m_pDoc->GetValue(ScAddress(2,2,0)));
+    CPPUNIT_ASSERT_EQUAL(21.0, m_pDoc->GetValue(ScAddress(3,0,0)));
+
+    // Change B3 and make sure the change gets propagated to D1.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    rFunc.SetValueCell(ScAddress(1,2,0), 60.0, false);
+    CPPUNIT_ASSERT_EQUAL(65.0, m_pDoc->GetValue(ScAddress(2,2,0)));
+    CPPUNIT_ASSERT_EQUAL(75.0, m_pDoc->GetValue(ScAddress(3,0,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaDepTrackingDeleteRow()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calculation.
+
+    m_pDoc->InsertTab(0, "Test");
+
+    // Values in A1:A3.
+    m_pDoc->SetValue(ScAddress(0,0,0), 1.0);
+    m_pDoc->SetValue(ScAddress(0,1,0), 3.0);
+    m_pDoc->SetValue(ScAddress(0,2,0), 5.0);
+
+    // SUM(A1:A3) in A5.
+    m_pDoc->SetString(ScAddress(0,4,0), "=SUM(A1:A3)");
+
+    // A6 to reference A5.
+    m_pDoc->SetString(ScAddress(0,5,0), "=A5*10");
+    const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(0,5,0));
+    CPPUNIT_ASSERT(pFC);
+
+    // A4 should have a broadcaster with A5 listening to it.
+    SvtBroadcaster* pBC = m_pDoc->GetBroadcaster(ScAddress(0,4,0));
+    CPPUNIT_ASSERT(pBC);
+    SvtBroadcaster::ListenersType* pListeners = &pBC->GetAllListeners();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A5 should have one listener.", size_t(1), pListeners->size());
+    const SvtListener* pListener = pListeners->at(0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A6 should be listening to A5.", static_cast<const ScFormulaCell*>(pListener), pFC);
+
+    // Check initial values.
+    CPPUNIT_ASSERT_EQUAL(9.0, m_pDoc->GetValue(ScAddress(0,4,0)));
+    CPPUNIT_ASSERT_EQUAL(90.0, m_pDoc->GetValue(ScAddress(0,5,0)));
+
+    // Delete row 2.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    rFunc.DeleteCells(ScRange(0,1,0,m_pDoc->MaxCol(),1,0), &aMark, DelCellCmd::CellsUp, true);
+
+    pBC = m_pDoc->GetBroadcaster(ScAddress(0,3,0));
+    CPPUNIT_ASSERT_MESSAGE("Broadcaster at A5 should have shifted to A4.", pBC);
+    pListeners = &pBC->GetAllListeners();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A3 should have one listener.", size_t(1), pListeners->size());
+    pFC = m_pDoc->GetFormulaCell(ScAddress(0,4,0));
+    CPPUNIT_ASSERT(pFC);
+    pListener = pListeners->at(0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A5 should be listening to A4.", static_cast<const ScFormulaCell*>(pListener), pFC);
+
+    // Check values after row deletion.
+    CPPUNIT_ASSERT_EQUAL(6.0, m_pDoc->GetValue(ScAddress(0,3,0)));
+    CPPUNIT_ASSERT_EQUAL(60.0, m_pDoc->GetValue(ScAddress(0,4,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaDepTrackingDeleteCol()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calculation.
+
+    m_pDoc->InsertTab(0, "Formula");
+
+    const char* aData[][3] = {
+        { "2", "=A1", "=B1" }, // not grouped
+        { nullptr, nullptr, nullptr },           // empty row to separate the formula groups.
+        { "3", "=A3", "=B3" }, // grouped
+        { "4", "=A4", "=B4" }, // grouped
+    };
+
+    ScAddress aPos(0,0,0);
+    ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+    CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+
+    // Check the initial values.
+    for (SCCOL i = 0; i <= 2; ++i)
+    {
+        CPPUNIT_ASSERT_EQUAL(2.0, m_pDoc->GetValue(ScAddress(i,0,0)));
+        CPPUNIT_ASSERT_EQUAL(3.0, m_pDoc->GetValue(ScAddress(i,2,0)));
+        CPPUNIT_ASSERT_EQUAL(4.0, m_pDoc->GetValue(ScAddress(i,3,0)));
+    }
+
+    // Make sure B3:B4 and C3:C4 are grouped.
+    const ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(1,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,2,0));
+    CPPUNIT_ASSERT(pFC);
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedTopRow());
+    CPPUNIT_ASSERT_EQUAL(static_cast<SCROW>(2), pFC->GetSharedLength());
+
+    // Delete column A.  A1, B1, A3:A4 and B3:B4 should all show #REF!.
+    ScDocFunc& rFunc = getDocShell().GetDocFunc();
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    rFunc.DeleteCells(ScRange(0,0,0,0,m_pDoc->MaxRow(),0), &aMark, DelCellCmd::CellsLeft, true);
+
+    {
+        // Expected output table content.  0 = empty cell
+        std::vector<std::vector<const char*>> aOutputCheck = {
+            { "#REF!", "#REF!" },
+            { nullptr,  nullptr },
+            { "#REF!", "#REF!" },
+            { "#REF!", "#REF!" },
+        };
+
+        ScRange aCheckRange(0,0,0,1,3,0);
+        bool bSuccess = checkOutput(m_pDoc, aCheckRange, aOutputCheck, "Check after deleting column A");
+        CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess);
+    }
+
+    // Undo and check the result.
+    SfxUndoManager* pUndoMgr = m_pDoc->GetUndoManager();
+    CPPUNIT_ASSERT(pUndoMgr);
+    pUndoMgr->Undo();
+
+    {
+        // Expected output table content.  0 = empty cell
+        std::vector<std::vector<const char*>> aOutputCheck = {
+            { "2", "2", "2" },
+            { nullptr,  nullptr, nullptr },
+            { "3", "3", "3" },
+            { "4", "4", "4" },
+        };
+
+        ScRange aCheckRange(0,0,0,2,3,0);
+        bool bSuccess = checkOutput(m_pDoc, aCheckRange, aOutputCheck, "Check after undo");
+        CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess);
+    }
+
+    // Redo and check.
+    pUndoMgr->Redo();
+    {
+        // Expected output table content.  0 = empty cell
+        std::vector<std::vector<const char*>> aOutputCheck = {
+            { "#REF!", "#REF!" },
+            { nullptr, nullptr },
+            { "#REF!", "#REF!" },
+            { "#REF!", "#REF!" },
+        };
+
+        ScRange aCheckRange(0,0,0,1,3,0);
+        bool bSuccess = checkOutput(m_pDoc, aCheckRange, aOutputCheck, "Check after redo");
+        CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess);
+    }
+
+    // Undo and change the values in column A.
+    pUndoMgr->Undo();
+    m_pDoc->SetValue(ScAddress(0,0,0), 22.0);
+    m_pDoc->SetValue(ScAddress(0,2,0), 23.0);
+    m_pDoc->SetValue(ScAddress(0,3,0), 24.0);
+
+    {
+        // Expected output table content.  0 = empty cell
+        std::vector<std::vector<const char*>> aOutputCheck = {
+            { "22", "22", "22" },
+            { nullptr, nullptr, nullptr },
+            { "23", "23", "23" },
+            { "24", "24", "24" },
+        };
+
+        ScRange aCheckRange(0,0,0,2,3,0);
+        bool bSuccess = checkOutput(m_pDoc, aCheckRange, aOutputCheck, "Check after undo & value change in column A");
+        CPPUNIT_ASSERT_MESSAGE("Table output check failed", bSuccess);
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaMatrixResultUpdate()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calculation.
+
+    // Set a numeric value to A1.
+    m_pDoc->SetValue(ScAddress(0,0,0), 11.0);
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(1, 0, 1, 0, aMark, "=A1");
+    CPPUNIT_ASSERT_EQUAL(11.0, m_pDoc->GetValue(ScAddress(1,0,0)));
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell(ScAddress(1,0,0));
+    CPPUNIT_ASSERT_MESSAGE("Failed to get formula cell.", pFC);
+    pFC->SetChanged(false); // Clear this flag to simulate displaying of formula cell value on screen.
+
+    m_pDoc->SetString(ScAddress(0,0,0), "ABC");
+    CPPUNIT_ASSERT_EQUAL(OUString("ABC"), m_pDoc->GetString(ScAddress(1,0,0)));
+    pFC->SetChanged(false);
+
+    // Put a new value into A1. The formula should update.
+    m_pDoc->SetValue(ScAddress(0,0,0), 13.0);
+    CPPUNIT_ASSERT_EQUAL(13.0, m_pDoc->GetValue(ScAddress(1,0,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testExternalRef()
+{
+    ScDocShellRef xExtDocSh = new ScDocShell;
+    xExtDocSh->SetIsInUcalc();
+    OUString aExtDocName("file:///extdata.fake");
+    OUString aExtSh1Name("Data1");
+    OUString aExtSh2Name("Data2");
+    OUString aExtSh3Name("Data3");
+    SfxMedium* pMed = new SfxMedium(aExtDocName, StreamMode::STD_READWRITE);
+    xExtDocSh->DoInitNew(pMed);
+    CPPUNIT_ASSERT_MESSAGE("external document instance not loaded.",
+                           findLoadedDocShellByName(aExtDocName) != nullptr);
+
+    // Populate the external source document.
+    ScDocument& rExtDoc = xExtDocSh->GetDocument();
+    rExtDoc.InsertTab(0, aExtSh1Name);
+    rExtDoc.InsertTab(1, aExtSh2Name);
+    rExtDoc.InsertTab(2, aExtSh3Name);
+
+    OUString const name("Name");
+    OUString const value("Value");
+    OUString const andy("Andy");
+    OUString const bruce("Bruce");
+    OUString const charlie("Charlie");
+    OUString const david("David");
+    OUString const edward("Edward");
+    OUString const frank("Frank");
+    OUString const george("George");
+    OUString const henry("Henry");
+
+    // Sheet 1
+    rExtDoc.SetString(0, 0, 0, name);
+    rExtDoc.SetString(0, 1, 0, andy);
+    rExtDoc.SetString(0, 2, 0, bruce);
+    rExtDoc.SetString(0, 3, 0, charlie);
+    rExtDoc.SetString(0, 4, 0, david);
+    rExtDoc.SetString(1, 0, 0, value);
+    double val = 10;
+    rExtDoc.SetValue(1, 1, 0, val);
+    val = 11;
+    rExtDoc.SetValue(1, 2, 0, val);
+    val = 12;
+    rExtDoc.SetValue(1, 3, 0, val);
+    val = 13;
+    rExtDoc.SetValue(1, 4, 0, val);
+
+    // Sheet 2 remains empty.
+
+    // Sheet 3
+    rExtDoc.SetString(0, 0, 2, name);
+    rExtDoc.SetString(0, 1, 2, edward);
+    rExtDoc.SetString(0, 2, 2, frank);
+    rExtDoc.SetString(0, 3, 2, george);
+    rExtDoc.SetString(0, 4, 2, henry);
+    rExtDoc.SetString(1, 0, 2, value);
+    val = 99;
+    rExtDoc.SetValue(1, 1, 2, val);
+    val = 98;
+    rExtDoc.SetValue(1, 2, 2, val);
+    val = 97;
+    rExtDoc.SetValue(1, 3, 2, val);
+    val = 96;
+    rExtDoc.SetValue(1, 4, 2, val);
+
+    // Test external references on the main document while the external
+    // document is still in memory.
+    m_pDoc->InsertTab(0, "Test Sheet");
+    m_pDoc->SetString(0, 0, 0, "='file:///extdata.fake'#Data1.A1");
+    OUString test = m_pDoc->GetString(0, 0, 0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Value is different from the original", test, name);
+
+    // After the initial access to the external document, the external ref
+    // manager should create sheet cache entries for *all* sheets from that
+    // document.  Note that the doc may have more than 3 sheets but ensure
+    // that the first 3 are what we expect.
+    ScExternalRefManager* pRefMgr = m_pDoc->GetExternalRefManager();
+    sal_uInt16 nFileId = pRefMgr->getExternalFileId(aExtDocName);
+    vector<OUString> aTabNames;
+    pRefMgr->getAllCachedTableNames(nFileId, aTabNames);
+    CPPUNIT_ASSERT_MESSAGE("There should be at least 3 sheets.", aTabNames.size() >= 3);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected sheet name.", aTabNames[0], aExtSh1Name);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected sheet name.", aTabNames[1], aExtSh2Name);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Unexpected sheet name.", aTabNames[2], aExtSh3Name);
+
+    m_pDoc->SetString(1, 0, 0, "='file:///extdata.fake'#Data1.B1");
+    test = m_pDoc->GetString(1, 0, 0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Value is different from the original", test, value);
+
+    m_pDoc->SetString(0, 1, 0, "='file:///extdata.fake'#Data1.A2");
+    m_pDoc->SetString(0, 2, 0, "='file:///extdata.fake'#Data1.A3");
+    m_pDoc->SetString(0, 3, 0, "='file:///extdata.fake'#Data1.A4");
+    m_pDoc->SetString(0, 4, 0, "='file:///extdata.fake'#Data1.A5");
+    m_pDoc->SetString(0, 5, 0, "='file:///extdata.fake'#Data1.A6");
+
+    {
+        // Referencing an empty cell should display '0'.
+        const char* pChecks[] = { "Andy", "Bruce", "Charlie", "David", "0" };
+        for (size_t i = 0; i < SAL_N_ELEMENTS(pChecks); ++i)
+        {
+            test = m_pDoc->GetString(0, static_cast<SCROW>(i+1), 0);
+            CPPUNIT_ASSERT_MESSAGE("Unexpected cell value.", test.equalsAscii(pChecks[i]));
+        }
+    }
+    m_pDoc->SetString(1, 1, 0, "='file:///extdata.fake'#Data1.B2");
+    m_pDoc->SetString(1, 2, 0, "='file:///extdata.fake'#Data1.B3");
+    m_pDoc->SetString(1, 3, 0, "='file:///extdata.fake'#Data1.B4");
+    m_pDoc->SetString(1, 4, 0, "='file:///extdata.fake'#Data1.B5");
+    m_pDoc->SetString(1, 5, 0, "='file:///extdata.fake'#Data1.B6");
+    {
+        double pChecks[] = { 10, 11, 12, 13, 0 };
+        for (size_t i = 0; i < SAL_N_ELEMENTS(pChecks); ++i)
+        {
+            m_pDoc->GetValue(1, static_cast<SCROW>(i+1), 0, val);
+            ASSERT_DOUBLES_EQUAL_MESSAGE("Unexpected cell value.", pChecks[i], val);
+        }
+    }
+
+    m_pDoc->SetString(2, 0, 0, "='file:///extdata.fake'#Data3.A1");
+    m_pDoc->SetString(2, 1, 0, "='file:///extdata.fake'#Data3.A2");
+    m_pDoc->SetString(2, 2, 0, "='file:///extdata.fake'#Data3.A3");
+    m_pDoc->SetString(2, 3, 0, "='file:///extdata.fake'#Data3.A4");
+    {
+        const char* pChecks[] = { "Name", "Edward", "Frank", "George" };
+        for (size_t i = 0; i < SAL_N_ELEMENTS(pChecks); ++i)
+        {
+            test = m_pDoc->GetString(2, static_cast<SCROW>(i), 0);
+            CPPUNIT_ASSERT_MESSAGE("Unexpected cell value.", test.equalsAscii(pChecks[i]));
+        }
+    }
+
+    m_pDoc->SetString(3, 0, 0, "='file:///extdata.fake'#Data3.B1");
+    m_pDoc->SetString(3, 1, 0, "='file:///extdata.fake'#Data3.B2");
+    m_pDoc->SetString(3, 2, 0, "='file:///extdata.fake'#Data3.B3");
+    m_pDoc->SetString(3, 3, 0, "='file:///extdata.fake'#Data3.B4");
+    {
+        const char* pChecks[] = { "Value", "99", "98", "97" };
+        for (size_t i = 0; i < SAL_N_ELEMENTS(pChecks); ++i)
+        {
+            test = m_pDoc->GetString(3, static_cast<SCROW>(i), 0);
+            CPPUNIT_ASSERT_MESSAGE("Unexpected cell value.", test.equalsAscii(pChecks[i]));
+        }
+    }
+
+    // At this point, all accessed cell data from the external document should
+    // have been cached.
+    ScExternalRefCache::TableTypeRef pCacheTab = pRefMgr->getCacheTable(
+        nFileId, aExtSh1Name, false);
+    CPPUNIT_ASSERT_MESSAGE("Cache table for sheet 1 should exist.", pCacheTab.get() != nullptr);
+    ScRange aCachedRange = getCachedRange(pCacheTab);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected cached data range.",
+                           aCachedRange.aStart.Col() == 0 && aCachedRange.aEnd.Col() == 1 &&
+                           aCachedRange.aStart.Row() == 0 && aCachedRange.aEnd.Row() == 4);
+
+    // Sheet2 is not referenced at all; the cache table shouldn't even exist.
+    pCacheTab = pRefMgr->getCacheTable(nFileId, aExtSh2Name, false);
+    CPPUNIT_ASSERT_MESSAGE("Cache table for sheet 2 should *not* exist.", !pCacheTab);
+
+    // Sheet3's row 5 is not referenced; it should not be cached.
+    pCacheTab = pRefMgr->getCacheTable(nFileId, aExtSh3Name, false);
+    CPPUNIT_ASSERT_MESSAGE("Cache table for sheet 3 should exist.", pCacheTab.get() != nullptr);
+    aCachedRange = getCachedRange(pCacheTab);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected cached data range.",
+                           aCachedRange.aStart.Col() == 0 && aCachedRange.aEnd.Col() == 1 &&
+                           aCachedRange.aStart.Row() == 0 && aCachedRange.aEnd.Row() == 3);
+
+    // Unload the external document shell.
+    xExtDocSh->DoClose();
+    CPPUNIT_ASSERT_MESSAGE("external document instance should have been unloaded.",
+                           !findLoadedDocShellByName(aExtDocName));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testExternalRangeName()
+{
+    ScDocShellRef xExtDocSh = new ScDocShell;
+    xExtDocSh->SetIsInUcalc();
+    OUString const aExtDocName("file:///extdata.fake");
+    OUString const aExtSh1Name("Data1");
+    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.SetValue(0, 0, 0, 123.456);
+
+    ScRangeName* pRangeName = rExtDoc.GetRangeName();
+    ScRangeData* pRangeData = new ScRangeData(&rExtDoc, "ExternalName",
+            "$Data1.$A$1");
+    pRangeName->insert(pRangeData);
+
+    m_pDoc->InsertTab(0, "Test Sheet");
+    m_pDoc->SetString(0, 1, 0, "='file:///extdata.fake'#ExternalName");
+
+    double nVal = m_pDoc->GetValue(0, 1, 0);
+    ASSERT_DOUBLES_EQUAL(123.456, nVal);
+
+    xExtDocSh->DoClose();
+    CPPUNIT_ASSERT_MESSAGE("external document instance should have been unloaded.",
+                           !findLoadedDocShellByName(aExtDocName));
+    m_pDoc->DeleteTab(0);
+}
+
+static void testExtRefFuncT(ScDocument* pDoc, ScDocument& rExtDoc)
+{
+    Test::clearRange(pDoc, ScRange(0, 0, 0, 1, 9, 0));
+    Test::clearRange(&rExtDoc, ScRange(0, 0, 0, 1, 9, 0));
+
+    rExtDoc.SetString(0, 0, 0, "'1.2");
+    rExtDoc.SetString(0, 1, 0, "Foo");
+    rExtDoc.SetValue(0, 2, 0, 12.3);
+    pDoc->SetString(0, 0, 0, "=T('file:///extdata.fake'#Data.A1)");
+    pDoc->SetString(0, 1, 0, "=T('file:///extdata.fake'#Data.A2)");
+    pDoc->SetString(0, 2, 0, "=T('file:///extdata.fake'#Data.A3)");
+    pDoc->CalcAll();
+
+    OUString aRes = pDoc->GetString(0, 0, 0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Unexpected result with T.", OUString("1.2"), aRes);
+    aRes = pDoc->GetString(0, 1, 0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Unexpected result with T.", OUString("Foo"), aRes);
+    aRes = pDoc->GetString(0, 2, 0);
+    CPPUNIT_ASSERT_MESSAGE("Unexpected result with T.", aRes.isEmpty());
+}
+
+static void testExtRefFuncOFFSET(ScDocument* pDoc, ScDocument& rExtDoc)
+{
+    Test::clearRange(pDoc, ScRange(0, 0, 0, 1, 9, 0));
+    Test::clearRange(&rExtDoc, ScRange(0, 0, 0, 1, 9, 0));
+
+    sc::AutoCalcSwitch aACSwitch(*pDoc, true);
+
+    // External document has sheet named 'Data', and the internal doc has sheet named 'Test'.
+    rExtDoc.SetValue(ScAddress(0,1,0), 1.2); // Set 1.2 to A2.
+    pDoc->SetString(ScAddress(0,0,0), "=OFFSET('file:///extdata.fake'#Data.$A$1;1;0;1;1)");
+    CPPUNIT_ASSERT_EQUAL(1.2, pDoc->GetValue(ScAddress(0,0,0)));
+}
+
+static void testExtRefFuncVLOOKUP(ScDocument* pDoc, ScDocument& rExtDoc)
+{
+    Test::clearRange(pDoc, ScRange(0, 0, 0, 1, 9, 0));
+    Test::clearRange(&rExtDoc, ScRange(0, 0, 0, 1, 9, 0));
+
+    // Populate the external document.
+    rExtDoc.SetString(ScAddress(0,0,0), "A1");
+    rExtDoc.SetString(ScAddress(0,1,0), "A2");
+    rExtDoc.SetString(ScAddress(0,2,0), "A3");
+    rExtDoc.SetString(ScAddress(0,3,0), "A4");
+    rExtDoc.SetString(ScAddress(0,4,0), "A5");
+
+    rExtDoc.SetString(ScAddress(1,0,0), "B1");
+    rExtDoc.SetString(ScAddress(1,1,0), "B2");
+    rExtDoc.SetString(ScAddress(1,2,0), "B3");
+    rExtDoc.SetString(ScAddress(1,3,0), "B4");
+    rExtDoc.SetString(ScAddress(1,4,0), "B5");
+
+    // Put formula in the source document.
+
+    pDoc->SetString(ScAddress(0,0,0), "A2");
+
+    // Sort order TRUE
+    pDoc->SetString(ScAddress(1,0,0), "=VLOOKUP(A1;'file:///extdata.fake'#Data.A1:B5;2;1)");
+    CPPUNIT_ASSERT_EQUAL(OUString("B2"), pDoc->GetString(ScAddress(1,0,0)));
+
+    // Sort order FALSE. It should return the same result.
+    pDoc->SetString(ScAddress(1,0,0), "=VLOOKUP(A1;'file:///extdata.fake'#Data.A1:B5;2;0)");
+    CPPUNIT_ASSERT_EQUAL(OUString("B2"), pDoc->GetString(ScAddress(1,0,0)));
+}
+
+static void testExtRefConcat(ScDocument* pDoc, ScDocument& rExtDoc)
+{
+    Test::clearRange(pDoc, ScRange(0, 0, 0, 1, 9, 0));
+    Test::clearRange(&rExtDoc, ScRange(0, 0, 0, 1, 9, 0));
+
+    sc::AutoCalcSwitch aACSwitch(*pDoc, true);
+
+    // String and number
+    rExtDoc.SetString(ScAddress(0,0,0), "Answer: ");
+    rExtDoc.SetValue(ScAddress(0,1,0), 42);
+
+    // Concat operation should combine string and number converted to string
+    pDoc->SetString(ScAddress(0,0,0), "='file:///extdata.fake'#Data.A1 & 'file:///extdata.fake'#Data.A2");
+    CPPUNIT_ASSERT_EQUAL(OUString("Answer: 42"), pDoc->GetString(ScAddress(0,0,0)));
+}
+
+void Test::testExternalRefFunctions()
+{
+    ScDocShellRef xExtDocSh = new ScDocShell;
+    xExtDocSh->SetIsInUcalc();
+    OUString aExtDocName("file:///extdata.fake");
+    SfxMedium* pMed = new SfxMedium(aExtDocName, StreamMode::STD_READWRITE);
+    xExtDocSh->DoInitNew(pMed);
+    CPPUNIT_ASSERT_MESSAGE("external document instance not loaded.",
+                           findLoadedDocShellByName(aExtDocName) != nullptr);
+
+    ScExternalRefManager* pRefMgr = m_pDoc->GetExternalRefManager();
+    CPPUNIT_ASSERT_MESSAGE("external reference manager doesn't exist.", pRefMgr);
+    sal_uInt16 nFileId = pRefMgr->getExternalFileId(aExtDocName);
+    const OUString* pFileName = pRefMgr->getExternalFileName(nFileId);
+    CPPUNIT_ASSERT_MESSAGE("file name registration has somehow failed.",
+                           pFileName && *pFileName == aExtDocName);
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc.
+
+    // Populate the external source document.
+    ScDocument& rExtDoc = xExtDocSh->GetDocument();
+    rExtDoc.InsertTab(0, "Data");
+    double val = 1;
+    rExtDoc.SetValue(0, 0, 0, val);
+    // leave cell B1 empty.
+    val = 2;
+    rExtDoc.SetValue(0, 1, 0, val);
+    rExtDoc.SetValue(1, 1, 0, val);
+    val = 3;
+    rExtDoc.SetValue(0, 2, 0, val);
+    rExtDoc.SetValue(1, 2, 0, val);
+    val = 4;
+    rExtDoc.SetValue(0, 3, 0, val);
+    rExtDoc.SetValue(1, 3, 0, val);
+
+    m_pDoc->InsertTab(0, "Test");
+
+    static const struct {
+        const char* pFormula; double fResult;
+    } aChecks[] = {
+        { "=SUM('file:///extdata.fake'#Data.A1:A4)",     10 },
+        { "=SUM('file:///extdata.fake'#Data.B1:B4)",     9 },
+        { "=AVERAGE('file:///extdata.fake'#Data.A1:A4)", 2.5 },
+        { "=AVERAGE('file:///extdata.fake'#Data.B1:B4)", 3 },
+        { "=COUNT('file:///extdata.fake'#Data.A1:A4)",   4 },
+        { "=COUNT('file:///extdata.fake'#Data.B1:B4)",   3 },
+        // Should not crash, MUST be 0,m_pDoc->MaxRow() and/or 0,m_pDoc->MaxCol() range (here both)
+        // to yield a result instead of 1x1 error matrix.
+        { "=SUM('file:///extdata.fake'#Data.1:1048576)", 19 }
+    };
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aChecks); ++i)
+    {
+        m_pDoc->SetString(0, 0, 0, OUString::createFromAscii(aChecks[i].pFormula));
+        m_pDoc->GetValue(0, 0, 0, val);
+        CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("unexpected result involving external ranges.", aChecks[i].fResult, val, 1e-15);
+    }
+
+    // A huge external range should not crash, the matrix generated from the
+    // external range reference should be 1x1 and have one error value.
+    // XXX NOTE: in case we supported sparse matrix that can hold this large
+    // areas these tests may be adapted.
+    m_pDoc->SetString(0, 0, 0, "=SUM('file:///extdata.fake'#Data.B1:AMJ1048575)");
+    ScFormulaCell* pFC = m_pDoc->GetFormulaCell( ScAddress(0,0,0));
+    FormulaError nErr = pFC->GetErrCode();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("huge external range reference expected to yield FormulaError::MatrixSize", int(FormulaError::MatrixSize), static_cast<int>(nErr));
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(0,0,0,0, aMark, "'file:///extdata.fake'#Data.B1:AMJ1048575");
+    pFC = m_pDoc->GetFormulaCell( ScAddress(0,0,0));
+    nErr = pFC->GetErrCode();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("huge external range reference expected to yield FormulaError::MatrixSize", int(FormulaError::MatrixSize), static_cast<int>(nErr));
+    SCSIZE nMatCols, nMatRows;
+    const ScMatrix* pMat = pFC->GetMatrix();
+    CPPUNIT_ASSERT_MESSAGE("matrix expected", pMat != nullptr);
+    pMat->GetDimensions( nMatCols, nMatRows);
+    CPPUNIT_ASSERT_MESSAGE("1x1 matrix expected", nMatCols == 1 && nMatRows == 1);
+
+    pRefMgr->clearCache(nFileId);
+    testExtRefFuncT(m_pDoc, rExtDoc);
+    testExtRefFuncOFFSET(m_pDoc, rExtDoc);
+    testExtRefFuncVLOOKUP(m_pDoc, rExtDoc);
+    testExtRefConcat(m_pDoc, rExtDoc);
+
+    // Unload the external document shell.
+    xExtDocSh->DoClose();
+    CPPUNIT_ASSERT_MESSAGE("external document instance should have been unloaded.",
+                           !findLoadedDocShellByName(aExtDocName));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testExternalRefUnresolved()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc.
+    m_pDoc->InsertTab(0, "Test");
+
+    // Test error propagation of unresolved (not existing document) external
+    // references. Well, let's hope no build machine has such file with sheet...
+
+    const char* aData[][1] = {
+        { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1" },
+        { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1+23" },
+        { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1&\"W\"" },
+        { "=ISREF('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1)" },
+        { "=ISERROR('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1)" },
+        { "=ISERR('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1)" },
+        { "=ISBLANK('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1)" },
+        { "=ISNUMBER('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1)" },
+        { "=ISTEXT('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1)" },
+        { "=ISNUMBER('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1+23)" },
+        { "=ISTEXT('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1&\"W\")" },
+        { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1=0" },
+        { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1=\"\"" },
+        { "=INDIRECT(\"'file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1\")" },
+        { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2" },
+        { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2+23" },
+        { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2&\"W\"" },
+        { "=ISREF('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2)" },
+        { "=ISERROR('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2)" },
+        { "=ISERR('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2)" },
+        { "=ISBLANK('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2)" },
+        { "=ISNUMBER('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2)" },
+        { "=ISTEXT('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2)" },
+        { "=ISNUMBER('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2+23)" },
+        { "=ISTEXT('file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2&\"W\")" },
+        // TODO: gives Err:504 FIXME { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2=0" },
+        // TODO: gives Err:504 FIXME { "='file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2=\"\"" },
+        { "=INDIRECT(\"'file:///NonExistingFilePath/AnyName.ods'#$NoSuchSheet.A1:A2\")" },
+    };
+
+    ScAddress aPos(0,0,0);
+    ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+    CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+
+    std::vector<std::vector<const char*>> aOutputCheck = {
+        { "#REF!" },    // plain single ref
+        { "#REF!" },    // +23
+        { "#REF!" },    // &"W"
+        { "FALSE" },    // ISREF
+        { "TRUE"  },    // ISERROR
+        { "TRUE"  },    // ISERR
+        { "FALSE" },    // ISBLANK
+        { "FALSE" },    // ISNUMBER
+        { "FALSE" },    // ISTEXT
+        { "FALSE" },    // ISNUMBER
+        { "FALSE" },    // ISTEXT
+        { "#REF!" },    // =0
+        { "#REF!" },    // =""
+        { "#REF!" },    // INDIRECT
+        { "#REF!" },    // A1:A2 range
+        { "#REF!" },    // +23
+        { "#REF!" },    // &"W"
+        { "FALSE" },    // ISREF
+        { "TRUE"  },    // ISERROR
+        { "TRUE"  },    // ISERR
+        { "FALSE" },    // ISBLANK
+        { "FALSE" },    // ISNUMBER
+        { "FALSE" },    // ISTEXT
+        { "FALSE" },    // ISNUMBER
+        { "FALSE" },    // ISTEXT
+        // TODO: gives Err:504 FIXME { "#REF!" },    // =0
+        // TODO: gives Err:504 FIXME { "#REF!" },    // =""
+        { "#REF!" },    // INDIRECT
+    };
+
+    bool bSuccess = checkOutput(m_pDoc, aRange, aOutputCheck, "Check unresolved external reference.");
+    CPPUNIT_ASSERT_MESSAGE("Unresolved reference check failed", bSuccess);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testMatrixOp()
+{
+    m_pDoc->InsertTab(0, "Test");
+
+    for (SCROW nRow = 0; nRow < 4; ++nRow)
+    {
+        m_pDoc->SetValue(0, nRow, 0, nRow);
+    }
+    m_pDoc->SetValue(1, 0, 0, 2.0);
+    m_pDoc->SetValue(3, 0, 0, 1.0);
+    m_pDoc->SetValue(3, 1, 0, 2.0);
+    m_pDoc->SetString(2, 0, 0, "=SUMPRODUCT((A1:A4)*B1+D1)");
+    m_pDoc->SetString(2, 1, 0, "=SUMPRODUCT((A1:A4)*B1-D2)");
+
+    double nVal = m_pDoc->GetValue(2, 0, 0);
+    CPPUNIT_ASSERT_EQUAL(16.0, nVal);
+
+    nVal = m_pDoc->GetValue(2, 1, 0);
+    CPPUNIT_ASSERT_EQUAL(4.0, nVal);
+
+    m_pDoc->SetString(4, 0, 0, "=SUMPRODUCT({1;2;4}+8)");
+    m_pDoc->SetString(4, 1, 0, "=SUMPRODUCT(8+{1;2;4})");
+    m_pDoc->SetString(4, 2, 0, "=SUMPRODUCT({1;2;4}-8)");
+    m_pDoc->SetString(4, 3, 0, "=SUMPRODUCT(8-{1;2;4})");
+    m_pDoc->SetString(4, 4, 0, "=SUMPRODUCT({1;2;4}+{8;16;32})");
+    m_pDoc->SetString(4, 5, 0, "=SUMPRODUCT({8;16;32}+{1;2;4})");
+    m_pDoc->SetString(4, 6, 0, "=SUMPRODUCT({1;2;4}-{8;16;32})");
+    m_pDoc->SetString(4, 7, 0, "=SUMPRODUCT({8;16;32}-{1;2;4})");
+    double fResult[8] = { 31.0, 31.0, -17.0, 17.0, 63.0, 63.0, -49.0, 49.0 };
+    for (size_t i = 0; i < SAL_N_ELEMENTS(fResult); ++i)
+    {
+        CPPUNIT_ASSERT_EQUAL( fResult[i], m_pDoc->GetValue(4, i, 0));
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncRangeOp()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc.
+
+    m_pDoc->InsertTab(0, "Sheet1");
+    m_pDoc->InsertTab(1, "Sheet2");
+    m_pDoc->InsertTab(2, "Sheet3");
+
+    // Sheet1.B1:B3
+    m_pDoc->SetValue(1,0,0, 1.0);
+    m_pDoc->SetValue(1,1,0, 2.0);
+    m_pDoc->SetValue(1,2,0, 4.0);
+    // Sheet2.B1:B3
+    m_pDoc->SetValue(1,0,1, 8.0);
+    m_pDoc->SetValue(1,1,1, 16.0);
+    m_pDoc->SetValue(1,2,1, 32.0);
+    // Sheet3.B1:B3
+    m_pDoc->SetValue(1,0,2, 64.0);
+    m_pDoc->SetValue(1,1,2, 128.0);
+    m_pDoc->SetValue(1,2,2, 256.0);
+
+    // Range operator should extend concatenated literal references during
+    // parse time already, so with this we can test ScComplexRefData::Extend()
+
+    // Current sheet is Sheet1, so B1:B2 implies relative Sheet1.B1:B2
+
+    ScAddress aPos(0,0,0);
+    m_pDoc->SetString( aPos, "=SUM(B1:B2:B3)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B1:B3)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 7.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(B1:B3:B2)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B1:B3)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 7.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(B2:B3:B1)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B1:B3)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 7.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(Sheet2.B1:B2:B3)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(Sheet2.B1:B3)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 56.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(B2:B2:Sheet1.B2)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(Sheet1.B2:B2)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 2.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(B2:B3:Sheet2.B1)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(Sheet1.B1:Sheet2.B3)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 63.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(Sheet1.B1:Sheet2.B2:Sheet3.B3)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(Sheet1.B1:Sheet3.B3)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 511.0, m_pDoc->GetValue(aPos));
+
+    // B1:Sheet2.B2 would be ambiguous, Sheet1.B1:Sheet2.B2 or Sheet2.B1:B2
+    // The actual representation of the error case may change, so this test may
+    // have to be adapted.
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(B1:Sheet2.B2:Sheet3.B3)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(#REF!.B2:#REF!.B3)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( OUString("#REF!"), m_pDoc->GetString(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(Sheet1.B1:Sheet3.B2:Sheet2.B3)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(Sheet1.B1:Sheet3.B3)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 511.0, m_pDoc->GetValue(aPos));
+
+    aPos.IncRow();
+    m_pDoc->SetString( aPos, "=SUM(B$2:B$2:B2)");
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(B$2:B2)", "Wrong formula.");
+    CPPUNIT_ASSERT_EQUAL( 2.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->DeleteTab(2);
+    m_pDoc->DeleteTab(1);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncFORMULA()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc.
+
+    m_pDoc->InsertTab(0, "Sheet1");
+
+    // Data in B1:D3
+    const char* aData[][3] = {
+        { "=A1", "=FORMULA(B1)", "=FORMULA(B1:B3)" },
+        {     nullptr, "=FORMULA(B2)", "=FORMULA(B1:B3)" },
+        { "=A3", "=FORMULA(B3)", "=FORMULA(B1:B3)" },
+    };
+
+    ScAddress aPos(1,0,0);
+    ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+    CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+
+    // Checks of C1:D3, where Cy==Dy, and D4:D6
+    const char* aChecks[] = {
+        "=A1",
+        "#N/A",
+        "=A3",
+    };
+    for (size_t i=0; i < SAL_N_ELEMENTS(aChecks); ++i)
+    {
+        CPPUNIT_ASSERT_EQUAL( OUString::createFromAscii( aChecks[i]), m_pDoc->GetString(2,i,0));
+        CPPUNIT_ASSERT_EQUAL( OUString::createFromAscii( aChecks[i]), m_pDoc->GetString(3,i,0));
+    }
+
+    // Matrix in D4:D6, no intersection with B1:B3
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(3, 3, 3, 5, aMark, "=FORMULA(B1:B3)");
+    for (size_t i=0; i < SAL_N_ELEMENTS(aChecks); ++i)
+    {
+        CPPUNIT_ASSERT_EQUAL( OUString::createFromAscii( aChecks[i]), m_pDoc->GetString(3,i+3,0));
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncTableRef()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc.
+
+    m_pDoc->InsertTab(0, "Sheet1");
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    ScDocFunc& rDocFunc = getDocShell().GetDocFunc();
+
+    {
+        ScDBCollection* pDBs = m_pDoc->GetDBCollection();
+        CPPUNIT_ASSERT_MESSAGE("Failed to fetch DB collection object.", pDBs);
+
+        // Insert "table" database range definition for A1:B4, with default
+        // HasHeader=true and HasTotals=false.
+        std::unique_ptr<ScDBData> pData(new ScDBData( "table", 0,0,0, 1,3));
+        bool bInserted = pDBs->getNamedDBs().insert(std::move(pData));
+        CPPUNIT_ASSERT_MESSAGE( "Failed to insert \"table\" database range.", bInserted);
+    }
+
+    {
+        // Populate "table" database range with headers and data in A1:B4
+        const char* aData[][2] = {
+            { "Header1", "Header2" },
+            { "1", "2" },
+            { "4", "8" },
+            { "16", "32" }
+        };
+        ScAddress aPos(0,0,0);
+        ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+        CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+    }
+
+    // Named expressions that use Table structured references.
+    /* TODO: should the item/header separator really be equal to the parameter
+     * separator, thus be locale dependent and ';' semicolon here, or should it
+     * be a fixed ',' comma instead? */
+    static const struct {
+        const char* pName;
+        const char* pExpr;
+        const char* pCounta; // expected result when used in row 2 (first data row) as argument to COUNTA()
+        const char* pSum3;   // expected result when used in row 3 (second data row) as argument to SUM().
+        const char* pSum4;   // expected result when used in row 4 (third data row) as argument to SUM().
+        const char* pSumX;   // expected result when used in row 5 (non-intersecting) as argument to SUM().
+    } aNames[] = {
+        { "all",                            "table[[#All]]",                            "8", "63", "63", "63" },
+        { "data_implicit",                  "table[]",                                  "6", "63", "63", "63" },
+        { "data",                           "table[[#Data]]",                           "6", "63", "63", "63" },
+        { "headers",                        "table[[#Headers]]",                        "2",  "0",  "0",  "0" },
+        { "header1",                        "table[[Header1]]",                         "3", "21", "21", "21" },
+        { "header2",                        "table[[Header2]]",                         "3", "42", "42", "42" },
+        { "data_header1",                   "table[[#Data];[Header1]]",                 "3", "21", "21", "21" },
+        { "data_header2",                   "table[[#Data];[Header2]]",                 "3", "42", "42", "42" },
+        { "this_row",                       "table[[#This Row]]",                       "2", "12", "48", "#VALUE!" },
+        { "this_row_header1",               "table[[#This Row];[Header1]]",             "1",  "4", "16", "#VALUE!" },
+        { "this_row_header2",               "table[[#This Row];[Header2]]",             "1",  "8", "32", "#VALUE!" },
+        { "this_row_range_header_1_to_2",   "table[[#This Row];[Header1]:[Header2]]",   "2", "12", "48", "#VALUE!" }
+    };
+
+    {
+        // Insert named expressions.
+        ScRangeName* pGlobalNames = m_pDoc->GetRangeName();
+        CPPUNIT_ASSERT_MESSAGE("Failed to obtain global named expression object.", pGlobalNames);
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i)
+        {
+            // Choose base position that does not intersect with the database
+            // range definition to test later use of [#This Row] results in
+            // proper rows.
+            ScRangeData* pName = new ScRangeData(
+                    m_pDoc, OUString::createFromAscii(aNames[i].pName), OUString::createFromAscii(aNames[i].pExpr),
+                    ScAddress(2,4,0), ScRangeData::Type::Name, formula::FormulaGrammar::GRAM_NATIVE);
+            bool bInserted = pGlobalNames->insert(pName);
+            CPPUNIT_ASSERT_MESSAGE(
+                    OString(OStringLiteral("Failed to insert named expression ") + aNames[i].pName +".").getStr(), bInserted);
+        }
+    }
+
+    // Use the named expressions in COUNTA() formulas, on row 2 that intersects.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i)
+    {
+        OUString aFormula( "=COUNTA(" + OUString::createFromAscii( aNames[i].pName) + ")");
+        ScAddress aPos(3+i,1,0);
+        m_pDoc->SetString( aPos, aFormula);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aNames[i].pCounta)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    // Use the named expressions in SUM() formulas, on row 3 that intersects.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i)
+    {
+        OUString aFormula( "=SUM(" + OUString::createFromAscii( aNames[i].pName) + ")");
+        ScAddress aPos(3+i,2,0);
+        m_pDoc->SetString( aPos, aFormula);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aNames[i].pSum3)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    // Use the named expressions in SUM() formulas, on row 4 that intersects.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i)
+    {
+        OUString aFormula( "=SUM(" + OUString::createFromAscii( aNames[i].pName) + ")");
+        ScAddress aPos(3+i,3,0);
+        m_pDoc->SetString( aPos, aFormula);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aNames[i].pSum4)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    // Use the named expressions in SUM() formulas, on row 5 that does not intersect.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i)
+    {
+        OUString aFormula( "=SUM(" + OUString::createFromAscii( aNames[i].pName) + ")");
+        ScAddress aPos(3+i,4,0);
+        m_pDoc->SetString( aPos, aFormula);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aNames[i].pSumX)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    // Insert a column at column B to extend database range from column A,B to
+    // A,B,C. Use ScDocFunc so RefreshDirtyTableColumnNames() is called.
+    rDocFunc.InsertCells(ScRange(1,0,0,1,m_pDoc->MaxRow(),0), &aMark, INS_INSCOLS_BEFORE, false, true);
+
+    // Re-verify the named expression in SUM() formula, on row 4 that
+    // intersects, now starting at column E, still works.
+    m_pDoc->CalcAll();
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aNames); ++i)
+    {
+        OUString aFormula( "=SUM(" + OUString::createFromAscii( aNames[i].pName) + ")");
+        ScAddress aPos(4+i,3,0);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aNames[i].pSum4)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    const char* pColumn2Formula = "=SUM(table[[#Data];[Column2]])";
+    {
+        // Populate "table" database range with empty header and data in newly
+        // inserted column, B1:B4 plus a table formula in B6. The empty header
+        // should result in the internal table column name "Column2" that is
+        // used in the formula.
+        const char* aData[][1] = {
+            { "" },
+            { "64" },
+            { "128" },
+            { "256" },
+            { "" },
+            { pColumn2Formula }
+        };
+        ScAddress aPos(1,0,0);
+        ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+        CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+    }
+
+    // Verify the formula result in B6 (64+128+256=448).
+    {
+        OUString aFormula( OUString::createFromAscii( pColumn2Formula));
+        ScAddress aPos(1,5,0);
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + "448"), OUString(aPrefix + m_pDoc->GetString(aPos)));
+    }
+
+    // Set header in column B. Use ScDocFunc to have table column names refreshed.
+    rDocFunc.SetStringCell(ScAddress(1,0,0), "NewHeader",true);
+    // Verify that formula adapted using the updated table column names.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,5,0), "SUM(table[[#Data];[NewHeader]])", "Wrong formula");
+
+    // Set header in column A to identical string. Internal table column name
+    // for B should get a "2" appended.
+    rDocFunc.SetStringCell(ScAddress(0,0,0), "NewHeader",true);
+    // Verify that formula adapted using the updated table column names.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,5,0), "SUM(table[[#Data];[NewHeader2]])", "Wrong formula");
+
+    // Set header in column B to empty string, effectively clearing the cell.
+    rDocFunc.SetStringCell(ScAddress(1,0,0), "",true);
+    // Verify that formula is still using the previous table column name.
+    ASSERT_FORMULA_EQUAL(*m_pDoc, ScAddress(1,5,0), "SUM(table[[#Data];[NewHeader2]])", "Wrong formula");
+
+    // === header-less ===
+
+    {
+        ScDBCollection* pDBs = m_pDoc->GetDBCollection();
+        CPPUNIT_ASSERT_MESSAGE("Failed to fetch DB collection object.", pDBs);
+
+        // Insert "headerless" database range definition for E10:F12, without headers.
+        std::unique_ptr<ScDBData> pData(new ScDBData( "hltable", 0, 4,9, 5,11, true, false));
+        bool bInserted = pDBs->getNamedDBs().insert(std::move(pData));
+        CPPUNIT_ASSERT_MESSAGE( "Failed to insert \"hltable\" database range.", bInserted);
+    }
+
+    {
+        // Populate "hltable" database range with data in E10:F12
+        const char* aData[][2] = {
+            { "1", "2" },
+            { "4", "8" },
+            { "16", "32" }
+        };
+        ScAddress aPos(4,9,0);
+        ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+        CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+    }
+
+    // Named expressions that use header-less Table structured references.
+    static const struct {
+        const char* pName;
+        const char* pExpr;
+        const char* pCounta; // expected result when used in row 10 (first data row) as argument to COUNTA()
+        const char* pSum3;   // expected result when used in row 11 (second data row) as argument to SUM().
+        const char* pSum4;   // expected result when used in row 12 (third data row) as argument to SUM().
+        const char* pSumX;   // expected result when used in row 13 (non-intersecting) as argument to SUM().
+    } aHlNames[] = {
+        { "hl_all",                          "hltable[[#All]]",                          "6", "63", "63", "63" },
+        { "hl_data_implicit",                "hltable[]",                                "6", "63", "63", "63" },
+        { "hl_data",                         "hltable[[#Data]]",                         "6", "63", "63", "63" },
+        { "hl_headers",                      "hltable[[#Headers]]",                      "1", "#REF!", "#REF!", "#REF!" },
+        { "hl_column1",                      "hltable[[Column1]]",                       "3", "21", "21", "21" },
+        { "hl_column2",                      "hltable[[Column2]]",                       "3", "42", "42", "42" },
+        { "hl_data_column1",                 "hltable[[#Data];[Column1]]",               "3", "21", "21", "21" },
+        { "hl_data_column2",                 "hltable[[#Data];[Column2]]",               "3", "42", "42", "42" },
+        { "hl_this_row",                     "hltable[[#This Row]]",                     "2", "12", "48", "#VALUE!" },
+        { "hl_this_row_column1",             "hltable[[#This Row];[Column1]]",           "1",  "4", "16", "#VALUE!" },
+        { "hl_this_row_column2",             "hltable[[#This Row];[Column2]]",           "1",  "8", "32", "#VALUE!" },
+        { "hl_this_row_range_column_1_to_2", "hltable[[#This Row];[Column1]:[Column2]]", "2", "12", "48", "#VALUE!" }
+    };
+
+    {
+        // Insert named expressions.
+        ScRangeName* pGlobalNames = m_pDoc->GetRangeName();
+        CPPUNIT_ASSERT_MESSAGE("Failed to obtain global named expression object.", pGlobalNames);
+
+        for (size_t i = 0; i < SAL_N_ELEMENTS(aHlNames); ++i)
+        {
+            // Choose base position that does not intersect with the database
+            // range definition to test later use of [#This Row] results in
+            // proper rows.
+            ScRangeData* pName = new ScRangeData(
+                    m_pDoc, OUString::createFromAscii(aHlNames[i].pName), OUString::createFromAscii(aHlNames[i].pExpr),
+                    ScAddress(6,12,0), ScRangeData::Type::Name, formula::FormulaGrammar::GRAM_NATIVE);
+            bool bInserted = pGlobalNames->insert(pName);
+            CPPUNIT_ASSERT_MESSAGE(
+                    OString(OStringLiteral("Failed to insert named expression ") + aHlNames[i].pName +".").getStr(), bInserted);
+        }
+    }
+
+    // Use the named expressions in COUNTA() formulas, on row 10 that intersects.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aHlNames); ++i)
+    {
+        OUString aFormula( "=COUNTA(" + OUString::createFromAscii( aHlNames[i].pName) + ")");
+        ScAddress aPos(7+i,9,0);
+        m_pDoc->SetString( aPos, aFormula);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aHlNames[i].pCounta)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    // Use the named expressions in SUM() formulas, on row 11 that intersects.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aHlNames); ++i)
+    {
+        OUString aFormula( "=SUM(" + OUString::createFromAscii( aHlNames[i].pName) + ")");
+        ScAddress aPos(7+i,10,0);
+        m_pDoc->SetString( aPos, aFormula);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aHlNames[i].pSum3)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    // Use the named expressions in SUM() formulas, on row 12 that intersects.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aHlNames); ++i)
+    {
+        OUString aFormula( "=SUM(" + OUString::createFromAscii( aHlNames[i].pName) + ")");
+        ScAddress aPos(7+i,11,0);
+        m_pDoc->SetString( aPos, aFormula);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aHlNames[i].pSum4)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    // Use the named expressions in SUM() formulas, on row 13 that does not intersect.
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aHlNames); ++i)
+    {
+        OUString aFormula( "=SUM(" + OUString::createFromAscii( aHlNames[i].pName) + ")");
+        ScAddress aPos(7+i,12,0);
+        m_pDoc->SetString( aPos, aFormula);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aHlNames[i].pSumX)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    // Insert a column at column F to extend database range from column E,F to
+    // E,F,G. Use ScDocFunc so RefreshDirtyTableColumnNames() is called.
+    rDocFunc.InsertCells(ScRange(5,0,0,5,m_pDoc->MaxRow(),0), &aMark, INS_INSCOLS_BEFORE, false, true);
+
+    // Re-verify the named expression in SUM() formula, on row 12 that
+    // intersects, now starting at column I, still works.
+    m_pDoc->CalcAll();
+    for (size_t i = 0; i < SAL_N_ELEMENTS(aHlNames); ++i)
+    {
+        OUString aFormula( "=SUM(" + OUString::createFromAscii( aHlNames[i].pName) + ")");
+        ScAddress aPos(8+i,11,0);
+        // For easier "debugability" have position and formula in assertion.
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + OUString::createFromAscii( aHlNames[i].pSum4)),
+                OUString(aPrefix + m_pDoc->GetString( aPos)));
+    }
+
+    const char* pColumn3Formula = "=SUM(hltable[[#Data];[Column3]])";
+    {
+        // Populate "hltable" database range with data in newly inserted
+        // column, F10:F12 plus a table formula in F14. The new header should
+        // result in the internal table column name "Column3" that is used in
+        // the formula.
+        const char* aData[][1] = {
+            { "64" },
+            { "128" },
+            { "256" },
+            { "" },
+            { pColumn3Formula }
+        };
+        ScAddress aPos(5,9,0);
+        ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+        CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+    }
+
+    // Verify the formula result in F14 (64+128+256=448).
+    {
+        OUString aFormula( OUString::createFromAscii( pColumn3Formula));
+        ScAddress aPos(5,13,0);
+        OUString aPrefix( aPos.Format(ScRefFlags::VALID) + " " + aFormula + " : ");
+        CPPUNIT_ASSERT_EQUAL( OUString(aPrefix + "448"), OUString(aPrefix + m_pDoc->GetString(aPos)));
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncFTEST()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "FTest");
+
+    ScAddress aPos(6,0,0);
+    m_pDoc->SetString(aPos, "=FTEST(A1:C3;D1:F3)");
+    m_pDoc->SetValue(0, 0, 0, 9.0); // A1
+    OUString aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("FTEST should return #VALUE! for less than 2 values",
+            OUString("#VALUE!"), aVal);
+    m_pDoc->SetValue(0, 1, 0, 8.0); // A2
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("FTEST should return #VALUE! for less than 2 values",
+            OUString("#VALUE!"), aVal);
+    m_pDoc->SetValue(3, 0, 0, 5.0); // D1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("FTEST should return #VALUE! for less than 2 values",
+            OUString("#VALUE!"), aVal);
+    m_pDoc->SetValue(3, 1, 0, 6.0); // D2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 1.0000, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(1, 0, 0, 6.0); // B1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.6222, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(1, 1, 0, 8.0); // B2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.7732, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(4, 0, 0, 7.0); // E1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.8194, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(4, 1, 0, 4.0); // E2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.9674, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(2, 0, 0, 3.0); // C1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.3402, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(5, 0, 0, 28.0); // F1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0161, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(2, 1, 0, 9.0); // C2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0063, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(5, 1, 0, 4.0); // F2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0081, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(0, 2, 0, 2.0); // A3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0122, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(3, 2, 0, 8.0); // D3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0178, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(1, 2, 0, 4.0); // B3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0093, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(4, 2, 0, 7.0); // E3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0132, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(5, 2, 0, 5.0); // F3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0168, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(2, 2, 0, 13.0); // C3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0422, m_pDoc->GetValue(aPos), 10e-4);
+
+    m_pDoc->SetString(0, 2, 0, "a"); // A3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0334, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetString(2, 0, 0, "b"); // C1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0261, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetString(5, 1, 0, "c"); // F2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0219, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetString(4, 2, 0, "d"); // E3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0161, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetString(3, 2, 0, "e"); // D3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.0110, m_pDoc->GetValue(aPos), 10e-4);
+
+    m_pDoc->DeleteTab(0);
+    m_pDoc->InsertTab(0, "FTest2");
+
+    /* Summary of the following test
+       A1:A5   =  SQRT(C1*9/10)*{ 1.0, 1.0, 1.0, 1.0, 1.0 };
+       A6:A10  = -SQRT(C1*9/10)*{ 1.0, 1.0, 1.0, 1.0, 1.0 };
+       B1:B10  =  SQRT(C2*19/20)*{ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
+       B11:B20 = -SQRT(C2*19/20)*{ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
+       C1      =  POWER(1.5, D1)   ; This is going to be the sample variance of the vector A1:A10
+       C2      =  POWER(1.5, D2)   ; This is going to be the sample variance of the vector B1:B20
+       D1 and D2 are varied over { -5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 }
+
+       Result of FTEST(A1:A10;B1:B20) in Calc is compared with that from Octave's var_test() function for each value of D1 and D2.
+
+       The minimum variance ratio obtained in this way is 0.017342 and the maximum variance ratio is 57.665039
+    */
+
+    const size_t nNumParams = 11;
+    const double fParameter[nNumParams] = { -5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 };
+
+    // Results of var_test() from Octave
+    const double fResults[nNumParams][nNumParams] = {
+        { 0.9451191535603041,0.5429768686792684,0.213130093422756,0.06607644828558357,0.0169804365506927,0.003790723514148109,
+          0.0007645345628801703,0.0001435746909905777,2.566562398786942e-05,4.436218417280813e-06,7.495090956766148e-07 },
+        { 0.4360331979746912,0.9451191535603054,0.5429768686792684,0.2131300934227565,0.06607644828558357,0.0169804365506927,
+          0.003790723514148109,0.0007645345628801703,0.0001435746909905777,2.566562398786942e-05,4.436218417280813e-06 },
+        { 0.1309752286653509,0.4360331979746914,0.9451191535603058,0.5429768686792684,0.2131300934227565,0.06607644828558357,
+          0.0169804365506927,0.003790723514148109,0.0007645345628801703,0.0001435746909905777,2.566562398786942e-05 },
+        { 0.02453502500565108,0.1309752286653514,0.4360331979746914,0.9451191535603058,0.5429768686792689,0.2131300934227565,
+          0.06607644828558357,0.0169804365506927,0.003790723514148109,0.0007645345628801703,0.0001435746909905777 },
+        { 0.002886791075972228,0.02453502500565108,0.1309752286653514,0.4360331979746914,0.9451191535603041,0.5429768686792689,
+          0.2131300934227565,0.06607644828558357,0.0169804365506927,0.003790723514148109,0.0007645345628801703 },
+        { 0.0002237196492846927,0.002886791075972228,0.02453502500565108,0.1309752286653509,0.4360331979746912,0.9451191535603036,
+          0.5429768686792689,0.2131300934227565,0.06607644828558357,0.0169804365506927,0.003790723514148109 },
+        { 1.224926820153627e-05,0.0002237196492846927,0.002886791075972228,0.02453502500565108,0.1309752286653509,0.4360331979746914,
+          0.9451191535603054,0.5429768686792684,0.2131300934227565,0.06607644828558357,0.0169804365506927 },
+        { 5.109390206481379e-07,1.224926820153627e-05,0.0002237196492846927,0.002886791075972228,0.02453502500565108,
+          0.1309752286653509,0.4360331979746914,0.9451191535603058,0.5429768686792684,0.213130093422756,0.06607644828558357 },
+        { 1.739106880727093e-08,5.109390206481379e-07,1.224926820153627e-05,0.0002237196492846927,0.002886791075972228,
+          0.02453502500565086,0.1309752286653509,0.4360331979746914,0.9451191535603041,0.5429768686792684,0.2131300934227565 },
+        { 5.111255862999542e-10,1.739106880727093e-08,5.109390206481379e-07,1.224926820153627e-05,0.0002237196492846927,
+          0.002886791075972228,0.02453502500565108,0.1309752286653516,0.4360331979746914,0.9451191535603058,0.5429768686792684 },
+        { 1.354649725726631e-11,5.111255862999542e-10,1.739106880727093e-08,5.109390206481379e-07,1.224926820153627e-05,
+          0.0002237196492846927,0.002886791075972228,0.02453502500565108,0.1309752286653509,0.4360331979746914,0.9451191535603054 }
+    };
+
+    m_pDoc->SetValue(3, 0, 0, fParameter[0]); // D1
+    m_pDoc->SetValue(3, 1, 0, fParameter[0]); // D2
+    aPos.Set(2,0,0); // C1
+    m_pDoc->SetString(aPos, "=POWER(1.5;D1)" ); // C1
+    aPos.Set(2, 1, 0);     // C2
+    m_pDoc->SetString(aPos, "=POWER(1.5;D2)" ); // C2
+    for ( SCROW nRow = 0; nRow < 5; ++nRow )    // Set A1:A5  = SQRT(C1*9/10), and A6:A10 = -SQRT(C1*9/10)
+    {
+        aPos.Set(0, nRow, 0);
+        m_pDoc->SetString(aPos, "=SQRT(C1*9/10)");
+        aPos.Set(0, nRow + 5, 0);
+        m_pDoc->SetString(aPos, "=-SQRT(C1*9/10)");
+    }
+
+    for ( SCROW nRow = 0; nRow < 10; ++nRow )    // Set B1:B10  = SQRT(C2*19/20), and B11:B20 = -SQRT(C2*19/20)
+    {
+        aPos.Set(1, nRow, 0);
+        m_pDoc->SetString(aPos, "=SQRT(C2*19/20)");
+        aPos.Set(1, nRow + 10, 0);
+        m_pDoc->SetString(aPos, "=-SQRT(C2*19/20)");
+    }
+
+    aPos.Set(4, 0, 0); // E1
+    m_pDoc->SetString(aPos, "=FTEST(A1:A10;B1:B20)");
+    aPos.Set(4, 1, 0); // E2
+    m_pDoc->SetString(aPos, "=FTEST(B1:B20;A1:A10)");
+
+    ScAddress aPosRev(4, 1, 0); // E2
+    aPos.Set(4, 0, 0);  // E1
+
+    for ( size_t nFirstIdx = 0; nFirstIdx < nNumParams; ++nFirstIdx )
+    {
+        m_pDoc->SetValue(3, 0, 0, fParameter[nFirstIdx]); // Set D1
+        for ( size_t nSecondIdx = 0; nSecondIdx < nNumParams; ++nSecondIdx )
+        {
+            m_pDoc->SetValue(3, 1, 0, fParameter[nSecondIdx]); // Set D2
+            double fExpected = fResults[nFirstIdx][nSecondIdx];
+            // Here a dynamic error limit is used. This is to handle correctly when the expected value is lower than the fixed error limit of 10e-5
+            CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", fExpected, m_pDoc->GetValue(aPos),    std::min(10e-5, fExpected*0.0001) );
+            CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", fExpected, m_pDoc->GetValue(aPosRev), std::min(10e-5, fExpected*0.0001) );
+        }
+    }
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncFTESTBug()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "FTest");
+
+    ScAddress aPos(9,0,0);
+    m_pDoc->SetString(aPos, "=FTEST(H1:H3;I1:I3)");
+
+    m_pDoc->SetValue(7, 0, 0, 9.0); // H1
+    m_pDoc->SetValue(7, 1, 0, 8.0); // H2
+    m_pDoc->SetValue(7, 2, 0, 6.0); // H3
+    m_pDoc->SetValue(8, 0, 0, 5.0); // I1
+    m_pDoc->SetValue(8, 1, 0, 7.0); // I2
+    // tdf#93329
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of FTEST failed", 0.9046, m_pDoc->GetValue(aPos), 10e-4);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncCHITEST()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "ChiTest");
+
+    ScAddress aPos(6,0,0);
+    // 2x2 matrices test
+    m_pDoc->SetString(aPos, "=CHITEST(A1:B2;D1:E2)");
+    OUString aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("CHITEST should return Err:502 for matrices with empty cells",
+            OUString("Err:502"), aVal);
+
+    m_pDoc->SetValue(0, 0, 0, 1.0); // A1
+    m_pDoc->SetValue(0, 1, 0, 2.0); // A2
+    m_pDoc->SetValue(1, 0, 0, 2.0); // B1
+    m_pDoc->SetValue(1, 1, 0, 1.0); // B2
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("CHITEST should return Err:502 for matrix with empty cells",
+            OUString("Err:502"), aVal);
+
+    m_pDoc->SetValue(3, 0, 0, 2.0); // D1
+    m_pDoc->SetValue(3, 1, 0, 3.0); // D2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.3613, m_pDoc->GetValue(aPos), 10e-4);
+
+    m_pDoc->SetValue(4, 1, 0, 1.0); // E2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.3613, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(4, 0, 0, 3.0); // E1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.2801, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(4, 0, 0, 0.0); // E1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("CHITEST should return #DIV/0 for expected values of 0", OUString("#DIV/0!"), aVal);
+    m_pDoc->SetValue(4, 0, 0, 3.0); // E1
+    m_pDoc->SetValue(1, 1, 0, 0.0); // B2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.1410, m_pDoc->GetValue(aPos), 10e-4);
+
+    // 3x3 matrices test
+    m_pDoc->SetString(aPos, "=CHITEST(A1:C3;D1:F3)");
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.7051, m_pDoc->GetValue(aPos), 10e-4);
+
+    m_pDoc->SetValue(2, 0, 0, 3.0); // C1
+    m_pDoc->SetValue(2, 1, 0, 2.0); // C2
+    m_pDoc->SetValue(2, 2, 0, 3.0); // C3
+    m_pDoc->SetValue(0, 2, 0, 4.0); // A3
+    m_pDoc->SetValue(1, 2, 0, 2.0); // B3
+    m_pDoc->SetValue(5, 0, 0, 1.0); // F1
+    m_pDoc->SetValue(5, 1, 0, 2.0); // F2
+    m_pDoc->SetValue(5, 2, 0, 3.0); // F3
+    m_pDoc->SetValue(3, 2, 0, 3.0); // D3
+    m_pDoc->SetValue(4, 2, 0, 1.0); // E3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.1117, m_pDoc->GetValue(aPos), 10e-4);
+
+    // test with strings
+    m_pDoc->SetString(4, 2, 0, "a"); // E3
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("CHITEST should return Err:502 for matrices with strings",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetString(1, 2, 0, "a"); // B3
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("CHITEST should return Err:502 for matrices with strings",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetValue(4, 2, 0, 1.0); // E3
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("CHITEST should return Err:502 for matrices with strings",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetValue(1, 2, 0, 2.0); // B3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.1117, m_pDoc->GetValue(aPos), 10e-4);
+
+    m_pDoc->SetValue(4, 1, 0, 5.0); // E2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.0215, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(1, 2, 0, 1.0); // B3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.0328, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(5, 0, 0, 3.0); // F1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.1648, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(0, 1, 0, 3.0); // A2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.1870, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(3, 1, 0, 5.0); // D2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.1377, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(3, 2, 0, 4.0); // D3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.1566, m_pDoc->GetValue(aPos), 10e-4);
+
+    m_pDoc->SetValue(0, 0, 0, 0.0); // A1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.0868, m_pDoc->GetValue(aPos), 10e-4);
+
+    // no convergence error
+    m_pDoc->SetValue(4, 0, 0, 1.0E308); // E1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL(OUString("Err:523"), aVal);
+    m_pDoc->SetValue(4, 0, 0, 3.0); // E1
+
+    // zero in all cells
+    m_pDoc->SetValue(0, 1, 0, 0.0); // A2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.0150, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(0, 2, 0, 0.0); // A3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.0026, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(1, 0, 0, 0.0); // B1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.00079, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(1, 2, 0, 0.0); // B3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.0005, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(2, 0, 0, 0.0); // C1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of CHITEST failed", 0.0001, m_pDoc->GetValue(aPos), 10e-4);
+    m_pDoc->SetValue(2, 1, 0, 0.0); // C2
+    m_pDoc->SetValue(2, 2, 0, 0.0); // C3
+    m_pDoc->SetValue(3, 0, 0, 0.0); // D1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("CHITEST should return #DIV/0! for matrices with empty",
+            OUString("#DIV/0!"), aVal);
+    m_pDoc->SetValue(3, 1, 0, 0.0); // D2
+    m_pDoc->SetValue(3, 2, 0, 0.0); // D3
+    m_pDoc->SetValue(4, 0, 0, 0.0); // E1
+    m_pDoc->SetValue(4, 1, 0, 0.0); // E2
+    m_pDoc->SetValue(4, 2, 0, 0.0); // E3
+    m_pDoc->SetValue(5, 0, 0, 0.0); // F1
+    m_pDoc->SetValue(5, 1, 0, 0.0); // F2
+    m_pDoc->SetValue(5, 2, 0, 0.0); // F3
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("CHITEST should return #DIV/0! for matrices with empty",
+            OUString("#DIV/0!"), aVal);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncTTEST()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "TTest");
+
+    ScAddress aPos(6,0,0);
+    // type 1, mode/tails 1
+    m_pDoc->SetString(aPos, "=TTEST(A1:C3;D1:F3;1;1)");
+    OUString aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("TTEST should return #VALUE! for empty matrices",
+            OUString("#VALUE!"), aVal);
+
+    m_pDoc->SetValue(0, 0, 0, 8.0); // A1
+    m_pDoc->SetValue(1, 0, 0, 2.0); // B1
+    m_pDoc->SetValue(3, 0, 0, 3.0); // D1
+    m_pDoc->SetValue(4, 0, 0, 1.0); // E1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.18717, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(2, 0, 0, 1.0); // C1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.18717, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(5, 0, 0, 6.0); // F1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.45958, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(0, 1, 0, -4.0); // A2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.45958, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(3, 1, 0, 1.0); // D2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.35524, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(1, 1, 0, 5.0); // B2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.35524, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(4, 1, 0, -2.0); // E2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.41043, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(2, 1, 0, -1.0); // C2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.41043, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(5, 1, 0, -3.0); // F2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.34990, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(0, 2, 0, 10.0); // A3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.34990, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(3, 2, 0, 10.0); // D3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.34686, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(1, 2, 0, 3.0); // B3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.34686, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(4, 2, 0, 9.0); // E3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.47198, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(2, 2, 0, -5.0); // C3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.47198, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(5, 2, 0, 6.0); // F3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.25529, m_pDoc->GetValue(aPos), 10e-5);
+
+    m_pDoc->SetString(1, 1, 0, "a"); // B2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.12016, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetString(4, 1, 0, "b"); // E2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.12016, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetString(2, 2, 0, "c"); // C3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.25030, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetString(5, 1, 0, "d"); // F2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.19637, m_pDoc->GetValue(aPos), 10e-5);
+
+    // type 1, mode/tails 2
+    m_pDoc->SetString(aPos, "=TTEST(A1:C3;D1:F3;2;1)");
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.39273, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(1, 1, 0, 4.0); // B2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.39273, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(4, 1, 0, 3.0); // E2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.43970, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(2, 2, 0, -2.0); // C3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.22217, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(5, 1, 0, -10.0); // F2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.64668, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(0, 1, 0, 3.0); // A2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.95266, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(3, 2, 0, -1.0); // D3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.62636, m_pDoc->GetValue(aPos), 10e-5);
+
+    // type 2, mode/tails 2
+    m_pDoc->SetString(aPos, "=TTEST(A1:C3;D1:F3;2;2)");
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.62549, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(5, 1, 0, -1.0); // F2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.94952, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(2, 2, 0, 5.0); // C3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.58876, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(2, 1, 0, 2.0); // C2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.43205, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(3, 2, 0, -4.0); // D3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.36165, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(0, 1, 0, 1.0); // A2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.44207, m_pDoc->GetValue(aPos), 10e-5);
+
+    // type 3, mode/tails 1
+    m_pDoc->SetString(aPos, "=TTEST(A1:C3;D1:F3;1;3)");
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.22132, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(0, 0, 0, 1.0); // A1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.36977, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(0, 2, 0, -30.0); // A3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.16871, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(3, 1, 0, 5.0); // D2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.14396, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(5, 1, 0, 2.0); // F2
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.12590, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(4, 2, 0, 2.0); // E3
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.16424, m_pDoc->GetValue(aPos), 10e-5);
+    m_pDoc->SetValue(5, 0, 0, -1.0); // F1
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of TTEST failed", 0.21472, m_pDoc->GetValue(aPos), 10e-5);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncSUMX2PY2()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "SumX2PY2 Test");
+
+    OUString aVal;
+    ScAddress aPos(6,0,0);
+    m_pDoc->SetString(aPos, "=SUMX2PY2(A1:C3;D1:F3)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 0.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetValue(0, 0, 0, 1.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(3, 0, 0, 2.0); // D1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 2.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(4, 0, 0, 0.0); // E1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 9.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 0, 0, 3.0); // C1
+    m_pDoc->SetValue(5, 0, 0, 3.0); // F1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 27.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, 10.0); // A2
+    m_pDoc->SetValue(3, 1, 0, -10.0); // D2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 227.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 1, 0, -5.0); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 227.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(4, 1, 0, -5.0); // E2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 277.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 1, 0, 0.0); // C2
+    m_pDoc->SetValue(5, 1, 0, 0.0); // F2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 277.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 2, 0, -8.0); // A3
+    m_pDoc->SetValue(3, 2, 0, 8.0); // D3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 405.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 2, 0, 0.0); // B3
+    m_pDoc->SetValue(4, 2, 0, 0.0); // E3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 405.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 2, 0, 1.0); // C3
+    m_pDoc->SetValue(5, 2, 0, 1.0); // F3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 407.0, m_pDoc->GetValue(aPos));
+
+    // add some strings
+    m_pDoc->SetString(4, 1, 0, "a"); // E2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 357.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(1, 1, 0, "a"); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 357.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(0, 0, 0, "a"); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 352.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(3, 0, 0, "a"); // D1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 352.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=SUMX2PY2({1;2;3};{2;3;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2PY2 failed", 43.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMX2PY2({1;2;3};{2;3})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUMX2PY2 should return #VALUE! for matrices with different sizes",
+            OUString("#VALUE!"), aVal);
+    m_pDoc->SetString(aPos, "=SUMX2PY2({1;2;3})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUMX2PY2 needs two parameters",
+            OUString("Err:511"), aVal);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncSUMX2MY2()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "SumX2MY2 Test");
+
+    OUString aVal;
+    ScAddress aPos(6,0,0);
+    m_pDoc->SetString(aPos, "=SUMX2MY2(A1:C3;D1:F3)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 0.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetValue(0, 0, 0, 10.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(3, 0, 0, -9.0); // D1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 19.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 2.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 19.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(4, 0, 0, 1.0); // E1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 0, 0, 3.0); // C1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(5, 0, 0, 3.0); // F1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, 10.0); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(3, 1, 0, -10.0); // D2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 1, 0, -5.0); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(4, 1, 0, -5.0); // E2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 1, 0, -3.0); // C2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(5, 1, 0, 3.0); // F2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 2, 0, -8.0); // A3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 22.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(3, 2, 0, 3.0); // D3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 77.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 2, 0, 2.0); // B3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 77.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(4, 2, 0, -6.0); // E3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 45.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 2, 0, -4.0); // C3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 45.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(5, 2, 0, 6.0); // F3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 25.0, m_pDoc->GetValue(aPos));
+
+    // add some strings
+    m_pDoc->SetString(5, 2, 0, "a"); // F3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 45.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(0, 2, 0, "a"); // A3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", -10.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(1, 0, 0, "a"); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", -13.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(3, 0, 0, "a"); // D1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", -32.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=SUMX2MY2({1;3;5};{0;4;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 3.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMX2MY2({1;-3;-5};{0;-4;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 3.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMX2MY2({9;5;1};{3;-3;3})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMX2MY2 failed", 80.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMX2MY2({1;2;3};{2;3})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUMX2MY2 should return #VALUE! for matrices with different sizes",
+            OUString("#VALUE!"), aVal);
+    m_pDoc->SetString(aPos, "=SUMX2MY2({1;2;3})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUMX2MY2 needs two parameters",
+            OUString("Err:511"), aVal);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncGCD()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "GCDTest");
+
+    OUString aVal;
+    ScAddress aPos(4,0,0);
+
+    m_pDoc->SetString(aPos, "=GCD(A1)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, 10.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 10.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, -2.0); // A1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("GCD should return Err:502 for values less than 0",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetString(0, 0, 0, "a"); // A1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("GCD should return #VALUE! for a single string",
+            OUString("#VALUE!"), aVal);
+
+    m_pDoc->SetString(aPos, "=GCD(A1:B2)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, -12.0); // B1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("GCD should return Err:502 for a matrix with values less than 0",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetValue(0, 0, 0, 15.0); // A1
+    m_pDoc->SetValue(0, 1, 0, 0.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 15.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 5.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, 10.0); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 30.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, 20.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 10.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 1, 0, 120.0); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 10.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, 80.0); // A2
+    m_pDoc->SetValue(1, 0, 0, 40.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 20.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 45.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 5.0, m_pDoc->GetValue(aPos));
+
+    // with floor
+    m_pDoc->SetValue(1, 0, 0, 45.381); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 1, 0, 120.895); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, 20.97); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, 10.15); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 5.0, m_pDoc->GetValue(aPos));
+
+    // inline array
+    m_pDoc->SetString(aPos, "=GCD({3;6;9})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 3.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=GCD({150;0})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 150.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=GCD({-3;6;9})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("GCD should return Err:502 for an array with values less than 0",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetString(aPos, "=GCD({\"a\";6;9})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("GCD should return Err:502 for an array with strings",
+            OUString("Err:502"), aVal);
+
+    //many inline array
+    m_pDoc->SetString(aPos, "=GCD({6;6;6};{3;6;9})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 3.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=GCD({300;300;300};{150;0})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 150.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos,"=GCD({3;6;9};{3;-6;9})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("GCD should return Err:502 for an array with values less than 0",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetString(aPos, "=GCD({3;6;9};{\"a\";6;9})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("GCD should return Err:502 for an array with strings",
+            OUString("Err:502"), aVal);
+
+    // inline list of values
+    m_pDoc->SetString(aPos, "=GCD(12;24;36;48;60)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 12.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=GCD(0;12;24;36;48;60)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 12.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=GCD(\"a\";1)");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("GCD should return #VALUE! for an array with strings",
+            OUString("#VALUE!"), aVal);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncLCM()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "LCMTest");
+
+    OUString aVal;
+    ScAddress aPos(4,0,0);
+
+    m_pDoc->SetString(aPos, "=LCM(A1)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, 10.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 10.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, -2.0); // A1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("LCM should return Err:502 for values less than 0",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetString(0, 0, 0, "a"); // A1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("LCM should return #VALUE! for a single string",
+            OUString("#VALUE!"), aVal);
+
+    m_pDoc->SetString(aPos, "=LCM(A1:B2)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of GCD for failed", 1.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, -12.0); // B1
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("LCM should return Err:502 for a matrix with values less than 0",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetValue(0, 0, 0, 15.0); // A1
+    m_pDoc->SetValue(0, 1, 0, 0.0); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 5.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, 10.0); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 30.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 30.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 30.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, 20.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 60.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 1, 0, 125.0); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 1500.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 99.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 49500.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, 37.0); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 1831500.0, m_pDoc->GetValue(aPos));
+
+    // with floor
+    m_pDoc->SetValue(1, 0, 0, 99.89); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 1831500.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 1, 0, 11.32); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 73260.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, 22.58); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 7326.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, 3.99); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 198.0, m_pDoc->GetValue(aPos));
+
+    // inline array
+    m_pDoc->SetString(aPos, "=LCM({3;6;9})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 18.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=LCM({150;0})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=LCM({-3;6;9})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("LCM should return Err:502 for an array with values less than 0",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetString(aPos, "=LCM({\"a\";6;9})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("LCM should return Err:502 for an array with strings",
+            OUString("Err:502"), aVal);
+
+        //many inline array
+    m_pDoc->SetString(aPos, "=LCM({6;6;6};{3;6;9})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 18.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=LCM({300;300;300};{150;0})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos,"=LCM({3;6;9};{3;-6;9})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("LCM should return Err:502 for an array with values less than 0",
+            OUString("Err:502"), aVal);
+    m_pDoc->SetString(aPos, "=LCM({3;6;9};{\"a\";6;9})");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("LCM should return Err:502 for an array with strings",
+            OUString("Err:502"), aVal);
+
+    m_pDoc->SetString(aPos, "=LCM(12;24;36;48;60)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 720.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=LCM(0;12;24;36;48;60)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of LCM for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=LCM(\"a\";1)");
+    aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("LCM should return #VALUE! for an array with strings",
+            OUString("#VALUE!"), aVal);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncSUMSQ()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "SUMSQTest");
+
+    ScAddress aPos(4,0,0);
+
+    m_pDoc->SetString(aPos, "=SUMSQ(A1)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 0.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, 1.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 1.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 0, 0, -1.0); // A1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 1.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 1, 0, -2.0); // A2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 1.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=SUMSQ(A1:A3)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 0, 0, 3.0); // B1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 5.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ(A1:C3)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 14.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 1, 0, -4.0); // B2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 30.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(1, 2, 0, "a"); // B3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ with a string for failed", 30.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(1, 2, 0, 0.0); // B3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ with a string for failed", 30.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(0, 2, 0, 6.0); // A3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ with a string for failed", 66.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 0, 0, -5.0); // C1
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ with a string for failed", 91.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 1, 0, 3.0); // C2
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ with a string for failed", 100.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue(2, 2, 0, 2.0); // C3
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ with a string for failed", 104.0, m_pDoc->GetValue(aPos));
+
+    // inline array
+    m_pDoc->SetString(aPos, "=SUMSQ({1;2;3})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 14.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ({3;6;9})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 126.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ({15;0})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 225.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ({-3;3;1})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 19.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ({\"a\";-4;-5})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 41.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=SUMSQ({2;3};{4;5})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 54.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ({-3;3;1};{-1})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 20.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ({-4};{1;4;2};{-5;7};{9})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 192.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ({-2;2};{1};{-1};{0;0;0;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 26.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=SUMSQ(4;1;-3)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 26.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ(0;5;13;-7;-4)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 259.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ(0;12;24;36;48;60)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 7920.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ(0;-12;-24;36;-48;60)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUMSQ for failed", 7920.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetString(aPos, "=SUMSQ(\"a\";1;\"d\";-4;2)");
+    OUString aVal = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUMSQ should return #VALUE! for an array with strings",
+            OUString("#VALUE!"), aVal);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFuncMDETERM()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "MDETERM_test");
+    ScAddress aPos(8,0,0);
+    OUString const aColCodes("ABCDEFGH");
+    OUString const aFormulaTemplate("=MDETERM(A1:B2)");
+    OUStringBuffer aFormulaBuffer(aFormulaTemplate);
+    for( SCSIZE nSize = 3; nSize <= 8; nSize++ )
+    {
+        double fVal = 1.0;
+        // Generate a singular integer matrix
+        for( SCROW nRow = 0; nRow < static_cast<SCROW>(nSize); nRow++ )
+        {
+            for( SCCOL nCol = 0; nCol < static_cast<SCCOL>(nSize); nCol++ )
+            {
+                m_pDoc->SetValue(nCol, nRow, 0, fVal);
+                fVal += 1.0;
+            }
+        }
+        aFormulaBuffer[12] = aColCodes[nSize-1];
+        aFormulaBuffer[13] = static_cast<sal_Unicode>( '0' + nSize );
+        m_pDoc->SetString(aPos, aFormulaBuffer.toString());
+
+#if SAL_TYPES_SIZEOFPOINTER == 4
+        // On crappy 32-bit targets, presumably without extended precision on
+        // interim results or optimization not catching it, this test fails
+        // when comparing to 0.0, so have a narrow error margin. See also
+        // commit message of 8140309d636d4a870875f2dd75ed3dfff2c0fbaf
+        CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of MDETERM incorrect for singular integer matrix",
+                0.0, m_pDoc->GetValue(aPos), 1e-12);
+#else
+        // Even on one (and only one) x86_64 target the result was
+        // 6.34413156928661e-17 instead of 0.0 (tdf#99730) so lower the bar to
+        // 10e-14.
+        // Then again on aarch64, ppc64* and s390x it also fails.
+        // Sigh... why do we even test this? The original complaint in tdf#32834
+        // was about -9.51712667007776E-016
+        CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of MDETERM incorrect for singular integer matrix",
+                0.0, m_pDoc->GetValue(aPos), 1e-14);
+#endif
+    }
+
+    int const aVals[] = {23, 31, 13, 12, 34, 64, 34, 31, 98, 32, 33, 63, 45, 54, 65, 76};
+    int nIdx = 0;
+    for( SCROW nRow = 0; nRow < 4; nRow++ )
+        for( SCCOL nCol = 0; nCol < 4; nCol++ )
+            m_pDoc->SetValue(nCol, nRow, 0, static_cast<double>(aVals[nIdx++]));
+    m_pDoc->SetString(aPos, "=MDETERM(A1:D4)");
+    // Following test is conservative in the sense that on Linux x86_64 the error is less that 1.0E-9
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Calculation of MDETERM incorrect for non-singular integer matrix",
+                                         -180655.0, m_pDoc->GetValue(aPos), 1.0E-6);
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaErrorPropagation()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+
+    m_pDoc->InsertTab(0, "Sheet1");
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    ScAddress aPos, aPos2;
+    const OUString aTRUE("TRUE");
+    const OUString aFALSE("FALSE");
+
+    aPos.Set(0,0,0);// A1
+    m_pDoc->SetValue( aPos, 1.0);
+    aPos.IncCol();  // B1
+    m_pDoc->SetValue( aPos, 2.0);
+    aPos.IncCol();
+
+    aPos.IncRow();  // C2
+    m_pDoc->SetString( aPos, "=ISERROR(A1:B1+3)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aTRUE, m_pDoc->GetString(aPos));
+
+    aPos.IncRow();  // C3
+    m_pDoc->SetString( aPos, "=ISERROR(A1:B1+{3})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aTRUE, m_pDoc->GetString(aPos));
+    aPos.IncRow();  // C4
+    aPos2 = aPos;
+    aPos2.IncCol(); // D4
+    m_pDoc->InsertMatrixFormula(aPos.Col(), aPos.Row(), aPos2.Col(), aPos2.Row(), aMark, "=ISERROR(A1:B1+{3})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aFALSE, m_pDoc->GetString(aPos));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos2.Format(ScRefFlags::VALID).toUtf8().getStr(), aFALSE, m_pDoc->GetString(aPos2));
+
+    aPos.IncRow();  // C5
+    m_pDoc->SetString( aPos, "=ISERROR({1;\"x\"}+{3;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aFALSE, m_pDoc->GetString(aPos));
+    aPos.IncRow();  // C6
+    aPos2 = aPos;
+    aPos2.IncCol(); // D6
+    m_pDoc->InsertMatrixFormula(aPos.Col(), aPos.Row(), aPos2.Col(), aPos2.Row(), aMark, "=ISERROR({1;\"x\"}+{3;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aFALSE, m_pDoc->GetString(aPos));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos2.Format(ScRefFlags::VALID).toUtf8().getStr(), aTRUE, m_pDoc->GetString(aPos2));
+
+    aPos.IncRow();  // C7
+    m_pDoc->SetString( aPos, "=ISERROR({\"x\";2}+{3;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aTRUE, m_pDoc->GetString(aPos));
+    aPos.IncRow();  // C8
+    aPos2 = aPos;
+    aPos2.IncCol(); // D8
+    m_pDoc->InsertMatrixFormula(aPos.Col(), aPos.Row(), aPos2.Col(), aPos2.Row(), aMark, "=ISERROR({\"x\";2}+{3;4})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aTRUE, m_pDoc->GetString(aPos));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos2.Format(ScRefFlags::VALID).toUtf8().getStr(), aFALSE, m_pDoc->GetString(aPos2));
+
+    aPos.IncRow();  // C9
+    m_pDoc->SetString( aPos, "=ISERROR(({1;\"x\"}+{3;4})-{5;6})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aFALSE, m_pDoc->GetString(aPos));
+    aPos.IncRow();  // C10
+    aPos2 = aPos;
+    aPos2.IncCol(); // D10
+    m_pDoc->InsertMatrixFormula(aPos.Col(), aPos.Row(), aPos2.Col(), aPos2.Row(), aMark, "=ISERROR(({1;\"x\"}+{3;4})-{5;6})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aFALSE, m_pDoc->GetString(aPos));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos2.Format(ScRefFlags::VALID).toUtf8().getStr(), aTRUE, m_pDoc->GetString(aPos2));
+
+    aPos.IncRow();  // C11
+    m_pDoc->SetString( aPos, "=ISERROR(({\"x\";2}+{3;4})-{5;6})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aTRUE, m_pDoc->GetString(aPos));
+    aPos.IncRow();  // C12
+    aPos2 = aPos;
+    aPos2.IncCol(); // D12
+    m_pDoc->InsertMatrixFormula(aPos.Col(), aPos.Row(), aPos2.Col(), aPos2.Row(), aMark, "=ISERROR(({\"x\";2}+{3;4})-{5;6})");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos.Format(ScRefFlags::VALID).toUtf8().getStr(), aTRUE, m_pDoc->GetString(aPos));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( aPos2.Format(ScRefFlags::VALID).toUtf8().getStr(), aFALSE, m_pDoc->GetString(aPos2));
+
+    m_pDoc->DeleteTab(0);
+}
+
+namespace {
+
+class ColumnTest
+{
+    ScDocument * m_pDoc;
+
+    const SCROW m_nTotalRows;
+    const SCROW m_nStart1;
+    const SCROW m_nEnd1;
+    const SCROW m_nStart2;
+    const SCROW m_nEnd2;
+
+public:
+    ColumnTest( ScDocument * pDoc, SCROW nTotalRows,
+                SCROW nStart1, SCROW nEnd1, SCROW nStart2, SCROW nEnd2 )
+        : m_pDoc(pDoc), m_nTotalRows(nTotalRows)
+        , m_nStart1(nStart1), m_nEnd1(nEnd1)
+        , m_nStart2(nStart2), m_nEnd2(nEnd2)
+    {}
+
+    void operator() ( SCCOL nColumn, const OUString& rFormula,
+                      std::function<double(SCROW )> const & lExpected ) const
+    {
+        ScDocument aClipDoc(SCDOCMODE_CLIP);
+        ScMarkData aMark(MAXROW, MAXCOL);
+
+        ScAddress aPos(nColumn, m_nStart1, 0);
+        m_pDoc->SetString(aPos, rFormula);
+        ASSERT_DOUBLES_EQUAL( lExpected(m_nStart1), m_pDoc->GetValue(aPos) );
+
+        // Copy formula cell to clipboard.
+        ScClipParam aClipParam(aPos, false);
+        aMark.SetMarkArea(aPos);
+        m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false);
+
+        // Paste it to first range.
+        InsertDeleteFlags nFlags = InsertDeleteFlags::CONTENTS;
+        ScRange aDestRange(nColumn, m_nStart1, 0, nColumn, m_nEnd1, 0);
+        aMark.SetMarkArea(aDestRange);
+        m_pDoc->CopyFromClip(aDestRange, aMark, nFlags, nullptr, &aClipDoc);
+
+        // Paste it second range.
+        aDestRange = ScRange(nColumn, m_nStart2, 0, nColumn, m_nEnd2, 0);
+        aMark.SetMarkArea(aDestRange);
+        m_pDoc->CopyFromClip(aDestRange, aMark, nFlags, nullptr, &aClipDoc);
+
+        // Check the formula results for passed column.
+        for( SCROW i = 0; i < m_nTotalRows; ++i )
+        {
+            if( !((m_nStart1 <= i && i <= m_nEnd1) || (m_nStart2 <= i && i <= m_nEnd2)) )
+                continue;
+            double fExpected = lExpected(i);
+            ASSERT_DOUBLES_EQUAL(fExpected, m_pDoc->GetValue(ScAddress(nColumn,i,0)));
+        }
+    }
+};
+
+}
+
+void Test::testTdf97369()
+{
+    const SCROW TOTAL_ROWS = 330;
+    const SCROW ROW_RANGE = 10;
+    const SCROW START1 = 9;
+    const SCROW END1 = 159;
+    const SCROW START2 = 169;
+    const SCROW END2 = 319;
+
+    const double SHIFT1 = 200;
+    const double SHIFT2 = 400;
+
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "tdf97369"));
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc.
+
+    // set up columns A, B, C
+    for( SCROW i = 0; i < TOTAL_ROWS; ++i )
+    {
+        m_pDoc->SetValue(ScAddress(0, i, 0), i);          // A
+        m_pDoc->SetValue(ScAddress(1, i, 0), i + SHIFT1); // B
+        m_pDoc->SetValue(ScAddress(2, i, 0), i + SHIFT2); // C
+    }
+
+    const ColumnTest columnTest( m_pDoc, TOTAL_ROWS, START1, END1, START2, END2 );
+
+    auto lExpectedinD = [=] (SCROW n) {
+        return 3.0 * (n-START1) + SHIFT1 + SHIFT2;
+    };
+    columnTest(3, "=SUM(A1:C1)", lExpectedinD);
+
+    auto lExpectedinE = [=] (SCROW ) {
+        return SHIFT1 + SHIFT2;
+    };
+    columnTest(4, "=SUM(A$1:C$1)", lExpectedinE);
+
+    auto lExpectedinF = [=] (SCROW n) {
+        return ((2*n + 1 - ROW_RANGE) * ROW_RANGE) / 2.0;
+    };
+    columnTest(5, "=SUM(A1:A10)", lExpectedinF);
+
+    auto lExpectedinG = [=] (SCROW n) {
+        return ((n + 1) * n) / 2.0;
+    };
+    columnTest(6, "=SUM(A$1:A10)", lExpectedinG);
+
+    auto lExpectedinH = [=] (SCROW n) {
+        return 3.0 * (((2*n + 1 - ROW_RANGE) * ROW_RANGE) / 2) + ROW_RANGE * (SHIFT1 + SHIFT2);
+    };
+    columnTest(7, "=SUM(A1:C10)", lExpectedinH);
+
+    auto lExpectedinI = [=] (SCROW ) {
+        return 3.0 * (((2*START1 + 1 - ROW_RANGE) * ROW_RANGE) / 2) + ROW_RANGE * (SHIFT1 + SHIFT2);
+    };
+    columnTest(8, "=SUM(A$1:C$10)", lExpectedinI);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testTdf97587()
+{
+    const SCROW TOTAL_ROWS = 150;
+    const SCROW ROW_RANGE = 10;
+
+    CPPUNIT_ASSERT_MESSAGE ("failed to insert sheet",
+                            m_pDoc->InsertTab (0, "tdf97587"));
+
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn on auto calc.
+
+    std::set<SCROW> emptyCells = {0, 100};
+    for( SCROW i = 0; i < ROW_RANGE; ++i )
+    {
+        emptyCells.insert(i + TOTAL_ROWS / 3);
+        emptyCells.insert(i + TOTAL_ROWS);
+    }
+
+    // set up columns A
+    for( SCROW i = 0; i < TOTAL_ROWS; ++i )
+    {
+        if( emptyCells.find(i) != emptyCells.end() )
+            continue;
+        m_pDoc->SetValue(ScAddress(0, i, 0), 1.0);
+    }
+
+    ScDocument aClipDoc(SCDOCMODE_CLIP);
+    ScMarkData aMark(MAXROW, MAXCOL);
+
+    ScAddress aPos(1, 0, 0);
+    m_pDoc->SetString(aPos, "=SUM(A1:A10)");
+
+    // Copy formula cell to clipboard.
+    ScClipParam aClipParam(aPos, false);
+    aMark.SetMarkArea(aPos);
+    m_pDoc->CopyToClip(aClipParam, &aClipDoc, &aMark, false, false);
+
+    // Paste it to first range.
+    ScRange aDestRange(1, 1, 0, 1, TOTAL_ROWS + ROW_RANGE, 0);
+    aMark.SetMarkArea(aDestRange);
+    m_pDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::CONTENTS, nullptr, &aClipDoc);
+
+    // Check the formula results in column B.
+    for( SCROW i = 0; i < TOTAL_ROWS + 1; ++i )
+    {
+        int k = std::count_if( emptyCells.begin(), emptyCells.end(),
+                [=](SCROW n) { return (i <= n && n < i + ROW_RANGE); } );
+        double fExpected = ROW_RANGE - k;
+        ASSERT_DOUBLES_EQUAL(fExpected, m_pDoc->GetValue(ScAddress(1,i,0)));
+    }
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testMatConcat()
+{
+    CPPUNIT_ASSERT(m_pDoc->InsertTab (0, "Test"));
+
+    for (SCCOL nCol = 0; nCol < 10; ++nCol)
+    {
+        for (SCROW nRow = 0; nRow < 10; ++nRow)
+        {
+            m_pDoc->SetValue(ScAddress(nCol, nRow, 0), nCol*nRow);
+        }
+    }
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(0, 12, 9, 21, aMark, "=A1:J10&A1:J10");
+
+    for (SCCOL nCol = 0; nCol < 10; ++nCol)
+    {
+        for (SCROW nRow = 12; nRow < 22; ++nRow)
+        {
+            OUString aStr = m_pDoc->GetString(ScAddress(nCol, nRow, 0));
+            CPPUNIT_ASSERT_EQUAL(OUString(OUString::number(nCol * (nRow - 12)) + OUString::number(nCol * (nRow - 12))), aStr);
+        }
+    }
+
+    {   // Data in A12:B16
+        const char* aData[][2] = {
+            { "q", "w" },
+            { "a",  "" },
+            {  "", "x" },
+            {  "",  "" },
+            { "e", "r" },
+        };
+
+        ScAddress aPos(0,11,0);
+        ScRange aRange = insertRangeData(m_pDoc, aPos, aData, SAL_N_ELEMENTS(aData));
+        CPPUNIT_ASSERT_EQUAL(aPos, aRange.aStart);
+    }
+    // Matrix formula in C17:C21
+    m_pDoc->InsertMatrixFormula(2, 16, 2, 20, aMark, "=A12:A16&B12:B16");
+    // Check proper concatenation including empty cells.
+    OUString aStr;
+    ScAddress aPos(2,16,0);
+    aStr = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL(OUString("qw"),aStr);
+    aPos.IncRow();
+    aStr = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL(OUString("a"),aStr);
+    aPos.IncRow();
+    aStr = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL(OUString("x"),aStr);
+    aPos.IncRow();
+    aStr = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL(OUString(),aStr);
+    aPos.IncRow();
+    aStr = m_pDoc->GetString(aPos);
+    CPPUNIT_ASSERT_EQUAL(OUString("er"),aStr);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testMatConcatReplication()
+{
+    // if one of the matrices is a one column or row matrix
+    // the matrix is replicated across the larger matrix
+    CPPUNIT_ASSERT(m_pDoc->InsertTab (0, "Test"));
+
+    for (SCCOL nCol = 0; nCol < 10; ++nCol)
+    {
+        for (SCROW nRow = 0; nRow < 10; ++nRow)
+        {
+            m_pDoc->SetValue(ScAddress(nCol, nRow, 0), nCol*nRow);
+        }
+    }
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(0, 12, 9, 21, aMark, "=A1:J10&A1:J1");
+
+    for (SCCOL nCol = 0; nCol < 10; ++nCol)
+    {
+        for (SCROW nRow = 12; nRow < 22; ++nRow)
+        {
+            OUString aStr = m_pDoc->GetString(ScAddress(nCol, nRow, 0));
+            CPPUNIT_ASSERT_EQUAL(OUString(OUString::number(nCol * (nRow - 12)) + "0"), aStr);
+        }
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testRefR1C1WholeCol()
+{
+    CPPUNIT_ASSERT(m_pDoc->InsertTab (0, "Test"));
+
+    ScAddress aPos(1, 1, 1);
+    ScCompiler aComp(m_pDoc, aPos, FormulaGrammar::GRAM_ENGLISH_XL_R1C1);
+    std::unique_ptr<ScTokenArray> pTokens(aComp.CompileString("=C[10]"));
+    sc::TokenStringContext aCxt(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH);
+    OUString aFormula = pTokens->CreateString(aCxt, aPos);
+
+    CPPUNIT_ASSERT_EQUAL(OUString("L:L"), aFormula);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testRefR1C1WholeRow()
+{
+    CPPUNIT_ASSERT(m_pDoc->InsertTab (0, "Test"));
+
+    ScAddress aPos(1, 1, 1);
+    ScCompiler aComp(m_pDoc, aPos, FormulaGrammar::GRAM_ENGLISH_XL_R1C1);
+    std::unique_ptr<ScTokenArray> pTokens(aComp.CompileString("=R[3]"));
+    sc::TokenStringContext aCxt(m_pDoc, formula::FormulaGrammar::GRAM_ENGLISH);
+    OUString aFormula = pTokens->CreateString(aCxt, aPos);
+
+    CPPUNIT_ASSERT_EQUAL(OUString("5:5"), aFormula);
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testSingleCellCopyColumnLabel()
+{
+    ScDocOptions aOptions = m_pDoc->GetDocOptions();
+    aOptions.SetLookUpColRowNames(true);
+    m_pDoc->SetDocOptions(aOptions);
+    m_pDoc->InsertTab(0, "Test");
+
+    m_pDoc->SetString(0, 0, 0, "a");
+    m_pDoc->SetValue(0, 1, 0, 1.0);
+    m_pDoc->SetValue(0, 2, 0, 2.0);
+    m_pDoc->SetValue(0, 3, 0, 3.0);
+    m_pDoc->SetString(1, 1, 0, "='a'");
+
+    double nVal = m_pDoc->GetValue(1, 1, 0);
+    ASSERT_DOUBLES_EQUAL(1.0, nVal);
+
+    ScDocument aClipDoc(SCDOCMODE_CLIP);
+    copyToClip(m_pDoc, ScRange(1, 1, 0), &aClipDoc);
+    pasteOneCellFromClip(m_pDoc, ScRange(1, 2, 0), &aClipDoc);
+    nVal = m_pDoc->GetValue(1, 2, 0);
+    ASSERT_DOUBLES_EQUAL(2.0, nVal);
+
+    m_pDoc->DeleteTab(0);
+}
+
+// Significant whitespace operator intersection in Excel syntax, tdf#96426
+void Test::testIntersectionOpExcel()
+{
+    CPPUNIT_ASSERT(m_pDoc->InsertTab (0, "Test"));
+
+    ScRangeName* pGlobalNames = m_pDoc->GetRangeName();
+    // Horizontal cell range covering C2.
+    pGlobalNames->insert( new ScRangeData( m_pDoc, "horz", "$B$2:$D$2"));
+    // Vertical cell range covering C2.
+    pGlobalNames->insert( new ScRangeData( m_pDoc, "vert", "$C$1:$C$3"));
+    // Data in C2.
+    m_pDoc->SetValue(2,1,0, 1.0);
+
+    m_pDoc->SetGrammar(FormulaGrammar::GRAM_ENGLISH_XL_A1);
+
+    // Choose formula positions that don't intersect with those data ranges.
+    ScAddress aPos(0,3,0);
+    m_pDoc->SetString(aPos,"=B2:D2 C1:C3");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A4 intersecting references failed", 1.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    m_pDoc->SetString(aPos,"=horz vert");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A5 intersecting named expressions failed", 1.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    m_pDoc->SetString(aPos,"=(horz vert)*2");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A6 calculating with intersecting named expressions failed", 2.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    m_pDoc->SetString(aPos,"=2*(horz vert)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("A7 calculating with intersecting named expressions failed", 2.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetGrammar(FormulaGrammar::GRAM_ENGLISH);
+
+    m_pDoc->DeleteTab(0);
+}
+
+//Test Subtotal and Aggregate during hide rows #tdf93171
+void Test::testFuncRowsHidden()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Test");
+    m_pDoc->SetValue(0, 0, 0, 1); //A1
+    m_pDoc->SetValue(0, 1, 0, 2); //A2
+    m_pDoc->SetValue(0, 2, 0, 4); //A3
+    m_pDoc->SetValue(0, 3, 0, 8); //A4
+    m_pDoc->SetValue(0, 4, 0, 16); //A5
+    m_pDoc->SetValue(0, 5, 0, 32); //A6
+
+    ScAddress aPos(0,6,0);
+    m_pDoc->SetString(aPos, "=SUBTOTAL(109; A1:A6)");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUBTOTAL failed", 63.0, m_pDoc->GetValue(aPos));
+    //Hide row 1
+    m_pDoc->SetRowHidden(0, 0, 0, true);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUBTOTAL failed", 62.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetRowHidden(0, 0, 0, false);
+    //Hide row 2 and 3
+    m_pDoc->SetRowHidden(1, 2, 0, true);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUBTOTAL failed", 57.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetRowHidden(1, 2, 0, false);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUBTOTAL failed", 63.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=AGGREGATE(9; 5; A1:A6)"); //9=SUM 5=Ignore only hidden rows
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of AGGREGATE failed", 63.0, m_pDoc->GetValue(aPos));
+    //Hide row 1
+    m_pDoc->SetRowHidden(0, 0, 0, true);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of AGGREGATE failed", 62.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetRowHidden(0, 0, 0, false);
+    //Hide rows 3 to 5
+    m_pDoc->SetRowHidden(2, 4, 0, true);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of AGGREGATE failed", 35.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetRowHidden(2, 4, 0, false);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of AGGREGATE failed", 63.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->SetString(aPos, "=SUM(A1:A6)");
+    m_pDoc->SetRowHidden(2, 4, 0, true);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Calculation of SUM failed", 63.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->DeleteTab(0);
+}
+
+// Test COUNTIFS, SUMIFS, AVERAGEIFS in array context.
+void Test::testFuncSUMIFS()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Test");
+
+    // Data in A1:B7, query in A9:A11
+    std::vector<std::vector<const char*>> aData = {
+        { "a",  "1" },
+        { "b",  "2" },
+        { "c",  "4" },
+        { "d",  "8" },
+        { "a", "16" },
+        { "b", "32" },
+        { "c", "64" },
+        { "" },             // {} doesn't work with some compilers
+        { "a" },
+        { "b" },
+        { "c" },
+    };
+
+    insertRangeData(m_pDoc, ScAddress(0,0,0), aData);
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    // Matrix formula in C8:C10 with SUMIFS
+    m_pDoc->InsertMatrixFormula(2, 7, 2, 9, aMark, "=SUMIFS(B1:B7;A1:A7;A9:A11)");
+    // Matrix formula in D8:D10 with COUNTIFS
+    m_pDoc->InsertMatrixFormula(3, 7, 3, 9, aMark, "=COUNTIFS(A1:A7;A9:A11)");
+    // Matrix formula in E8:E10 with AVERAGEIFS
+    m_pDoc->InsertMatrixFormula(4, 7, 4, 9, aMark, "=AVERAGEIFS(B1:B7;A1:A7;A9:A11)");
+
+    {
+        // Result B1+B5, B2+B6, B3+B7 and counts and averages.
+        std::vector<std::vector<const char*>> aCheck = {
+            { "17", "2",  "8.5" },
+            { "34", "2", "17" },
+            { "68", "2", "34" }
+        };
+        bool bGood = checkOutput(m_pDoc, ScRange(2,7,0, 4,9,0), aCheck,
+                "SUMIFS, COUNTIFS and AVERAGEIFS in array context");
+        CPPUNIT_ASSERT_MESSAGE("SUMIFS, COUNTIFS or AVERAGEIFS in array context failed", bGood);
+    }
+
+    // Matrix formula in G8:G10 with SUMIFS and reference list arrays.
+    m_pDoc->InsertMatrixFormula(6, 7, 6, 9, aMark, "=SUMIFS(OFFSET(B1;ROW(1:3);0;2);OFFSET(B1;ROW(1:3);0;2);\">4\")");
+    // Matrix formula in H8:H10 with COUNTIFS and reference list arrays.
+    m_pDoc->InsertMatrixFormula(7, 7, 7, 9, aMark, "=COUNTIFS(OFFSET(B1;ROW(1:3);0;2);\">4\")");
+    // Matrix formula in I8:I10 with AVERAGEIFS and reference list arrays.
+    m_pDoc->InsertMatrixFormula(8, 7, 8, 9, aMark, "=AVERAGEIFS(OFFSET(B1;ROW(1:3);0;2);OFFSET(B1;ROW(1:3);0;2);\">4\")");
+
+    {
+        // Result sums, counts and averages.
+        std::vector<std::vector<const char*>> aCheck = {
+            {  "0", "0", "#DIV/0!" },
+            {  "8", "1",  "8" },
+            { "24", "2", "12" }
+        };
+        bool bGood = checkOutput(m_pDoc, ScRange(6,7,0, 8,9,0), aCheck,
+                "SUMIFS, COUNTIFS and AVERAGEIFS with reference list arrays");
+        CPPUNIT_ASSERT_MESSAGE("SUMIFS, COUNTIFS or AVERAGEIFS with reference list arrays failed", bGood);
+    }
+
+    // Matrix formula in K8:K10 with SUMIFS and reference list array condition
+    // and "normal" data range.
+    m_pDoc->InsertMatrixFormula(10, 7, 10, 9, aMark, "=SUMIFS(B1:B2;OFFSET(B1;ROW(1:3);0;2);\">4\")");
+    // Matrix formula in L8:L10 with AVERAGEIFS and reference list array
+    // condition and "normal" data range.
+    m_pDoc->InsertMatrixFormula(11, 7, 11, 9, aMark, "=AVERAGEIFS(B1:B2;OFFSET(B1;ROW(1:3);0;2);\">4\")");
+
+    {
+        // Result sums and averages.
+        std::vector<std::vector<const char*>> aCheck = {
+            { "0", "#DIV/0!" },
+            { "2", "2" },
+            { "3", "1.5" }
+        };
+        bool bGood = checkOutput(m_pDoc, ScRange(10,7,0, 11,9,0), aCheck,
+                "SUMIFS, COUNTIFS and AVERAGEIFS with reference list array and normal range");
+        CPPUNIT_ASSERT_MESSAGE("SUMIFS, COUNTIFS or AVERAGEIFS with reference list array and normal range failed", bGood);
+    }
+
+    // Matrix formula in G18:G20 with SUMIFS and reference list arrays and a
+    // "normal" criteria range.
+    m_pDoc->InsertMatrixFormula(6, 17, 6, 19, aMark, "=SUMIFS(OFFSET(B1;ROW(1:3);0;2);OFFSET(B1;ROW(1:3);0;2);\">4\";B1:B2;\">1\")");
+    // Matrix formula in H18:H20 with COUNTIFS and reference list arrays and a
+    // "normal" criteria range.
+    m_pDoc->InsertMatrixFormula(7, 17, 7, 19, aMark, "=COUNTIFS(OFFSET(B1;ROW(1:3);0;2);\">4\";B1:B2;\">1\")");
+    // Matrix formula in I18:I20 with AVERAGEIFS and reference list arrays and
+    // a "normal" criteria range.
+    m_pDoc->InsertMatrixFormula(8, 17, 8, 19, aMark, "=AVERAGEIFS(OFFSET(B1;ROW(1:3);0;2);OFFSET(B1;ROW(1:3);0;2);\">4\";B1:B2;\">1\")");
+
+    {
+        // Result sums, counts and averages.
+        std::vector<std::vector<const char*>> aCheck = {
+            {  "0", "0", "#DIV/0!" },
+            {  "8", "1",  "8" },
+            { "16", "1", "16" }
+        };
+        bool bGood = checkOutput(m_pDoc, ScRange(6,17,0, 8,19,0), aCheck,
+                "SUMIFS, COUNTIFS and AVERAGEIFS with reference list arrays and a normal criteria range");
+        CPPUNIT_ASSERT_MESSAGE("SUMIFS, COUNTIFS or AVERAGEIFS with reference list arrays and a normal criteria range failed", bGood);
+    }
+
+    // Matrix formula in K18:K20 with SUMIFS and reference list array condition
+    // and "normal" data range and a "normal" criteria range.
+    m_pDoc->InsertMatrixFormula(10, 17, 10, 19, aMark, "=SUMIFS(B1:B2;OFFSET(B1;ROW(1:3);0;2);\">4\";B1:B2;\">1\")");
+    // Matrix formula in L18:L20 with AVERAGEIFS and reference list array
+    // condition and "normal" data range and a "normal" criteria range.
+    m_pDoc->InsertMatrixFormula(11, 17, 11, 19, aMark, "=AVERAGEIFS(B1:B2;OFFSET(B1;ROW(1:3);0;2);\">4\";B1:B2;\">1\")");
+
+    {
+        // Result sums and averages.
+        std::vector<std::vector<const char*>> aCheck = {
+            { "0", "#DIV/0!" },
+            { "2", "2" },
+            { "2", "2" }
+        };
+        bool bGood = checkOutput(m_pDoc, ScRange(10,17,0, 11,19,0), aCheck,
+                "SUMIFS, COUNTIFS and AVERAGEIFS with reference list array and normal data and criteria range");
+        CPPUNIT_ASSERT_MESSAGE("SUMIFS, COUNTIFS or AVERAGEIFS with reference list array and normal data and criteria range failed", bGood);
+    }
+
+    // Same, but swapped normal and array criteria.
+
+    // Matrix formula in G28:G30 with SUMIFS and reference list arrays and a
+    // "normal" criteria range, swapped.
+    m_pDoc->InsertMatrixFormula(6, 27, 6, 29, aMark, "=SUMIFS(OFFSET(B1;ROW(1:3);0;2);B1:B2;\">1\";OFFSET(B1;ROW(1:3);0;2);\">4\")");
+    // Matrix formula in H28:H30 with COUNTIFS and reference list arrays and a
+    // "normal" criteria range, swapped.
+    m_pDoc->InsertMatrixFormula(7, 27, 7, 29, aMark, "=COUNTIFS(B1:B2;\">1\";OFFSET(B1;ROW(1:3);0;2);\">4\")");
+    // Matrix formula in I28:I30 with AVERAGEIFS and reference list arrays and
+    // a "normal" criteria range, swapped.
+    m_pDoc->InsertMatrixFormula(8, 27, 8, 29, aMark, "=AVERAGEIFS(OFFSET(B1;ROW(1:3);0;2);B1:B2;\">1\";OFFSET(B1;ROW(1:3);0;2);\">4\")");
+
+    {
+        // Result sums, counts and averages.
+        std::vector<std::vector<const char*>> aCheck = {
+            {  "0", "0", "#DIV/0!" },
+            {  "8", "1",  "8" },
+            { "16", "1", "16" }
+        };
+        bool bGood = checkOutput(m_pDoc, ScRange(6,27,0, 8,29,0), aCheck,
+                "SUMIFS, COUNTIFS and AVERAGEIFS with reference list arrays and a normal criteria range, swapped");
+        CPPUNIT_ASSERT_MESSAGE("SUMIFS, COUNTIFS or AVERAGEIFS with reference list arrays and a normal criteria range failed, swapped", bGood);
+    }
+
+    // Matrix formula in K28:K30 with SUMIFS and reference list array condition
+    // and "normal" data range and a "normal" criteria range, swapped.
+    m_pDoc->InsertMatrixFormula(10, 27, 10, 29, aMark, "=SUMIFS(B1:B2;B1:B2;\">1\";OFFSET(B1;ROW(1:3);0;2);\">4\")");
+    // Matrix formula in L28:L30 with AVERAGEIFS and reference list array
+    // condition and "normal" data range and a "normal" criteria range,
+    // swapped.
+    m_pDoc->InsertMatrixFormula(11, 27, 11, 29, aMark, "=AVERAGEIFS(B1:B2;B1:B2;\">1\";OFFSET(B1;ROW(1:3);0;2);\">4\")");
+
+    {
+        // Result sums and averages.
+        std::vector<std::vector<const char*>> aCheck = {
+            { "0", "#DIV/0!" },
+            { "2", "2" },
+            { "2", "2" }
+        };
+        bool bGood = checkOutput(m_pDoc, ScRange(10,27,0, 11,29,0), aCheck,
+                "SUMIFS, COUNTIFS and AVERAGEIFS with reference list array and normal data and criteria range, swapped");
+        CPPUNIT_ASSERT_MESSAGE("SUMIFS, COUNTIFS or AVERAGEIFS with reference list array and normal data and criteria range failed, swapped", bGood);
+    }
+
+    m_pDoc->DeleteTab(0);
+}
+
+// Test SUBTOTAL with reference lists in array context.
+void Test::testFuncRefListArraySUBTOTAL()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Test");
+
+    m_pDoc->SetValue(0,0,0,  1.0);  // A1
+    m_pDoc->SetValue(0,1,0,  2.0);  // A2
+    m_pDoc->SetValue(0,2,0,  4.0);  // A3
+    m_pDoc->SetValue(0,3,0,  8.0);  // A4
+    m_pDoc->SetValue(0,4,0, 16.0);  // A5
+    m_pDoc->SetValue(0,5,0, 32.0);  // A6
+
+    // Matrix in B7:B9, individual SUM of A2:A3, A3:A4 and A4:A5
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+    m_pDoc->InsertMatrixFormula(1, 6, 1, 8, aMark, "=SUBTOTAL(9;OFFSET(A1;ROW(1:3);0;2))");
+    ScAddress aPos(1,6,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL SUM for A2:A3 failed",  6.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL SUM for A3:A4 failed", 12.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL SUM for A4:A5 failed", 24.0, m_pDoc->GetValue(aPos));
+
+    // Matrix in C7:C9, individual AVERAGE of A2:A3, A3:A4 and A4:A5
+    m_pDoc->InsertMatrixFormula(2, 6, 2, 8, aMark, "=SUBTOTAL(1;OFFSET(A1;ROW(1:3);0;2))");
+    aPos.Set(2,6,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL AVERAGE for A2:A3 failed",  3.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL AVERAGE for A3:A4 failed",  6.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL AVERAGE for A4:A5 failed", 12.0, m_pDoc->GetValue(aPos));
+
+    // Matrix in D7:D9, individual MIN of A2:A3, A3:A4 and A4:A5
+    m_pDoc->InsertMatrixFormula(3, 6, 3, 8, aMark, "=SUBTOTAL(5;OFFSET(A1;ROW(1:3);0;2))");
+    aPos.Set(3,6,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MIN for A2:A3 failed",  2.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MIN for A3:A4 failed",  4.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MIN for A4:A5 failed",  8.0, m_pDoc->GetValue(aPos));
+
+    // Matrix in E7:E9, individual MAX of A2:A3, A3:A4 and A4:A5
+    m_pDoc->InsertMatrixFormula(4, 6, 4, 8, aMark, "=SUBTOTAL(4;OFFSET(A1;ROW(1:3);0;2))");
+    aPos.Set(4,6,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MAX for A2:A3 failed",  4.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MAX for A3:A4 failed",  8.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MAX for A4:A5 failed", 16.0, m_pDoc->GetValue(aPos));
+
+    // Matrix in F7:F9, individual STDEV of A2:A3, A3:A4 and A4:A5
+    m_pDoc->InsertMatrixFormula(5, 6, 5, 8, aMark, "=SUBTOTAL(7;OFFSET(A1;ROW(1:3);0;2))");
+    aPos.Set(5,6,0);
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SUBTOTAL STDEV for A2:A3 failed", 1.414214, m_pDoc->GetValue(aPos), 1e-6);
+    aPos.IncRow();
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SUBTOTAL STDEV for A3:A4 failed", 2.828427, m_pDoc->GetValue(aPos), 1e-6);
+    aPos.IncRow();
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SUBTOTAL STDEV for A4:A5 failed", 5.656854, m_pDoc->GetValue(aPos), 1e-6);
+
+    // Matrix in G7:G9, individual AVERAGE of A2:A3, A3:A4 and A4:A5
+    // Plus two "ordinary" ranges, one before and one after.
+    m_pDoc->InsertMatrixFormula(6, 6, 6, 8, aMark, "=SUBTOTAL(1;A1:A2;OFFSET(A1;ROW(1:3);0;2);A5:A6)");
+    aPos.Set(6,6,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL AVERAGE for A1:A2,A2:A3,A5:A6 failed",  9.5, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL AVERAGE for A1:A2,A3:A4,A5:A6 failed", 10.5, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL AVERAGE for A1:A2,A4:A5,A5:A6 failed", 12.5, m_pDoc->GetValue(aPos));
+
+    // Matrix in H7:H9, individual MAX of A2:A3, A3:A4 and A4:A5
+    // Plus two "ordinary" ranges, one before and one after.
+    m_pDoc->InsertMatrixFormula(7, 6, 7, 8, aMark, "=SUBTOTAL(4;A1:A2;OFFSET(A1;ROW(1:3);0;2);A5:A6)");
+    aPos.Set(7,6,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MAX for A1:A2,A2:A3,A5:A6 failed", 32.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MAX for A1:A2,A3:A4,A5:A6 failed", 32.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUBTOTAL MAX for A1:A2,A4:A5,A5:A6 failed", 32.0, m_pDoc->GetValue(aPos));
+
+    // Matrix in I7:I9, individual STDEV of A2:A3, A3:A4 and A4:A5
+    // Plus two "ordinary" ranges, one before and one after.
+    m_pDoc->InsertMatrixFormula(8, 6, 8, 8, aMark, "=SUBTOTAL(7;A1:A2;OFFSET(A1;ROW(1:3);0;2);A5:A6)");
+    aPos.Set(8,6,0);
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SUBTOTAL STDEV for A1:A2,A2:A3,A5:A6 failed", 12.35718, m_pDoc->GetValue(aPos), 1e-5);
+    aPos.IncRow();
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SUBTOTAL STDEV for A1:A2,A3:A4,A5:A6 failed", 11.86170, m_pDoc->GetValue(aPos), 1e-5);
+    aPos.IncRow();
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("SUBTOTAL STDEV for A1:A2,A4:A5,A5:A6 failed", 11.55422, m_pDoc->GetValue(aPos), 1e-5);
+
+    // Empty two cells such that they affect two ranges.
+    m_pDoc->SetString(0,1,0, "");   // A2
+    m_pDoc->SetString(0,2,0, "");   // A3
+    // Matrix in J7:J9, individual COUNTBLANK of A2:A3, A3:A4 and A4:A5
+    m_pDoc->InsertMatrixFormula(9, 6, 9, 8, aMark, "=COUNTBLANK(OFFSET(A1;ROW(1:3);0;2))");
+    aPos.Set(9,6,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("COUNTBLANK for A1:A2,A2:A3,A5:A6 failed", 2.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("COUNTBLANK for A1:A2,A3:A4,A5:A6 failed", 1.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("COUNTBLANK for A1:A2,A4:A5,A5:A6 failed", 0.0, m_pDoc->GetValue(aPos));
+
+    // Restore these two cell values so we'd catch failures below.
+    m_pDoc->SetValue(0,1,0,  2.0);  // A2
+    m_pDoc->SetValue(0,2,0,  4.0);  // A3
+    // Hide rows 2 to 4.
+    m_pDoc->SetRowHidden(1,3,0, true);
+    // Matrix in K7, array of references as OFFSET result.
+    m_pDoc->InsertMatrixFormula(10, 6, 10, 6, aMark, "=SUM(SUBTOTAL(109;OFFSET(A1;ROW(A1:A7)-ROW(A1);;1)))");
+    aPos.Set(10,6,0);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUM SUBTOTAL failed", 49.0, m_pDoc->GetValue(aPos));
+    aPos.IncRow();
+    // ForceArray in K8, array of references as OFFSET result.
+    m_pDoc->SetString( aPos, "=SUMPRODUCT(SUBTOTAL(109;OFFSET(A1;ROW(A1:A7)-ROW(A1);;1)))");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("SUMPRODUCT SUBTOTAL failed", 49.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->DeleteTab(0);
+}
+
+// tdf#115493 jump commands return the matrix result instead of the reference
+// list array.
+void Test::testFuncJumpMatrixArrayIF()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Test");
+
+    m_pDoc->SetString(0,0,0, "a");  // A1
+    std::vector<std::vector<const char*>> aData = {
+        { "a", "1" },
+        { "b", "2" },
+        { "a", "4" }
+    };                              // A7:B9
+    insertRangeData(m_pDoc, ScAddress(0,6,0), aData);
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+
+    // Matrix in C10, summing B7,B9
+    m_pDoc->InsertMatrixFormula( 2,9, 2,9, aMark, "=SUM(IF(EXACT(A7:A9;A$1);B7:B9;0))");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Formula C10 failed", 5.0, m_pDoc->GetValue(ScAddress(2,9,0)));
+
+    // Matrix in C11, summing B7,B9
+    m_pDoc->InsertMatrixFormula( 2,10, 2,10, aMark,
+            "=SUM(IF(EXACT(OFFSET(A7;0;0):OFFSET(A7;2;0);A$1);OFFSET(A7;0;1):OFFSET(A7;2;1);0))");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Formula C11 failed", 5.0, m_pDoc->GetValue(ScAddress(2,10,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+// tdf#123477 OFFSET() returns the matrix result instead of the reference list
+// array if result is not used as ReferenceOrRefArray.
+void Test::testFuncJumpMatrixArrayOFFSET()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Test");
+
+    std::vector<std::vector<const char*>> aData = {
+        { "abc" },
+        { "bcd" },
+        { "cde" }
+    };
+    insertRangeData(m_pDoc, ScAddress(0,0,0), aData);   // A1:A3
+
+    ScMarkData aMark(MAXROW, MAXCOL);
+    aMark.SelectOneTable(0);
+
+    // Matrix in C5:C7, COLUMN()-3 here offsets by 0 but the entire expression
+    // is in array/matrix context.
+    m_pDoc->InsertMatrixFormula( 2,4, 2,6, aMark, "=FIND(\"c\";OFFSET(A1:A3;0;COLUMN()-3))");
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Formula C5 failed", 3.0, m_pDoc->GetValue(ScAddress(2,4,0)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Formula C6 failed", 2.0, m_pDoc->GetValue(ScAddress(2,5,0)));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Formula C7 failed", 1.0, m_pDoc->GetValue(ScAddress(2,6,0)));
+
+    m_pDoc->DeleteTab(0);
+}
+
+// Test iterations with circular chain of references.
+void Test::testIterations()
+{
+    ScDocOptions aDocOpts = m_pDoc->GetDocOptions();
+    aDocOpts.SetIter( true );
+    m_pDoc->SetDocOptions( aDocOpts );
+
+    m_pDoc->InsertTab(0, "Test");
+
+    m_pDoc->SetValue( 0, 0, 0, 0.01 );         // A1
+    m_pDoc->SetString( 0, 1, 0, "=A1" );       // A2
+    m_pDoc->SetString( 0, 2, 0, "=COS(A2)" );  // A3
+    m_pDoc->CalcAll();
+
+    // Establish reference cycle for the computation of the fixed point of COS() function
+    m_pDoc->SetString( 0, 0, 0, "=A3" );       // A1
+    m_pDoc->CalcAll();
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Cell A3 should not have any formula error", FormulaError::NONE, m_pDoc->GetErrCode( ScAddress( 0, 2, 0) ) );
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE( "Iterations to calculate fixed point of cos() failed", 0.7387, m_pDoc->GetValue(0, 2, 0), 1e-4 );
+
+    // Modify the formula
+    m_pDoc->SetString( 0, 2, 0, "=COS(A2)+0.001" );  // A3
+    m_pDoc->CalcAll();
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Cell A3 should not have any formula error after perturbation", FormulaError::NONE, m_pDoc->GetErrCode( ScAddress( 0, 2, 0) ) );
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE( "Iterations to calculate perturbed fixed point of cos() failed", 0.7399, m_pDoc->GetValue(0, 2, 0), 1e-4 );
+
+    m_pDoc->DeleteTab(0);
+
+    aDocOpts.SetIter( false );
+    m_pDoc->SetDocOptions( aDocOpts );
+}
+
+// tdf#111428 CellStoreEvent and its counter used for quick "has a column
+// formula cells" must point to the correct column.
+void Test::testInsertColCellStoreEventSwap()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Test");
+
+    m_pDoc->SetValue(  0,0,0, 1.0 );    // A1
+    m_pDoc->SetString( 1,0,0, "=A1" );  // B1
+    // Insert column left of B
+    m_pDoc->InsertCol( ScRange(1,0,0, 1,m_pDoc->MaxRow(),0));
+    ScAddress aPos(2,0,0);              // C1, new formula position
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Should be formula cell having value", 1.0, m_pDoc->GetValue(aPos));
+    // After having swapped in an empty column, editing or adding a formula
+    // cell has to use the correct store context. To test this,
+    // ScDocument::SetString() can't be used as it doesn't expose the behavior
+    // in question, use ScDocFunc::SetFormulaCell() instead which actually is
+    // also called when editing a cell and creating a formula cell.
+    ScFormulaCell* pCell = new ScFormulaCell( m_pDoc, aPos, "=A1+1");
+    ScDocFunc& rDocFunc = getDocShell().GetDocFunc();
+    rDocFunc.SetFormulaCell( aPos, pCell, false);   // C1, change formula
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Initial calculation failed", 2.0, m_pDoc->GetValue(aPos));
+    m_pDoc->SetValue( 0,0,0, 2.0 );     // A1, change value
+    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Recalculation failed", 3.0, m_pDoc->GetValue(aPos));
+
+    m_pDoc->DeleteTab(0);
+}
+
+void Test::testFormulaAfterDeleteRows()
+{
+    sc::AutoCalcSwitch aACSwitch(*m_pDoc, true); // turn auto calc on.
+    m_pDoc->InsertTab(0, "Test");
+
+    // Fill A1:A70000 with 1.0
+    std::vector<double> aVals(70000, 1.0);
+    m_pDoc->SetValues(ScAddress(0, 0, 0), aVals);
+    // Set A70001 with formula "=SUM(A1:A70000)"
+    m_pDoc->SetString(0, 70000, 0, "=SUM(A1:A70000)");
+
+    // Delete rows 2:69998
+    m_pDoc->DeleteRow(ScRange(0, 1, 0, m_pDoc->MaxCol(), 69997, 0));
+
+    const ScAddress aPos(0, 3, 0);  // A4
+    ASSERT_FORMULA_EQUAL(*m_pDoc, aPos, "SUM(A1:A3)", "Wrong formula in A4.");
+
+    ASSERT_DOUBLES_EQUAL_MESSAGE("Wrong value at A4", 3.0, m_pDoc->GetValue(aPos));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */