chart2/qa/extras/PivotChartTest.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include "charttest.hxx"
  11
  12 #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
  13 #include <com/sun/star/sheet/DataPilotFieldLayoutMode.hpp>
  14 #include <com/sun/star/sheet/DataPilotFieldLayoutInfo.hpp>
  15 #include <com/sun/star/sheet/XDataPilotTable.hpp>
  16 #include <com/sun/star/sheet/XDataPilotDescriptor.hpp>
  17 #include <com/sun/star/sheet/XDataPilotTables.hpp>
  18 #include <com/sun/star/sheet/XDataPilotTablesSupplier.hpp>
  19 #include <com/sun/star/sheet/XSpreadsheet.hpp>
  20 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
  21 #include <com/sun/star/sheet/XSpreadsheets.hpp>
  22 #include <com/sun/star/table/XTablePivotCharts.hpp>
  23 #include <com/sun/star/sheet/GeneralFunction.hpp>
  24 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
  25 #include <com/sun/star/util/XNumberFormatTypes.hpp>
  26 #include <com/sun/star/util/NumberFormat.hpp>
  27
  28 #include <com/sun/star/chart2/data/XPivotTableDataProvider.hpp>
  29 #include <com/sun/star/chart2/data/XTextualDataSequence.hpp>
  30
  31 namespace com::sun::star::table { class XCellRange; }
  32 namespace com::sun::star::util { class XNumberFormats; }
  33
  34 class PivotChartTest : public ChartTest
  35 {
  36 public:
  37     PivotChartTest()
  38         : ChartTest("/chart2/qa/extras/data/")
  39     {}
  40
  41     void testRoundtrip();
  42     void testChangePivotTable();
  43     void testPivotChartWithOneColumnField();
  44     void testPivotChartWithOneRowField();
  45     void testPivotTableDataProvider_PivotTableFields();
  46     void testPivotChartRowFieldInOutlineMode();
  47     void testPivotChartWithDateRowField();
  48
  49     CPPUNIT_TEST_SUITE(PivotChartTest);
  50     CPPUNIT_TEST(testRoundtrip);
  51     CPPUNIT_TEST(testChangePivotTable);
  52     CPPUNIT_TEST(testPivotChartWithOneColumnField);
  53     CPPUNIT_TEST(testPivotChartWithOneRowField);
  54     CPPUNIT_TEST(testPivotTableDataProvider_PivotTableFields);
  55     CPPUNIT_TEST(testPivotChartRowFieldInOutlineMode);
  56     CPPUNIT_TEST(testPivotChartWithDateRowField);
  57     CPPUNIT_TEST_SUITE_END();
  58 };
  59
  60 namespace
  61 {
  62
  63 void lclModifyOrientation(uno::Reference<sheet::XDataPilotDescriptor> const & xDescriptor,
  64                           std::u16string_view sFieldName,
  65                           sheet::DataPilotFieldOrientation eOrientation)
  66 {
  67     uno::Reference<container::XIndexAccess> xIndexAccess(xDescriptor->getDataPilotFields(), UNO_SET_THROW);
  68     sal_Int32 nCount = xIndexAccess->getCount();
  69     for (sal_Int32 i = 0; i < nCount; ++i)
  70     {
  71         uno::Reference<container::XNamed> xNamed(xIndexAccess->getByIndex(i), UNO_QUERY_THROW);
  72         OUString aName = xNamed->getName();
  73         uno::Reference<beans::XPropertySet> xPropSet(xNamed, UNO_QUERY_THROW);
  74         if (aName == sFieldName)
  75             xPropSet->setPropertyValue("Orientation", uno::Any(eOrientation));
  76     }
  77 }
  78
  79 void lclModifyFunction(uno::Reference<sheet::XDataPilotDescriptor> const & xDescriptor,
  80                           std::u16string_view sFieldName,
  81                           sheet::GeneralFunction eFunction)
  82 {
  83     uno::Reference<container::XIndexAccess> xPilotIndexAccess(xDescriptor->getDataPilotFields(), UNO_SET_THROW);
  84     sal_Int32 nCount = xPilotIndexAccess->getCount();
  85     for (sal_Int32 i = 0; i < nCount; ++i)
  86     {
  87         uno::Reference<container::XNamed> xNamed(xPilotIndexAccess->getByIndex(i), UNO_QUERY_THROW);
  88         OUString aName = xNamed->getName();
  89         uno::Reference<beans::XPropertySet> xPropSet(xNamed, UNO_QUERY_THROW);
  90         if (aName == sFieldName)
  91             xPropSet->setPropertyValue("Function", uno::Any(eFunction));
  92     }
  93 }
  94
  95 void lclModifyLayoutInfo(uno::Reference<sheet::XDataPilotDescriptor> const & xDescriptor,
  96                           std::u16string_view sFieldName,
  97                           sheet::DataPilotFieldLayoutInfo aLayoutInfo)
  98 {
  99     uno::Reference<container::XIndexAccess> xIndexAccess(xDescriptor->getDataPilotFields(), UNO_SET_THROW);
 100     sal_Int32 nCount = xIndexAccess->getCount();
 101     for (sal_Int32 i = 0; i < nCount; ++i)
 102     {
 103         uno::Reference<container::XNamed> xNamed(xIndexAccess->getByIndex(i), UNO_QUERY_THROW);
 104         OUString aName = xNamed->getName();
 105         uno::Reference<beans::XPropertySet> xPropSet(xNamed, UNO_QUERY_THROW);
 106         if (aName == sFieldName)
 107         {
 108             uno::Any aValue;
 109             aValue <<= aLayoutInfo;
 110             xPropSet->setPropertyValue("LayoutInfo", aValue);
 111         }
 112     }
 113 }
 114
 115 void lclModifySubtotals(uno::Reference<sheet::XDataPilotDescriptor> const & xDescriptor,
 116                         std::u16string_view sFieldName,
 117                         uno::Sequence<sheet::GeneralFunction> const & rSubtotalFunctions)
 118 {
 119     uno::Reference<container::XIndexAccess> xIndexAccess(xDescriptor->getDataPilotFields(), UNO_SET_THROW);
 120     sal_Int32 nCount = xIndexAccess->getCount();
 121     for (sal_Int32 i = 0; i < nCount; ++i)
 122     {
 123         uno::Reference<container::XNamed> xNamed(xIndexAccess->getByIndex(i), UNO_QUERY_THROW);
 124         OUString aName = xNamed->getName();
 125         uno::Reference<beans::XPropertySet> xPropSet(xNamed, UNO_QUERY_THROW);
 126         if (aName == sFieldName)
 127         {
 128             uno::Any aValue;
 129             aValue <<= rSubtotalFunctions;
 130             xPropSet->setPropertyValue("Subtotals", aValue);
 131         }
 132     }
 133 }
 134
 135 void lclModifyColumnGrandTotal(uno::Reference<sheet::XDataPilotDescriptor> const & xDataPilotDescriptor, bool bTotal)
 136 {
 137         uno::Reference<beans::XPropertySet> xProperties(xDataPilotDescriptor, uno::UNO_QUERY_THROW);
 138         xProperties->setPropertyValue("ColumnGrand", uno::Any(bTotal));
 139 }
 140
 141 void lclModifyRowGrandTotal(uno::Reference<sheet::XDataPilotDescriptor> const & xDataPilotDescriptor, bool bTotal)
 142 {
 143         uno::Reference<beans::XPropertySet> xProperties(xDataPilotDescriptor, uno::UNO_QUERY_THROW);
 144         xProperties->setPropertyValue("RowGrand", uno::Any(bTotal));
 145 }
 146
 147 void lclCheckSequence(std::vector<double> const & reference,
 148                       uno::Sequence<uno::Any> const & values,
 149                       double delta)
 150 {
 151     CPPUNIT_ASSERT_EQUAL(reference.size(), size_t(values.getLength()));
 152     for (size_t i = 0; i < reference.size(); ++i)
 153     {
 154         CPPUNIT_ASSERT_DOUBLES_EQUAL(
 155             reference[i], values[i].get<double>(), delta);
 156     }
 157 }
 158
 159 void lclCheckCategories(std::vector<OUString> const & reference,
 160                         uno::Reference<chart2::data::XDataSequence> const & xSequence)
 161 {
 162     uno::Reference<chart2::data::XTextualDataSequence> xTextualDataSequence(xSequence, uno::UNO_QUERY_THROW);
 163     uno::Sequence<OUString> aText = xTextualDataSequence->getTextualData();
 164
 165     CPPUNIT_ASSERT_EQUAL(reference.size(), size_t(aText.getLength()));
 166     for (size_t i = 0; i < reference.size(); ++i)
 167     {
 168         CPPUNIT_ASSERT_EQUAL(reference[i], aText[i]);
 169     }
 170 }
 171
 172 OUString lclGetLabel(Reference<chart2::XChartDocument> const & xChartDoc, sal_Int32 nSeriesIndex)
 173 {
 174     Reference<chart2::data::XDataSequence> xLabelDataSequence = getLabelDataSequenceFromDoc(xChartDoc, nSeriesIndex);
 175     return xLabelDataSequence->getData()[0].get<OUString>();
 176 }
 177
 178 uno::Reference<sheet::XDataPilotTable> lclGetPivotTableByName(sal_Int32 nIndex, OUString const & sPivotTableName,
 179                                                            uno::Reference<lang::XComponent> const & xComponent)
 180 {
 181     uno::Reference<sheet::XSpreadsheetDocument> xDoc(xComponent, UNO_QUERY_THROW);
 182     uno::Reference<container::XIndexAccess> xSheetIndexAccess(xDoc->getSheets(), UNO_QUERY_THROW);
 183     uno::Any aAny = xSheetIndexAccess->getByIndex(nIndex);
 184     uno::Reference<sheet::XSpreadsheet> xSheet;
 185     CPPUNIT_ASSERT(aAny >>= xSheet);
 186     uno::Reference<sheet::XDataPilotTablesSupplier> xDataPilotTablesSupplier(xSheet, uno::UNO_QUERY_THROW);
 187     uno::Reference<sheet::XDataPilotTables> xDataPilotTables = xDataPilotTablesSupplier->getDataPilotTables();
 188     return uno::Reference<sheet::XDataPilotTable>(xDataPilotTables->getByName(sPivotTableName), UNO_QUERY_THROW);
 189 }
 190
 191 uno::Sequence<uno::Reference<chart2::data::XLabeledDataSequence>>
 192     lclGetCategories(Reference<chart2::XChartDocument> const & xChartDoc)
 193 {
 194     uno::Sequence<beans::PropertyValue> aArguments( comphelper::InitPropertySequence(
 195             {{"CellRangeRepresentation", uno::Any(OUString("PT@categories"))}} ));
 196
 197     uno::Reference<chart2::data::XDataProvider> xDataProvider(xChartDoc->getDataProvider(), uno::UNO_SET_THROW);
 198     return xDataProvider->createDataSource(aArguments)->getDataSequences();
 199 }
 200
 201 struct Value
 202 {
 203     OUString maString;
 204     double mfValue;
 205     bool mbIsValue;
 206
 207     Value(OUString const & rString)
 208         : maString(rString)
 209         , mfValue(0.0)
 210         , mbIsValue(false)
 211     {}
 212
 213     Value(double fValue)
 214         : mfValue(fValue)
 215         , mbIsValue(true)
 216     {}
 217 };
 218
 219 uno::Reference< sheet::XDataPilotTables>
 220 lclGetDataPilotTables(sal_Int32 nIndex, uno::Reference<sheet::XSpreadsheetDocument> const & xSheetDoc)
 221 {
 222     uno::Reference<sheet::XSpreadsheets> xSpreadsheets = xSheetDoc->getSheets();
 223     uno::Reference<container::XIndexAccess> oIndexAccess(xSpreadsheets, uno::UNO_QUERY_THROW);
 224     uno::Reference<sheet::XSpreadsheet> xSheet;
 225     CPPUNIT_ASSERT(oIndexAccess->getByIndex(nIndex) >>= xSheet);
 226
 227     // create the test objects
 228     uno::Reference< sheet::XDataPilotTablesSupplier> xDataPilotTablesSupplier(xSheet, uno::UNO_QUERY_THROW);
 229     return xDataPilotTablesSupplier->getDataPilotTables();
 230 }
 231
 232 table::CellRangeAddress lclCreateTestData(uno::Reference<sheet::XSpreadsheetDocument> const & xSheetDoc)
 233 {
 234     CPPUNIT_ASSERT_MESSAGE("no calc document!", xSheetDoc.is());
 235
 236     std::vector<OUString> aHeaders {
 237         "Country", "City", "Type", "Sales T1", "Sales T2", "Sales T3", "Sales T4", "Date"
 238     };
 239
 240     std::vector<std::vector<Value>> aData {
 241         { {"FR"}, {"Paris"},     {"A"}, {123.0}, {223.0}, {323.0}, {423.0}, {"12/14/15"} },
 242         { {"EN"}, {"London"},    {"A"}, {456.0}, {556.0}, {656.0}, {756.0}, {"12/11/15"} },
 243         { {"DE"}, {"Berlin"},    {"A"}, {468.0}, {568.0}, {668.0}, {768.0}, {"12/11/15"} },
 244         { {"FR"}, {"Nantes"},    {"A"}, {694.0}, {794.0}, {894.0}, {994.0}, {"12/11/15"} },
 245         { {"EN"}, {"Glasgow"},   {"A"}, {298.0}, {398.0}, {498.0}, {598.0}, {"12/11/15"} },
 246         { {"DE"}, {"Munich"},    {"A"}, {369.0}, {469.0}, {569.0}, {669.0}, {"12/11/15"} },
 247         { {"FR"}, {"Paris"},     {"B"}, {645.0}, {745.0}, {845.0}, {945.0}, {"12/11/15"} },
 248         { {"EN"}, {"London"},    {"B"}, {687.0}, {787.0}, {887.0}, {987.0}, {"03/21/17"} },
 249         { {"DE"}, {"Munich"},    {"B"}, {253.0}, {353.0}, {453.0}, {553.0}, {"12/17/15"} },
 250         { {"FR"}, {"Nantes"},    {"B"}, {474.0}, {574.0}, {674.0}, {774.0}, {"01/20/16"} },
 251         { {"EN"}, {"Liverpool"}, {"B"}, {562.0}, {662.0}, {762.0}, {862.0}, {"01/20/16"} },
 252         { {"DE"}, {"Berlin"},    {"B"}, {648.0}, {748.0}, {848.0}, {948.0}, {"01/20/16"} }
 253     };
 254
 255     // Getting spreadsheet
 256     uno::Reference<sheet::XSpreadsheets> xSpreadsheets = xSheetDoc->getSheets();
 257     uno::Reference<container::XIndexAccess> oIndexAccess(xSpreadsheets, uno::UNO_QUERY_THROW);
 258     uno::Reference<sheet::XSpreadsheet> xSheet;
 259     CPPUNIT_ASSERT(oIndexAccess->getByIndex(0) >>= xSheet);
 260
 261     uno::Reference<sheet::XSpreadsheet> oPivotTableSheet;
 262     xSpreadsheets->insertNewByName("Pivot Table", 1);
 263     CPPUNIT_ASSERT(oIndexAccess->getByIndex(1) >>= oPivotTableSheet);
 264
 265     sal_Int32 currentRow = 0;
 266     for (size_t column = 0; column < aHeaders.size(); ++column)
 267     {
 268         xSheet->getCellByPosition(column, currentRow)->setFormula(aHeaders[column]);
 269     }
 270     currentRow++;
 271
 272     for (std::vector<Value> const & rRowOfData : aData)
 273     {
 274         for (size_t column = 0; column < rRowOfData.size(); ++column)
 275         {
 276             Value const & rValue = rRowOfData[column];
 277             uno::Reference<table::XCell> xCell(xSheet->getCellByPosition(column, currentRow));
 278             if (rValue.mbIsValue)
 279                 xCell->setValue(rValue.mfValue);
 280             else
 281                 xCell->setFormula(rValue.maString);
 282         }
 283         currentRow++;
 284     }
 285
 286     sal_Int32 nEndCol = sal_Int32(aHeaders.size() - 1);
 287     sal_Int32 nEndRow = sal_Int32(1/*HEADER*/ + aData.size() - 1);
 288
 289     // Apply date format to the last column
 290     uno::Reference<util::XNumberFormatsSupplier> xNumberFormatsSupplier(xSheetDoc, UNO_QUERY_THROW);
 291     uno::Reference<util::XNumberFormats> xNumberFormats = xNumberFormatsSupplier->getNumberFormats();
 292     uno::Reference<util::XNumberFormatTypes> xNumberFormatTypes(xNumberFormats, UNO_QUERY_THROW);
 293     lang::Locale aLocale;
 294     sal_Int32 nDateKey = xNumberFormatTypes->getStandardFormat(util::NumberFormat::DATE, aLocale);
 295     uno::Reference<table::XCellRange> xCellRange = xSheet->getCellRangeByPosition(nEndCol, 1, nEndCol, nEndRow);
 296     uno::Reference<beans::XPropertySet> xCellProp(xCellRange, UNO_QUERY_THROW);
 297     xCellProp->setPropertyValue("NumberFormat", uno::Any(nDateKey));
 298
 299     table::CellRangeAddress sCellRangeAddress;
 300     sCellRangeAddress.Sheet = 0;
 301     sCellRangeAddress.StartColumn = 0;
 302     sCellRangeAddress.StartRow = 0;
 303     sCellRangeAddress.EndColumn = nEndCol;
 304     sCellRangeAddress.EndRow = nEndRow;
 305
 306     return sCellRangeAddress;
 307 }
 308
 309 } // end anonymous namespace
 310
 311 void PivotChartTest::testRoundtrip()
 312 {
 313     uno::Sequence<uno::Any> xSequence;
 314     Reference<chart2::XChartDocument> xChartDoc;
 315
 316     std::vector<double> aReference1 { 10162.033139, 16614.523063, 27944.146101 };
 317
 318     std::vector<double> aReference2 { 101879.458079, 178636.929704, 314626.484864 };
 319
 320     loadFromFile(u"ods/PivotChartRoundTrip.ods");
 321
 322     xChartDoc = getPivotChartDocFromSheet(1, mxComponent);
 323     CPPUNIT_ASSERT(xChartDoc.is());
 324
 325     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), getNumberOfDataSeries(xChartDoc));
 326
 327     // Check the data series
 328     {
 329         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 330         lclCheckSequence(aReference1, xSequence, 1E-4);
 331         CPPUNIT_ASSERT_EQUAL(OUString("Exp."), lclGetLabel(xChartDoc, 0));
 332     }
 333     {
 334         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 1)->getData();
 335         lclCheckSequence(aReference2, xSequence, 1E-4);
 336         CPPUNIT_ASSERT_EQUAL(OUString("Rev."), lclGetLabel(xChartDoc, 1));
 337     }
 338
 339     // Modify the pivot table
 340     {
 341         uno::Reference<sheet::XDataPilotTable> xDataPilotTable = lclGetPivotTableByName(1, "DataPilot1", mxComponent);
 342         uno::Reference<sheet::XDataPilotDescriptor> xDataPilotDescriptor(xDataPilotTable, UNO_QUERY_THROW);
 343         lclModifyOrientation(xDataPilotDescriptor, u"Exp.", sheet::DataPilotFieldOrientation_HIDDEN);
 344     }
 345
 346     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), getNumberOfDataSeries(xChartDoc));
 347
 348     // Check again the data series
 349     {
 350         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 351         lclCheckSequence(aReference2, xSequence, 1E-4);
 352         CPPUNIT_ASSERT_EQUAL(OUString("Total"), lclGetLabel(xChartDoc, 0));
 353     }
 354
 355     saveAndReload("calc8");
 356
 357     xChartDoc = getPivotChartDocFromSheet(1, mxComponent);
 358     CPPUNIT_ASSERT(xChartDoc.is());
 359
 360     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), getNumberOfDataSeries(xChartDoc));
 361
 362     // Check again the data series
 363     {
 364         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 365         lclCheckSequence(aReference2, xSequence, 1E-4);
 366         CPPUNIT_ASSERT_EQUAL(OUString("Total"), lclGetLabel(xChartDoc, 0));
 367     }
 368 }
 369
 370 void PivotChartTest::testChangePivotTable()
 371 {
 372     uno::Sequence<uno::Any> xSequence;
 373     Reference<chart2::XChartDocument> xChartDoc;
 374
 375     loadFromFile(u"ods/PivotTableExample.ods");
 376
 377     // Check we have the Pivot Table
 378     OUString sPivotTableName("DataPilot1");
 379     uno::Reference<sheet::XDataPilotTable> xDataPilotTable = lclGetPivotTableByName(1, sPivotTableName, mxComponent);
 380     CPPUNIT_ASSERT(xDataPilotTable.is());
 381
 382     // Check that we don't have any pivot chart in the document
 383     uno::Reference<table::XTablePivotCharts> xTablePivotCharts = getTablePivotChartsFromSheet(1, mxComponent);
 384     uno::Reference<container::XIndexAccess> xIndexAccess(xTablePivotCharts, UNO_QUERY_THROW);
 385     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xIndexAccess->getCount());
 386
 387     // Create a new pivot chart
 388     xTablePivotCharts->addNewByName("Chart", awt::Rectangle{0, 0, 9000, 9000}, sPivotTableName);
 389     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
 390
 391     // Get the pivot chart document so we can access its data
 392     xChartDoc.set(getPivotChartDocFromSheet(xTablePivotCharts, 0));
 393
 394     CPPUNIT_ASSERT(xChartDoc.is());
 395
 396     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), getNumberOfDataSeries(xChartDoc));
 397
 398     // Check first data series
 399     {
 400         std::vector<double> aReference { 10162.033139, 16614.523063, 27944.146101 };
 401
 402         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 403         lclCheckSequence(aReference, xSequence, 1E-4);
 404
 405         CPPUNIT_ASSERT_EQUAL(OUString("Exp."), lclGetLabel(xChartDoc, 0));
 406     }
 407
 408     // Check second data series
 409     {
 410         std::vector<double> aReference { 101879.458079, 178636.929704, 314626.484864 };
 411
 412         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 1)->getData();
 413         lclCheckSequence(aReference, xSequence, 1E-4);
 414
 415         CPPUNIT_ASSERT_EQUAL(OUString("Rev."), lclGetLabel(xChartDoc, 1));
 416     }
 417
 418     // Modify the pivot table, move "Group Segment" to Column fields,
 419     // add "Service Month" to Row fields, remove "Rev." Data field
 420     {
 421         uno::Reference<sheet::XDataPilotDescriptor> xDataPilotDescriptor(xDataPilotTable, UNO_QUERY_THROW);
 422
 423         lclModifyOrientation(xDataPilotDescriptor, u"Service Month", sheet::DataPilotFieldOrientation_ROW);
 424         lclModifyOrientation(xDataPilotDescriptor, u"Group Segment", sheet::DataPilotFieldOrientation_COLUMN);
 425         lclModifyOrientation(xDataPilotDescriptor, u"Rev.", sheet::DataPilotFieldOrientation_HIDDEN);
 426     }
 427
 428     // Check the pivot chart again as we expect it has been updated when we updated the pivot table
 429
 430     CPPUNIT_ASSERT_EQUAL(sal_Int32(3), getNumberOfDataSeries(xChartDoc));
 431
 432     // Check the first data series
 433     {
 434         std::vector<double> aReference { 2855.559, 1780.326, 2208.713, 2130.064, 1187.371 };
 435
 436         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 437         lclCheckSequence(aReference, xSequence, 1E-3);
 438
 439         CPPUNIT_ASSERT_EQUAL(OUString("Big"), lclGetLabel(xChartDoc, 0));
 440     }
 441
 442     // Check the second data series
 443     {
 444         std::vector<double> aReference { 4098.908, 2527.286, 4299.716, 2362.225, 3326.389 };
 445
 446         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 1)->getData();
 447         lclCheckSequence(aReference, xSequence, 1E-3);
 448
 449         CPPUNIT_ASSERT_EQUAL(OUString("Medium"), lclGetLabel(xChartDoc, 1));
 450     }
 451
 452     // Check the third data series
 453     {
 454         std::vector<double> aReference { 4926.303, 5684.060, 4201.398, 7290.795, 5841.591 };
 455
 456         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 2)->getData();
 457         lclCheckSequence(aReference, xSequence, 1E-3);
 458
 459         CPPUNIT_ASSERT_EQUAL(OUString("Small"), lclGetLabel(xChartDoc, 2));
 460     }
 461
 462     // Remove "Service Month" so row fields are empty - check we handle empty rows
 463     {
 464         uno::Reference<sheet::XDataPilotDescriptor> xDataPilotDescriptor(xDataPilotTable, uno::UNO_QUERY_THROW);
 465         lclModifyOrientation(xDataPilotDescriptor, u"Service Month", sheet::DataPilotFieldOrientation_HIDDEN);
 466     }
 467
 468     // Check the pivot chart again as we expect it has been updated when we updated the pivot table
 469
 470     CPPUNIT_ASSERT_EQUAL(sal_Int32(3), getNumberOfDataSeries(xChartDoc));
 471
 472     // Check the first data series
 473     {
 474         std::vector<double> aReference { 10162.033139 };
 475         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 476         lclCheckSequence(aReference, xSequence, 1E-3);
 477         CPPUNIT_ASSERT_EQUAL(OUString("Big"), lclGetLabel(xChartDoc, 0));
 478     }
 479     // Check the second data series
 480     {
 481         std::vector<double> aReference { 16614.523063 };
 482         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 1)->getData();
 483         lclCheckSequence(aReference, xSequence, 1E-3);
 484         CPPUNIT_ASSERT_EQUAL(OUString("Medium"), lclGetLabel(xChartDoc, 1));
 485     }
 486     // Check the third data series
 487     {
 488         std::vector<double> aReference { 27944.146101 };
 489         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 2)->getData();
 490         lclCheckSequence(aReference, xSequence, 1E-3);
 491         CPPUNIT_ASSERT_EQUAL(OUString("Small"), lclGetLabel(xChartDoc, 2));
 492     }
 493
 494     // Enable column totals and check the data is still unchanged
 495     {
 496         uno::Reference<beans::XPropertySet> xProperties(xDataPilotTable, uno::UNO_QUERY_THROW);
 497         xProperties->setPropertyValue("ColumnGrand", uno::Any(true));
 498     }
 499
 500     CPPUNIT_ASSERT_EQUAL(sal_Int32(3), getNumberOfDataSeries(xChartDoc));
 501
 502     // Check the first data series
 503     {
 504         std::vector<double> aReference { 10162.033139 };
 505         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 506         lclCheckSequence(aReference, xSequence, 1E-3);
 507         CPPUNIT_ASSERT_EQUAL(OUString("Big"), lclGetLabel(xChartDoc, 0));
 508     }
 509     // Check the second data series
 510     {
 511         std::vector<double> aReference { 16614.523063 };
 512         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 1)->getData();
 513         lclCheckSequence(aReference, xSequence, 1E-3);
 514         CPPUNIT_ASSERT_EQUAL(OUString("Medium"), lclGetLabel(xChartDoc, 1));
 515     }
 516     // Check the third data series
 517     {
 518         std::vector<double> aReference { 27944.146101 };
 519         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 2)->getData();
 520         lclCheckSequence(aReference, xSequence, 1E-3);
 521         CPPUNIT_ASSERT_EQUAL(OUString("Small"), lclGetLabel(xChartDoc, 2));
 522     }
 523 }
 524
 525 void PivotChartTest::testPivotChartWithOneColumnField()
 526 {
 527     // We put one field as COLUMN field only and one DATA field. We expect we will get as many data series
 528     // in the pivot table as many distinct column values we have (with this example data 3: DE, EN, FR).
 529
 530     // SETUP DATA and PIVOT TABLE
 531
 532     mxComponent = loadFromDesktop("private:factory/scalc");
 533
 534     uno::Reference<sheet::XSpreadsheetDocument> xSheetDoc(mxComponent, uno::UNO_QUERY_THROW);
 535
 536     OUString sPivotTableName("DataPilotTable");
 537
 538     table::CellRangeAddress sCellRangeAddress = lclCreateTestData(xSheetDoc);
 539
 540     uno::Reference<sheet::XDataPilotTables> xDataPilotTables = lclGetDataPilotTables(0, xSheetDoc);
 541
 542     uno::Reference<sheet::XDataPilotDescriptor> xDataPilotDescriptor = xDataPilotTables->createDataPilotDescriptor();
 543     xDataPilotDescriptor->setSourceRange(sCellRangeAddress);
 544
 545     lclModifyOrientation(xDataPilotDescriptor, u"Country", sheet::DataPilotFieldOrientation_COLUMN);
 546     lclModifyOrientation(xDataPilotDescriptor, u"Sales T1", sheet::DataPilotFieldOrientation_DATA);
 547     lclModifyFunction(xDataPilotDescriptor, u"Sales T1", sheet::GeneralFunction_SUM);
 548
 549     xDataPilotTables->insertNewByName(sPivotTableName, table::CellAddress{1, 0, 0}, xDataPilotDescriptor);
 550
 551     // TEST
 552
 553     uno::Sequence<uno::Any> xSequence;
 554     Reference<chart2::XChartDocument> xChartDoc;
 555
 556     // Check we have the Pivot Table
 557
 558     uno::Reference<sheet::XDataPilotTable> xDataPilotTable = lclGetPivotTableByName(1, sPivotTableName, mxComponent);
 559     CPPUNIT_ASSERT(xDataPilotTable.is());
 560
 561     // Check that we don't have any pivot chart in the document
 562     uno::Reference<table::XTablePivotCharts> xTablePivotCharts = getTablePivotChartsFromSheet(1, mxComponent);
 563     uno::Reference<container::XIndexAccess> xIndexAccess(xTablePivotCharts, UNO_QUERY_THROW);
 564     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xIndexAccess->getCount());
 565
 566     // Create a new pivot chart
 567     xTablePivotCharts->addNewByName("PivotChart", awt::Rectangle{ 9000, 9000, 21000, 18000 }, sPivotTableName);
 568     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
 569
 570     // Get the pivot chart document so we can access its data
 571     xChartDoc.set(getPivotChartDocFromSheet(xTablePivotCharts, 0));
 572
 573     CPPUNIT_ASSERT(xChartDoc.is());
 574
 575     CPPUNIT_ASSERT_EQUAL(sal_Int32(3), getNumberOfDataSeries(xChartDoc));
 576     // Check data series 1
 577     {
 578         std::vector<double> aReference { 1738.0 };
 579
 580         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 581         lclCheckSequence(aReference, xSequence, 1E-4);
 582
 583         CPPUNIT_ASSERT_EQUAL(OUString("DE"), lclGetLabel(xChartDoc, 0));
 584     }
 585
 586     // Check data series 2
 587     {
 588         std::vector<double> aReference { 2003.0 };
 589
 590         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 1)->getData();
 591         lclCheckSequence(aReference, xSequence, 1E-4);
 592
 593         CPPUNIT_ASSERT_EQUAL(OUString("EN"), lclGetLabel(xChartDoc, 1));
 594     }
 595     // Check data series 3
 596     {
 597         std::vector<double> aReference { 1936.0 };
 598
 599         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 2)->getData();
 600         lclCheckSequence(aReference, xSequence, 1E-4);
 601
 602         CPPUNIT_ASSERT_EQUAL(OUString("FR"), lclGetLabel(xChartDoc, 2));
 603     }
 604 }
 605
 606 void PivotChartTest::testPivotChartWithOneRowField()
 607 {
 608     // We put one field as ROW field only and one DATA field. We expect we will get one data series
 609     // in the pivot table.
 610
 611     // SETUP DATA and PIVOT TABLE
 612
 613     mxComponent = loadFromDesktop("private:factory/scalc");
 614
 615     uno::Reference<sheet::XSpreadsheetDocument> xSheetDoc(mxComponent, uno::UNO_QUERY_THROW);
 616
 617     OUString sPivotTableName("DataPilotTable");
 618
 619     table::CellRangeAddress sCellRangeAddress = lclCreateTestData(xSheetDoc);
 620
 621     uno::Reference<sheet::XDataPilotTables> xDataPilotTables = lclGetDataPilotTables(0, xSheetDoc);
 622
 623     uno::Reference<sheet::XDataPilotDescriptor> xDataPilotDescriptor = xDataPilotTables->createDataPilotDescriptor();
 624     xDataPilotDescriptor->setSourceRange(sCellRangeAddress);
 625
 626     lclModifyOrientation(xDataPilotDescriptor, u"Country", sheet::DataPilotFieldOrientation_ROW);
 627     lclModifyOrientation(xDataPilotDescriptor, u"Sales T1", sheet::DataPilotFieldOrientation_DATA);
 628     lclModifyFunction(xDataPilotDescriptor, u"Sales T1", sheet::GeneralFunction_SUM);
 629
 630     xDataPilotTables->insertNewByName(sPivotTableName, table::CellAddress{1, 0, 0}, xDataPilotDescriptor);
 631
 632     // TEST
 633
 634     uno::Sequence<uno::Any> xSequence;
 635     Reference<chart2::XChartDocument> xChartDoc;
 636
 637     // Check we have the Pivot Table
 638
 639     uno::Reference<sheet::XDataPilotTable> xDataPilotTable = lclGetPivotTableByName(1, sPivotTableName, mxComponent);
 640     CPPUNIT_ASSERT(xDataPilotTable.is());
 641
 642     // Check that we don't have any pivot chart in the document
 643     uno::Reference<table::XTablePivotCharts> xTablePivotCharts = getTablePivotChartsFromSheet(1, mxComponent);
 644     uno::Reference<container::XIndexAccess> xIndexAccess(xTablePivotCharts, UNO_QUERY_THROW);
 645     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xIndexAccess->getCount());
 646
 647     // Create a new pivot chart
 648     xTablePivotCharts->addNewByName("PivotChart", awt::Rectangle{ 9000, 9000, 21000, 18000 }, sPivotTableName);
 649     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
 650
 651     // Get the pivot chart document so we can access its data
 652     xChartDoc.set(getPivotChartDocFromSheet(xTablePivotCharts, 0));
 653
 654     CPPUNIT_ASSERT(xChartDoc.is());
 655
 656     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), getNumberOfDataSeries(xChartDoc));
 657     // Check data series 1
 658     {
 659         std::vector<double> aReference { 1738.0, 2003.0, 1936.0 };
 660
 661         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 662         lclCheckSequence(aReference, xSequence, 1E-4);
 663
 664         CPPUNIT_ASSERT_EQUAL(OUString("Total"), lclGetLabel(xChartDoc, 0));
 665     }
 666 }
 667
 668 void PivotChartTest::testPivotTableDataProvider_PivotTableFields()
 669 {
 670     // SETUP DATA and PIVOT TABLE
 671
 672     mxComponent = loadFromDesktop("private:factory/scalc");
 673
 674     uno::Reference<sheet::XSpreadsheetDocument> xSheetDoc(mxComponent, uno::UNO_QUERY_THROW);
 675
 676     OUString sPivotTableName("DataPilotTable");
 677
 678     table::CellRangeAddress sCellRangeAddress = lclCreateTestData(xSheetDoc);
 679
 680     uno::Reference<sheet::XDataPilotTables> xDataPilotTables = lclGetDataPilotTables(0, xSheetDoc);
 681
 682     uno::Reference<sheet::XDataPilotDescriptor> xDataPilotDescriptor = xDataPilotTables->createDataPilotDescriptor();
 683     xDataPilotDescriptor->setSourceRange(sCellRangeAddress);
 684
 685     lclModifyOrientation(xDataPilotDescriptor, u"City", sheet::DataPilotFieldOrientation_ROW);
 686     lclModifyOrientation(xDataPilotDescriptor, u"Country", sheet::DataPilotFieldOrientation_COLUMN);
 687     lclModifyOrientation(xDataPilotDescriptor, u"Type", sheet::DataPilotFieldOrientation_COLUMN);
 688     lclModifyOrientation(xDataPilotDescriptor, u"Sales T1", sheet::DataPilotFieldOrientation_DATA);
 689     lclModifyFunction(xDataPilotDescriptor, u"Sales T1", sheet::GeneralFunction_SUM);
 690     lclModifyOrientation(xDataPilotDescriptor, u"Sales T2", sheet::DataPilotFieldOrientation_DATA);
 691     lclModifyFunction(xDataPilotDescriptor, u"Sales T2", sheet::GeneralFunction_SUM);
 692
 693     lclModifyColumnGrandTotal(xDataPilotDescriptor, true);
 694     lclModifyRowGrandTotal(xDataPilotDescriptor, true);
 695
 696     xDataPilotTables->insertNewByName(sPivotTableName, table::CellAddress{1, 0, 0}, xDataPilotDescriptor);
 697
 698     // TEST
 699     Reference<chart2::XChartDocument> xChartDoc;
 700
 701     // Check we have the Pivot Table
 702     uno::Reference<sheet::XDataPilotTable> xDataPilotTable = lclGetPivotTableByName(1, sPivotTableName, mxComponent);
 703     CPPUNIT_ASSERT(xDataPilotTable.is());
 704
 705     // refetch the XDataPilotDescriptor
 706     xDataPilotDescriptor.set(xDataPilotTable, uno::UNO_QUERY_THROW);
 707
 708     // Check that we don't have any pivot chart in the document
 709     uno::Reference<table::XTablePivotCharts> xTablePivotCharts = getTablePivotChartsFromSheet(1, mxComponent);
 710     uno::Reference<container::XIndexAccess> xIndexAccess(xTablePivotCharts, UNO_QUERY_THROW);
 711     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xIndexAccess->getCount());
 712
 713     // Create a new pivot chart
 714     xTablePivotCharts->addNewByName("PivotChart", awt::Rectangle{ 9000, 9000, 21000, 18000 }, sPivotTableName);
 715     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
 716
 717     // Get the pivot chart document so we can access its data
 718     xChartDoc.set(getPivotChartDocFromSheet(xTablePivotCharts, 0));
 719
 720     CPPUNIT_ASSERT(xChartDoc.is());
 721
 722     uno::Reference<chart2::data::XPivotTableDataProvider> xPivotTableDataProvider(xChartDoc->getDataProvider(), UNO_QUERY_THROW);
 723     uno::Sequence<chart2::data::PivotTableFieldEntry> aFieldEntries;
 724
 725     aFieldEntries = xPivotTableDataProvider->getColumnFields();
 726
 727     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), aFieldEntries.getLength());
 728     CPPUNIT_ASSERT_EQUAL(OUString("Country"), aFieldEntries[0].Name);
 729     CPPUNIT_ASSERT_EQUAL(OUString("Type"), aFieldEntries[1].Name);
 730
 731     aFieldEntries = xPivotTableDataProvider->getRowFields();
 732
 733     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), aFieldEntries.getLength());
 734     CPPUNIT_ASSERT_EQUAL(OUString("City"), aFieldEntries[0].Name);
 735     CPPUNIT_ASSERT_EQUAL(OUString("Data"), aFieldEntries[1].Name);
 736
 737     aFieldEntries = xPivotTableDataProvider->getDataFields();
 738
 739     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), aFieldEntries.getLength());
 740     CPPUNIT_ASSERT_EQUAL(OUString("Sum - Sales T1"), aFieldEntries[0].Name);
 741     CPPUNIT_ASSERT_EQUAL(OUString("Sum - Sales T2"), aFieldEntries[1].Name);
 742
 743     // Data to column fields
 744     lclModifyOrientation(xDataPilotDescriptor, u"Data", sheet::DataPilotFieldOrientation_COLUMN);
 745
 746     // Change the order of column fields: expected data, type, country
 747     lclModifyOrientation(xDataPilotDescriptor, u"Country", sheet::DataPilotFieldOrientation_HIDDEN);
 748     lclModifyOrientation(xDataPilotDescriptor, u"Type", sheet::DataPilotFieldOrientation_HIDDEN);
 749
 750     lclModifyOrientation(xDataPilotDescriptor, u"Type", sheet::DataPilotFieldOrientation_COLUMN);
 751     lclModifyOrientation(xDataPilotDescriptor, u"Country", sheet::DataPilotFieldOrientation_COLUMN);
 752
 753     // set the XPivotTableDataProvider again as the old one was exchanged
 754     xPivotTableDataProvider.set(xChartDoc->getDataProvider(), uno::UNO_QUERY_THROW);
 755
 756     aFieldEntries = xPivotTableDataProvider->getColumnFields();
 757
 758     CPPUNIT_ASSERT_EQUAL(sal_Int32(3), aFieldEntries.getLength());
 759     CPPUNIT_ASSERT_EQUAL(OUString("Data"), aFieldEntries[0].Name);
 760     CPPUNIT_ASSERT_EQUAL(OUString("Type"), aFieldEntries[1].Name);
 761     CPPUNIT_ASSERT_EQUAL(OUString("Country"), aFieldEntries[2].Name);
 762
 763     aFieldEntries = xPivotTableDataProvider->getRowFields();
 764
 765     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), aFieldEntries.getLength());
 766     CPPUNIT_ASSERT_EQUAL(OUString("City"), aFieldEntries[0].Name);
 767
 768     aFieldEntries = xPivotTableDataProvider->getDataFields();
 769
 770     CPPUNIT_ASSERT_EQUAL(sal_Int32(2), aFieldEntries.getLength());
 771     CPPUNIT_ASSERT_EQUAL(OUString("Sum - Sales T1"), aFieldEntries[0].Name);
 772     CPPUNIT_ASSERT_EQUAL(OUString("Sum - Sales T2"), aFieldEntries[1].Name);
 773 }
 774
 775 void PivotChartTest::testPivotChartRowFieldInOutlineMode()
 776 {
 777     // SETUP DATA and PIVOT TABLE
 778
 779     mxComponent = loadFromDesktop("private:factory/scalc");
 780
 781     uno::Reference<sheet::XSpreadsheetDocument> xSheetDoc(mxComponent, uno::UNO_QUERY_THROW);
 782
 783     OUString sPivotTableName("DataPilotTable");
 784
 785     table::CellRangeAddress sCellRangeAddress = lclCreateTestData(xSheetDoc);
 786
 787     uno::Reference<sheet::XDataPilotTables> xDataPilotTables = lclGetDataPilotTables(0, xSheetDoc);
 788
 789     uno::Reference<sheet::XDataPilotDescriptor> xDataPilotDescriptor = xDataPilotTables->createDataPilotDescriptor();
 790     xDataPilotDescriptor->setSourceRange(sCellRangeAddress);
 791
 792     lclModifyOrientation(xDataPilotDescriptor, u"Country", sheet::DataPilotFieldOrientation_ROW);
 793     lclModifyOrientation(xDataPilotDescriptor, u"City", sheet::DataPilotFieldOrientation_ROW);
 794     lclModifyOrientation(xDataPilotDescriptor, u"Sales T1", sheet::DataPilotFieldOrientation_DATA);
 795     lclModifyFunction(xDataPilotDescriptor, u"Sales T1", sheet::GeneralFunction_SUM);
 796     xDataPilotTables->insertNewByName(sPivotTableName, table::CellAddress{1, 0, 0}, xDataPilotDescriptor);
 797
 798     // TEST
 799     uno::Sequence<uno::Any> xSequence;
 800     Reference<chart2::XChartDocument> xChartDoc;
 801
 802     // Check we have the Pivot Table
 803     uno::Reference<sheet::XDataPilotTable> xDataPilotTable = lclGetPivotTableByName(1, sPivotTableName, mxComponent);
 804     CPPUNIT_ASSERT(xDataPilotTable.is());
 805
 806     // refetch the XDataPilotDescriptor
 807     xDataPilotDescriptor.set(xDataPilotTable, uno::UNO_QUERY_THROW);
 808
 809     // Check that we don't have any pivot chart in the document
 810     uno::Reference<table::XTablePivotCharts> xTablePivotCharts = getTablePivotChartsFromSheet(1, mxComponent);
 811     uno::Reference<container::XIndexAccess> xIndexAccess(xTablePivotCharts, UNO_QUERY_THROW);
 812     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xIndexAccess->getCount());
 813
 814     // Create a new pivot chart
 815     xTablePivotCharts->addNewByName("PivotChart", awt::Rectangle{ 9000, 9000, 21000, 18000 }, sPivotTableName);
 816     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
 817
 818     // Get the pivot chart document so we can access its data
 819     xChartDoc.set(getPivotChartDocFromSheet(xTablePivotCharts, 0));
 820
 821     CPPUNIT_ASSERT(xChartDoc.is());
 822
 823     // Test case with defaults
 824
 825     // Check when using defaults the data is as expected
 826     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), getNumberOfDataSeries(xChartDoc));
 827     {
 828         std::vector<double> aReference { 1116.0, 622.0, 298.0, 562.0, 1143.0, 1168.0, 768.0 };
 829
 830         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 831         lclCheckSequence(aReference, xSequence, 1E-4);
 832
 833         CPPUNIT_ASSERT_EQUAL(OUString("Total"), lclGetLabel(xChartDoc, 0));
 834     }
 835     // Check the categories
 836     {
 837         lclCheckCategories({ "DE", "", "EN", "", "", "FR", ""},
 838                            lclGetCategories(xChartDoc)[0]->getValues());
 839         lclCheckCategories({ "Berlin", "Munich", "Glasgow", "Liverpool", "London", "Nantes", "Paris"},
 840                            lclGetCategories(xChartDoc)[1]->getValues());
 841     }
 842
 843     sheet::DataPilotFieldLayoutInfo aLayoutInfoValue;
 844
 845     // Test case where we enable subtotals (auto) and set the outline subtotals at the bottom
 846     // We don't expect any change in data as every extra subtotal row should be ignored
 847
 848     // Enable subtotals - set to auto
 849     uno::Sequence<sheet::GeneralFunction> aGeneralFunctionSequence{ sheet::GeneralFunction_AUTO };
 850     lclModifySubtotals(xDataPilotDescriptor, u"Country", aGeneralFunctionSequence);
 851     // Set Subtotals layout to bottom + add empty lines
 852     aLayoutInfoValue.AddEmptyLines = true;
 853     aLayoutInfoValue.LayoutMode = sheet::DataPilotFieldLayoutMode::OUTLINE_SUBTOTALS_BOTTOM;
 854     lclModifyLayoutInfo(xDataPilotDescriptor, u"Country", aLayoutInfoValue);
 855
 856     // Check data is unchanged
 857     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), getNumberOfDataSeries(xChartDoc));
 858     {
 859         std::vector<double> aReference { 1116.0, 622.0, 298.0, 562.0, 1143.0, 1168.0, 768.0 };
 860
 861         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 862         lclCheckSequence(aReference, xSequence, 1E-4);
 863
 864         CPPUNIT_ASSERT_EQUAL(OUString("Total"), lclGetLabel(xChartDoc, 0));
 865     }
 866     // Check categories
 867     {
 868         lclCheckCategories({ "DE", "", "EN", "", "", "FR", ""},
 869                            lclGetCategories(xChartDoc)[0]->getValues());
 870         lclCheckCategories({ "Berlin", "Munich", "Glasgow", "Liverpool", "London", "Nantes", "Paris"},
 871                            lclGetCategories(xChartDoc)[1]->getValues());
 872     }
 873
 874     // Test case where we enable subtotals (auto) and set the outline subtotals at the top
 875     // We don't expect any change in data as every extra subtotal row should be ignored
 876
 877     // Enable subtotals - set to auto
 878     aGeneralFunctionSequence.getArray()[0] = sheet::GeneralFunction_AUTO;
 879     lclModifySubtotals(xDataPilotDescriptor, u"Country", aGeneralFunctionSequence);
 880     // Set Subtotals layout to top + add empty lines
 881     aLayoutInfoValue.AddEmptyLines = true;
 882     aLayoutInfoValue.LayoutMode = sheet::DataPilotFieldLayoutMode::OUTLINE_SUBTOTALS_TOP;
 883     lclModifyLayoutInfo(xDataPilotDescriptor, u"Country", aLayoutInfoValue);
 884
 885     // Check data is unchanged
 886     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), getNumberOfDataSeries(xChartDoc));
 887     {
 888         std::vector<double> aReference { 1116.0, 622.0, 298.0, 562.0, 1143.0, 1168.0, 768.0 };
 889
 890         xSequence = getDataSequenceFromDocByRole(xChartDoc, u"values-y", 0)->getData();
 891         lclCheckSequence(aReference, xSequence, 1E-4);
 892
 893         CPPUNIT_ASSERT_EQUAL(OUString("Total"), lclGetLabel(xChartDoc, 0));
 894     }
 895     // Check categories
 896     {
 897         lclCheckCategories({ "DE", "", "EN", "", "", "FR", ""},
 898                            lclGetCategories(xChartDoc)[0]->getValues());
 899         lclCheckCategories({ "Berlin", "Munich", "Glasgow", "Liverpool", "London", "Nantes", "Paris"},
 900                            lclGetCategories(xChartDoc)[1]->getValues());
 901     }
 902 }
 903
 904 void PivotChartTest::testPivotChartWithDateRowField()
 905 {
 906     // SETUP DATA and PIVOT TABLE
 907
 908     mxComponent = loadFromDesktop("private:factory/scalc");
 909
 910     uno::Reference<sheet::XSpreadsheetDocument> xSheetDoc(mxComponent, uno::UNO_QUERY_THROW);
 911
 912     OUString sPivotTableName("DataPilotTable");
 913
 914     table::CellRangeAddress sCellRangeAddress = lclCreateTestData(xSheetDoc);
 915
 916     uno::Reference<sheet::XDataPilotTables> xDataPilotTables = lclGetDataPilotTables(0, xSheetDoc);
 917
 918     uno::Reference<sheet::XDataPilotDescriptor> xDataPilotDescriptor = xDataPilotTables->createDataPilotDescriptor();
 919     xDataPilotDescriptor->setSourceRange(sCellRangeAddress);
 920
 921     lclModifyOrientation(xDataPilotDescriptor, u"Date", sheet::DataPilotFieldOrientation_ROW);
 922     lclModifyOrientation(xDataPilotDescriptor, u"City", sheet::DataPilotFieldOrientation_ROW);
 923     lclModifyOrientation(xDataPilotDescriptor, u"Country", sheet::DataPilotFieldOrientation_ROW);
 924     lclModifyOrientation(xDataPilotDescriptor, u"Type", sheet::DataPilotFieldOrientation_COLUMN);
 925     lclModifyOrientation(xDataPilotDescriptor, u"Sales T1", sheet::DataPilotFieldOrientation_DATA);
 926     lclModifyFunction(xDataPilotDescriptor, u"Sales T1", sheet::GeneralFunction_SUM);
 927
 928     lclModifyColumnGrandTotal(xDataPilotDescriptor, true);
 929     lclModifyRowGrandTotal(xDataPilotDescriptor, true);
 930
 931     xDataPilotTables->insertNewByName(sPivotTableName, table::CellAddress{1, 0, 0}, xDataPilotDescriptor);
 932
 933     // TEST
 934     Reference<chart2::XChartDocument> xChartDoc;
 935
 936     // Check we have the Pivot Table
 937     uno::Reference<sheet::XDataPilotTable> xDataPilotTable = lclGetPivotTableByName(1, sPivotTableName, mxComponent);
 938     CPPUNIT_ASSERT(xDataPilotTable.is());
 939
 940     // refetch the XDataPilotDescriptor
 941     xDataPilotDescriptor.set(xDataPilotTable, uno::UNO_QUERY_THROW);
 942
 943     // Check that we don't have any pivot chart in the document
 944     uno::Reference<table::XTablePivotCharts> xTablePivotCharts = getTablePivotChartsFromSheet(1, mxComponent);
 945     uno::Reference<container::XIndexAccess> xIndexAccess(xTablePivotCharts, UNO_QUERY_THROW);
 946     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xIndexAccess->getCount());
 947
 948     // Create a new pivot chart
 949     xTablePivotCharts->addNewByName("PivotChart", awt::Rectangle{ 9000, 9000, 21000, 18000 }, sPivotTableName);
 950     CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
 951
 952     // Get the pivot chart document so we can access its data
 953     xChartDoc.set(getPivotChartDocFromSheet(xTablePivotCharts, 0));
 954
 955     CPPUNIT_ASSERT(xChartDoc.is());
 956
 957     // Check if Date category is date formatted.
 958     lclCheckCategories( { "12/11/15", "", "", "", "", "", "12/14/15", "12/17/15", "01/20/16", "", "", "03/21/17" },
 959                         lclGetCategories( xChartDoc )[0]->getValues() );
 960 }
 961
 962
 963 CPPUNIT_TEST_SUITE_REGISTRATION(PivotChartTest);
 964
 965 CPPUNIT_PLUGIN_IMPLEMENT();
 966
 967 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */