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