chart2/qa/extras/chart2dump/chart2dump.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 #include <com/sun/star/chart2/XChartDocument.hpp>
  12 #include <com/sun/star/chart/XChartDocument.hpp>
  13 #include <com/sun/star/text/XText.hpp>
  14 #include <com/sun/star/drawing/HomogenMatrix3.hpp>
  15 #include <com/sun/star/drawing/LineDash.hpp>
  16 #include <com/sun/star/drawing/LineStyle.hpp>
  17 #include <com/sun/star/drawing/FillStyle.hpp>
  18
  19 #include <editeng/unoprnms.hxx>
  20 #include <rtl/ustring.hxx>
  21 #include <rtl/ustrbuf.hxx>
  22
  23 #include <fstream>
  24 #include <string_view>
  25
  26 #if defined(X86)
  27 #define INT_EPS     2.1
  28 #else
  29 #define INT_EPS     0.1
  30 #endif
  31
  32 #define DECLARE_DUMP_TEST(TestName, BaseClass, DumpMode) \
  33     class TestName : public BaseClass { \
  34         protected:\
  35             virtual OUString getTestName() override { return u"" #TestName ""_ustr; } \
  36         public:\
  37             TestName() : BaseClass(DumpMode) {}; \
  38             CPPUNIT_TEST_SUITE(TestName); \
  39             CPPUNIT_TEST(verify); \
  40             CPPUNIT_TEST_SUITE_END(); \
  41             virtual void verify() override;\
  42     };\
  43     CPPUNIT_TEST_SUITE_REGISTRATION(TestName); \
  44     void TestName::verify()
  45
  46
  47 #define CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(aActual) \
  48     if(isInDumpMode()) \
  49         writeActual(OUString::number(aActual), u"" #aActual ""_ustr); \
  50     else \
  51         { \
  52             OString sTestFileName = OUStringToOString(getTestFileName(), RTL_TEXTENCODING_UTF8); \
  53             CPPUNIT_ASSERT_EQUAL_MESSAGE(OString("Failing test file is: " + sTestFileName).getStr(), readExpected(u ## #aActual), OUString(OUString::number(aActual))); \
  54         }
  55
  56 #define CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aActual, EPS_) \
  57     if(isInDumpMode()) \
  58         writeActual(OUString::number(aActual), u"" #aActual ""_ustr); \
  59         else \
  60         { \
  61             OString sTestFileName = OUStringToOString(getTestFileName(), RTL_TEXTENCODING_UTF8); \
  62             CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(OString("Failing test file is: " + sTestFileName).getStr(), readExpectedDouble(u ## #aActual), aActual, EPS_); \
  63         }
  64
  65 #define CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(aActual) \
  66     if(isInDumpMode()) \
  67         writeActual(aActual, u"" #aActual ""_ustr); \
  68     else \
  69     { \
  70         OString sTestFileName = OUStringToOString(getTestFileName(), RTL_TEXTENCODING_UTF8); \
  71         CPPUNIT_ASSERT_EQUAL_MESSAGE(OString("Failing test file is: " + sTestFileName).getStr(), readExpected(u ## #aActual), aActual.trim()); \
  72     }
  73
  74 #define CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aActual, EPS_) \
  75     if(isInDumpMode()) \
  76         writeActualTransformation(aActual, u"" #aActual ""_ustr); \
  77     else \
  78     { \
  79         OUString expectedTransform; \
  80         if (!readAndCheckTransformation (aActual, u ## #aActual, EPS_, expectedTransform)) \
  81         { \
  82             OString sTestFileName = OUStringToOString(getTestFileName(), RTL_TEXTENCODING_UTF8); \
  83             CPPUNIT_ASSERT_EQUAL_MESSAGE(OString("Failing test file is: " + sTestFileName).getStr(), expectedTransform, transformationToOneLineString(aActual)); \
  84         } \
  85     }
  86
  87 class Chart2DumpTest : public ChartTest
  88 {
  89 protected:
  90     Chart2DumpTest(bool bDumpMode)
  91         : ChartTest("/chart2/qa/extras/chart2dump/data/")
  92     {
  93         m_bDumpMode = bDumpMode;
  94     }
  95
  96     virtual ~Chart2DumpTest() override
  97     {
  98     }
  99
 100     void CPPUNIT_DUMP_ASSERT_NOTE(OUString const & Note) {
 101         if(isInDumpMode())
 102             writeNote(Note);
 103         else
 104             readNote(Note);
 105     }
 106
 107     bool isInDumpMode () const {return m_bDumpMode;}
 108
 109     virtual OUString getTestName() { return OUString(); }
 110     OUString const & getTestFileName() const { return m_sTestFileName; }
 111     OUString getReferenceDirName()
 112     {
 113         return "/chart2/qa/extras/chart2dump/reference/" + getTestName().toAsciiLowerCase() + "/";
 114     }
 115
 116     void setTestFileName (const OUString& sName)
 117     {
 118         m_sTestFileName = sName;
 119
 120         OUString sFileName = m_sTestFileName;
 121         assert(sFileName.lastIndexOf('.') < sFileName.getLength());
 122         sFileName = OUString::Concat(sFileName.subView(0, sFileName.lastIndexOf('.'))) + ".txt";
 123         if (!m_bDumpMode)
 124         {
 125             if (m_aReferenceFile.is_open())
 126                 m_aReferenceFile.close();
 127             OString sReferenceFile = OUStringToOString(Concat2View(m_directories.getPathFromSrc(getReferenceDirName()) + sFileName), RTL_TEXTENCODING_UTF8);
 128             m_aReferenceFile.open(sReferenceFile.getStr(), std::ios_base::in);
 129             CPPUNIT_ASSERT_MESSAGE(OString("Can't open reference file: " + sReferenceFile).getStr(), m_aReferenceFile.is_open());
 130         }
 131         else
 132         {
 133             if (m_aDumpFile.is_open())
 134                 m_aDumpFile.close();
 135             OString sDumpFile = OUStringToOString(Concat2View(m_directories.getPathFromSrc(getReferenceDirName()) + sFileName), RTL_TEXTENCODING_UTF8);
 136             m_aDumpFile.open(sDumpFile.getStr(), std::ios_base::out | std::ofstream::binary | std::ofstream::trunc);
 137             CPPUNIT_ASSERT_MESSAGE(OString("Can't open dump file: " + sDumpFile).getStr(), m_aDumpFile.is_open());
 138         }
 139     }
 140
 141     virtual void verify()
 142     {
 143         CPPUNIT_FAIL("verify method must be overridden");
 144     }
 145
 146     OUString readExpected(std::u16string_view sCheck)
 147     {
 148         assert(!m_bDumpMode);
 149         assert(m_aReferenceFile.is_open());
 150         std::string sTemp;
 151         getline(m_aReferenceFile, sTemp);
 152         OString sAssertMessage =
 153             "The reference file does not contain the right content. Maybe it needs an update:"
 154             + OUStringToOString(m_sTestFileName, RTL_TEXTENCODING_UTF8);
 155         CPPUNIT_ASSERT_EQUAL_MESSAGE(sAssertMessage.getStr(), OUString(OUString::Concat("// ") + sCheck), OUString(sTemp.data(), sTemp.length(), RTL_TEXTENCODING_UTF8));
 156         getline(m_aReferenceFile, sTemp);
 157         return OUString(sTemp.data(), sTemp.length(), RTL_TEXTENCODING_UTF8);
 158     }
 159
 160     void writeActual(std::u16string_view sActualValue, const OUString& sCheck)
 161     {
 162         assert(m_bDumpMode);
 163         assert(m_aDumpFile.is_open());
 164         m_aDumpFile << "// " << sCheck << "\n";   // Add check string to make dump file readable
 165         m_aDumpFile << OUString(sActualValue) << "\n";      // Write out the checked value, will be used as reference later
 166     }
 167
 168     void readNote(std::u16string_view sNote)
 169     {
 170         assert(!m_bDumpMode);
 171         assert(m_aReferenceFile.is_open());
 172         std::string sTemp;
 173         getline(m_aReferenceFile, sTemp);
 174         OString sAssertMessage =
 175             "The reference file does not contain the right content. Maybe it needs an update:"
 176             + OUStringToOString(m_sTestFileName, RTL_TEXTENCODING_UTF8);
 177         CPPUNIT_ASSERT_EQUAL_MESSAGE(sAssertMessage.getStr(), OUString(OUString::Concat("/// ") + sNote), OUString(sTemp.data(), sTemp.length(), RTL_TEXTENCODING_UTF8));
 178     }
 179
 180     void writeNote(const OUString& sNote)
 181     {
 182         assert(m_bDumpMode);
 183         assert(m_aDumpFile.is_open());
 184         m_aDumpFile << "/// " << sNote << "\n";
 185     }
 186
 187     double readExpectedDouble(std::u16string_view sCheck)
 188     {
 189         OUString sExpected = readExpected(sCheck);
 190         return sExpected.toDouble();
 191     }
 192
 193     void writeActualTransformation(const drawing::HomogenMatrix3& rTransform, const OUString& sCheck)
 194     {
 195         writeActual(transformationToOneLineString(rTransform), sCheck);
 196     }
 197
 198     bool readAndCheckTransformation(const drawing::HomogenMatrix3& rTransform, std::u16string_view sCheck, const double fEPS, OUString& rExpectedTransform)
 199     {
 200         rExpectedTransform = readExpected(sCheck); // Reference transformation string
 201
 202         // Convert string back to a transformation;
 203         drawing::HomogenMatrix3 aExpectedTransform;
 204         sal_Int32 nIdx {0};
 205         aExpectedTransform.Line1.Column1 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 206         aExpectedTransform.Line1.Column2 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 207         aExpectedTransform.Line1.Column3 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 208         aExpectedTransform.Line2.Column1 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 209         aExpectedTransform.Line2.Column2 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 210         aExpectedTransform.Line2.Column3 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 211         aExpectedTransform.Line3.Column1 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 212         aExpectedTransform.Line3.Column2 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 213         aExpectedTransform.Line3.Column3 = o3tl::toDouble(o3tl::getToken(rExpectedTransform, 0, ';', nIdx));
 214
 215         // Check the equality of the two transformation
 216         return (std::abs(aExpectedTransform.Line1.Column1 - rTransform.Line1.Column1) < fEPS &&
 217             std::abs(aExpectedTransform.Line1.Column2 - rTransform.Line1.Column2) < fEPS &&
 218             std::abs(aExpectedTransform.Line1.Column3 - rTransform.Line1.Column3) < fEPS &&
 219             std::abs(aExpectedTransform.Line2.Column1 - rTransform.Line2.Column1) < fEPS &&
 220             std::abs(aExpectedTransform.Line2.Column2 - rTransform.Line2.Column2) < fEPS &&
 221             std::abs(aExpectedTransform.Line2.Column3 - rTransform.Line2.Column3) < fEPS &&
 222             std::abs(aExpectedTransform.Line3.Column1 - rTransform.Line3.Column1) < fEPS &&
 223             std::abs(aExpectedTransform.Line3.Column2 - rTransform.Line3.Column2) < fEPS &&
 224             std::abs(aExpectedTransform.Line3.Column3 - rTransform.Line3.Column3) < fEPS);
 225     }
 226
 227     OUString sequenceToOneLineString(const uno::Sequence<OUString>& rSeq)
 228     {
 229         OUStringBuffer aBuffer;
 230         for (const OUString& seqItem : rSeq)
 231         {
 232             aBuffer.append(seqItem + ";");
 233         }
 234         return aBuffer.makeStringAndClear();
 235     }
 236
 237     OUString doubleVectorToOneLineString(const std::vector<double>& rVector)
 238     {
 239         OUStringBuffer aBuffer;
 240         for (const double& vectorItem : rVector)
 241         {
 242             aBuffer.append(OUString::number(vectorItem) + ";");
 243         }
 244         return aBuffer.makeStringAndClear();
 245     }
 246
 247     OUString transformationToOneLineString(const drawing::HomogenMatrix3& rTransform)
 248     {
 249         return OUString::number(rTransform.Line1.Column1) + ";" + OUString::number(rTransform.Line1.Column2) + ";" + OUString::number(rTransform.Line1.Column3) + ";" +
 250             OUString::number(rTransform.Line2.Column1) + ";" + OUString::number(rTransform.Line2.Column2) + ";" + OUString::number(rTransform.Line2.Column3) + ";" +
 251             OUString::number(rTransform.Line3.Column1) + ";" + OUString::number(rTransform.Line3.Column2) + ";" + OUString::number(rTransform.Line3.Column3);
 252     }
 253
 254 private:
 255     OUString         m_sTestFileName;
 256     bool             m_bDumpMode;
 257     std::ifstream    m_aReferenceFile;
 258     std::ofstream    m_aDumpFile;
 259 };
 260
 261 DECLARE_DUMP_TEST(ChartDataTest, Chart2DumpTest, false)
 262 {
 263     const std::vector<OUString> aTestFiles =
 264     {
 265         "simple_chart.ods",
 266         "multiple_categories.ods"
 267     };
 268
 269     for (const OUString& aTestFile : aTestFiles)
 270     {
 271         setTestFileName(aTestFile);
 272         loadFromFile(getTestFileName());
 273         uno::Reference< chart::XChartDocument > xChartDoc (getChartDocFromSheet(0, mxComponent), UNO_QUERY_THROW);
 274
 275         // Check title
 276         uno::Reference< chart2::XChartDocument > xChartDoc2(xChartDoc, UNO_QUERY_THROW);
 277         Reference<chart2::XTitled> xTitled(xChartDoc, uno::UNO_QUERY_THROW);
 278         uno::Reference<chart2::XTitle> xTitle = xTitled->getTitleObject();
 279         if(xTitle.is())
 280         {
 281             OUString sChartTitle = getTitleString(xTitled);
 282             CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sChartTitle);
 283         }
 284
 285         // Check chart type
 286         Reference<chart2::XChartType> xChartType = getChartTypeFromDoc(xChartDoc2, 0);
 287         CPPUNIT_ASSERT(xChartType.is());
 288         OUString sChartType = xChartType->getChartType();
 289         CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sChartType);
 290
 291         // Check axis titles and number format
 292         // x Axis
 293         Reference<chart2::XAxis> xAxis = getAxisFromDoc(xChartDoc2, 0, 0, 0);
 294         Reference<chart2::XTitled> xAxisTitled(xAxis, UNO_QUERY_THROW);
 295         uno::Reference<chart2::XTitle> xAxisTitle = xAxisTitled->getTitleObject();
 296         if (xAxisTitle.is())
 297         {
 298             OUString sXAxisTitle = getTitleString(xAxisTitled);
 299             CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sXAxisTitle);
 300         }
 301         sal_Int32 nXAxisNumberFormat = getNumberFormatFromAxis(xAxis);
 302         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nXAxisNumberFormat);
 303         sal_Int16 nXAxisNumberType = getNumberFormatType(xChartDoc2, nXAxisNumberFormat);
 304         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nXAxisNumberType);
 305
 306         // y Axis
 307         xAxis.set(getAxisFromDoc(xChartDoc2, 0, 1, 0));
 308         xAxisTitled.set(xAxis, UNO_QUERY_THROW);
 309         xAxisTitle.set(xAxisTitled->getTitleObject());
 310         if (xAxisTitle.is())
 311         {
 312             OUString sYAxisTitle = getTitleString(xAxisTitled);
 313             CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sYAxisTitle);
 314         }
 315         sal_Int32 nYAxisNumberFormat = getNumberFormatFromAxis(xAxis);
 316         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nYAxisNumberFormat);
 317         sal_Int16 nYAxisNumberType = getNumberFormatType(xChartDoc2, nYAxisNumberFormat);
 318         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nYAxisNumberType);
 319
 320         // Check column labels
 321         uno::Reference< chart::XChartDataArray > xChartData(xChartDoc->getData(), UNO_QUERY_THROW);
 322         uno::Sequence < OUString > aColumnLabels = xChartData->getColumnDescriptions();
 323         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(aColumnLabels.getLength());
 324         OUString sColumnLabels = sequenceToOneLineString(aColumnLabels);
 325         CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sColumnLabels);
 326
 327         // Check row labels
 328         uno::Sequence< OUString > aRowLabels = xChartData->getRowDescriptions();
 329         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(aRowLabels.getLength());
 330         OUString sRowLabels = sequenceToOneLineString(aRowLabels);
 331         CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sRowLabels);
 332
 333         // Check Y values
 334         std::vector<std::vector<double> > aDataSeriesYValues = getDataSeriesYValuesFromChartType(xChartType);
 335         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(aDataSeriesYValues.size());
 336         for (const std::vector<double>& aYValuesOfSeries : aDataSeriesYValues)
 337         {
 338             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(aYValuesOfSeries.size());
 339             OUString sYValuesOfSeries = doubleVectorToOneLineString(aYValuesOfSeries);
 340             CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sYValuesOfSeries);
 341         }
 342
 343         // Check source ranges
 344         for (size_t nIndex = 0; nIndex < aDataSeriesYValues.size(); ++nIndex)
 345         {
 346             Reference< chart2::data::XDataSequence > xDataSeq = getDataSequenceFromDocByRole(xChartDoc2, u"values-x", nIndex);
 347             if (xDataSeq.is())
 348             {
 349                 OUString aXValuesSourceRange = xDataSeq->getSourceRangeRepresentation();
 350                 CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(aXValuesSourceRange);
 351             }
 352             xDataSeq.set(getDataSequenceFromDocByRole(xChartDoc2, u"values-y", nIndex));
 353             if (xDataSeq.is())
 354             {
 355                 OUString aYValuesSourceRange = xDataSeq->getSourceRangeRepresentation();
 356                 CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(aYValuesSourceRange);
 357             }
 358             xDataSeq.set(getDataSequenceFromDocByRole(xChartDoc2, u"categories", nIndex));
 359             if (xDataSeq.is())
 360             {
 361                 OUString aCategoriesSourceRange = xDataSeq->getSourceRangeRepresentation();
 362                 CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(aCategoriesSourceRange);
 363             }
 364         }
 365     }
 366 }
 367
 368 DECLARE_DUMP_TEST(LegendTest, Chart2DumpTest, false)
 369 {
 370     const std::vector<OUString> aTestFiles =
 371     {
 372         "legend_on_right_side.odp",
 373         "legend_on_bottom.odp",
 374         "legend_on_left_side.odp",
 375         "legend_on_top.odp",
 376         "many_legend_entries.odp",
 377         "custom_legend_position.odp",
 378         "multiple_categories.odp",
 379         "minimal_legend_test.odp"
 380     };
 381
 382     for (const OUString& aTestFile : aTestFiles)
 383     {
 384         setTestFileName(aTestFile);
 385         loadFromFile(getTestFileName());
 386         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromDrawImpress(0, 0), UNO_SET_THROW);
 387         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 388         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 389         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 390         CPPUNIT_ASSERT(xShapes.is());
 391
 392         // Get legend shape
 393         uno::Reference<drawing::XShape> xLegend = getShapeByName(xShapes, "CID/D=0:Legend=");
 394         CPPUNIT_ASSERT(xLegend.is());
 395
 396         /* Check legend position and size
 397         awt::Point aLegendPosition = xLegend->getPosition();
 398         CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLegendPosition.X, INT_EPS);
 399         CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLegendPosition.Y, INT_EPS);
 400         awt::Size aLegendSize = xLegend->getSize();
 401         CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLegendSize.Width, INT_EPS);
 402         CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLegendSize.Height, INT_EPS);*/
 403
 404         // Check legend entries
 405         uno::Reference< chart2::XChartDocument > xChartDoc2(xChartDoc, UNO_QUERY_THROW);
 406         Reference<chart2::XChartType> xChartType = getChartTypeFromDoc(xChartDoc2, 0);
 407         CPPUNIT_ASSERT(xChartType.is());
 408         std::vector<std::vector<double> > aDataSeriesYValues = getDataSeriesYValuesFromChartType(xChartType);
 409         size_t nLegendEntryCount = aDataSeriesYValues.size();
 410         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nLegendEntryCount);
 411         // Check legend entries geometry
 412         for (size_t nSeriesIndex = 0; nSeriesIndex < nLegendEntryCount; ++nSeriesIndex)
 413         {
 414             uno::Reference<drawing::XShape> xLegendEntry = getShapeByName(xShapes, "CID/MultiClick/D=0:CS=0:CT=0:Series=" + OUString::number(nSeriesIndex) + ":LegendEntry=0");
 415             CPPUNIT_ASSERT(xLegendEntry.is());
 416
 417             /* Check position and size
 418             awt::Point aLegendEntryPosition = xLegendEntry->getPosition();
 419             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLegendEntryPosition.X, INT_EPS);
 420             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLegendEntryPosition.Y, INT_EPS);
 421             awt::Size aLegendEntrySize = xLegendEntry->getSize();
 422             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLegendEntrySize.Height, INT_EPS);
 423             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLegendEntrySize.Width, INT_EPS);
 424
 425             // Check transformation
 426             Reference< beans::XPropertySet > xLegendEntryPropSet(xLegendEntry, UNO_QUERY_THROW);
 427             drawing::HomogenMatrix3 aLegendEntryTransformation;
 428             xLegendEntryPropSet->getPropertyValue("Transformation") >>= aLegendEntryTransformation;
 429             CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aLegendEntryTransformation, INT_EPS);*/
 430
 431             uno::Reference<container::XIndexAccess> xLegendEntryContainer(xLegendEntry, UNO_QUERY_THROW);
 432             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(xLegendEntryContainer->getCount());
 433             for (sal_Int32 nEntryGeometryElement = 1; nEntryGeometryElement < xLegendEntryContainer->getCount(); ++nEntryGeometryElement)
 434             {
 435                 uno::Reference<drawing::XShape> xLegendEntryGeom(xLegendEntryContainer->getByIndex(nEntryGeometryElement), UNO_QUERY_THROW);
 436
 437                 // Check geometry
 438                 uno::Reference< drawing::XShapeDescriptor > xShapeDescriptor(xLegendEntryGeom, uno::UNO_QUERY_THROW);
 439                 OUString sEntryGeomShapeType = xShapeDescriptor->getShapeType();
 440                 CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sEntryGeomShapeType);
 441
 442                 // Check display color
 443                 Reference< beans::XPropertySet > xPropSet(xLegendEntryGeom, UNO_QUERY_THROW);
 444                 util::Color aEntryGeomColor = 0;
 445                 xPropSet->getPropertyValue(UNO_NAME_FILLCOLOR) >>= aEntryGeomColor;
 446                 CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aEntryGeomColor));
 447             }
 448         }
 449         // Check legend entries' text
 450         uno::Reference<container::XIndexAccess> xLegendContainer(xLegend, UNO_QUERY_THROW);
 451         for (sal_Int32 i = 0; i < xLegendContainer->getCount(); ++i)
 452         {
 453             uno::Reference<drawing::XShape> xShape(xLegendContainer->getByIndex(i), uno::UNO_QUERY);
 454             uno::Reference< drawing::XShapeDescriptor > xShapeDescriptor(xShape, uno::UNO_QUERY_THROW);
 455             OUString sShapeType = xShapeDescriptor->getShapeType();
 456
 457             if (sShapeType == "com.sun.star.drawing.TextShape")
 458             {
 459                 uno::Reference<text::XText> xLegendEntryText = uno::Reference<text::XTextRange>(xShape, uno::UNO_QUERY_THROW)->getText();
 460                 CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(xLegendEntryText->getString());
 461             }
 462         }
 463     }
 464 }
 465
 466 DECLARE_DUMP_TEST(GridTest, Chart2DumpTest, false)
 467 {
 468     const std::vector<OUString> aTestFiles =
 469     {
 470         "vertical_grid.ods",
 471         "horizontal_grid.ods",
 472         "minor_grid.ods",
 473         "formated_grid_line.ods"
 474     };
 475
 476     for (const OUString& sTestFile : aTestFiles)
 477     {
 478         setTestFileName(sTestFile);
 479         loadFromFile(getTestFileName());
 480         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromSheet(0, mxComponent), UNO_QUERY_THROW);
 481         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 482         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 483         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 484         CPPUNIT_ASSERT(xShapes.is());
 485
 486         const std::vector<OUString> aGridShapeNames =
 487         {
 488             "CID/D=0:CS=0:Axis=1,0:Grid=0", // Major vertical grid
 489             "CID/D=0:CS=0:Axis=0,0:Grid=0", // Major horizontal grid
 490             "CID/D=0:CS=0:Axis=1,0:Grid=0:SubGrid=0", // Minor vertical grid
 491             "CID/D=0:CS=0:Axis=0,0:Grid=0:SubGrid=0"  // Minor horizontal grid
 492         };
 493
 494         for (const OUString& sGridShapeName : aGridShapeNames)
 495         {
 496             uno::Reference<drawing::XShape> xGrid = getShapeByName(xShapes, sGridShapeName);
 497             if (xGrid.is())
 498             {
 499                 CPPUNIT_DUMP_ASSERT_NOTE(sGridShapeName);
 500                 // Check position and size
 501                 awt::Point aGridPosition = xGrid->getPosition();
 502                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aGridPosition.X, INT_EPS);
 503                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aGridPosition.Y, INT_EPS);
 504                 awt::Size aGridSize = xGrid->getSize();
 505                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aGridSize.Height, INT_EPS);
 506                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aGridSize.Width, INT_EPS);
 507
 508                 // Check transformation
 509                 Reference< beans::XPropertySet > xPropSet(xGrid, UNO_QUERY_THROW);
 510                 drawing::HomogenMatrix3 aGridTransformation;
 511                 xPropSet->getPropertyValue("Transformation") >>= aGridTransformation;
 512                 CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aGridTransformation, INT_EPS);
 513
 514                 // Check line properties
 515                 uno::Reference<container::XIndexAccess> xIndexAccess(xGrid, UNO_QUERY_THROW);
 516                 uno::Reference<drawing::XShape> xGridLine(xIndexAccess->getByIndex(0), UNO_QUERY_THROW);
 517                 Reference< beans::XPropertySet > xGridLinePropSet(xGridLine, UNO_QUERY_THROW);
 518                 // Line type
 519                 drawing::LineDash aLineDash;
 520                 xGridLinePropSet->getPropertyValue("LineDash") >>= aLineDash;
 521                 OUString sGridLineDash =
 522                     OUString::number(static_cast<sal_Int32>(aLineDash.Style)) + ";" + OUString::number(aLineDash.Dots) + ";" + OUString::number(aLineDash.DotLen) +
 523                     OUString::number(aLineDash.Dashes) + ";" + OUString::number(aLineDash.DashLen) + ";" + OUString::number(aLineDash.Distance);
 524                 CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sGridLineDash);
 525                 // Line color
 526                 util::Color aLineColor = 0;
 527                 xGridLinePropSet->getPropertyValue("LineColor") >>= aLineColor;
 528                 CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aLineColor));
 529                 // Line width
 530                 sal_Int32 nLineWidth = 0;
 531                 xGridLinePropSet->getPropertyValue("LineWidth") >>= nLineWidth;
 532                 CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nLineWidth);
 533             }
 534         }
 535     }
 536 }
 537
 538 DECLARE_DUMP_TEST(AxisGeometryTest, Chart2DumpTest, false)
 539 {
 540     const std::vector<OUString> aTestFiles =
 541     {
 542         "default_formated_axis.odp",
 543         "axis_special_positioning.odp",
 544         "formated_axis_lines.odp",
 545         "rotated_axis_labels.odp"
 546     };
 547
 548     for (const OUString& sTestFile : aTestFiles)
 549     {
 550         setTestFileName(sTestFile);
 551         loadFromFile(getTestFileName());
 552         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromDrawImpress(0, 0), UNO_SET_THROW);
 553         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 554         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 555         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 556         CPPUNIT_ASSERT(xShapes.is());
 557
 558         const std::vector<OUString> aAxisShapeNames =
 559         {
 560             "CID/D=0:CS=0:Axis=0,0", // X Axis
 561             "CID/D=0:CS=0:Axis=1,0", // Y Axis
 562         };
 563
 564         for (const OUString& sAxisShapeName : aAxisShapeNames)
 565         {
 566             uno::Reference<drawing::XShape> xXAxis = getShapeByName(xShapes, sAxisShapeName);
 567             CPPUNIT_ASSERT(xXAxis.is());
 568
 569             CPPUNIT_DUMP_ASSERT_NOTE(sAxisShapeName);
 570             // Check position and size
 571             awt::Point aAxisPosition = xXAxis->getPosition();
 572             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aAxisPosition.X, INT_EPS);
 573             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aAxisPosition.Y, INT_EPS);
 574             awt::Size aAxisSize = xXAxis->getSize();
 575             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aAxisSize.Height, INT_EPS);
 576             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aAxisSize.Width, INT_EPS);
 577
 578             // Check transformation
 579             Reference< beans::XPropertySet > xPropSet(xXAxis, UNO_QUERY_THROW);
 580             drawing::HomogenMatrix3 aAxisTransformation;
 581             xPropSet->getPropertyValue("Transformation") >>= aAxisTransformation;
 582             CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aAxisTransformation, INT_EPS);
 583
 584             // Check line properties
 585             uno::Reference<container::XIndexAccess> xIndexAccess(xXAxis, UNO_QUERY_THROW);
 586             sal_Int32 nAxisGeometriesCount = xIndexAccess->getCount();
 587             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nAxisGeometriesCount);
 588             uno::Reference<drawing::XShape> xAxisLine(xIndexAccess->getByIndex(0), UNO_QUERY_THROW);
 589             Reference< beans::XPropertySet > xAxisLinePropSet(xAxisLine, UNO_QUERY_THROW);
 590             // Line type
 591             drawing::LineDash aLineDash;
 592             xAxisLinePropSet->getPropertyValue("LineDash") >>= aLineDash;
 593             OUString sAxisLineDash =
 594                 OUString::number(static_cast<sal_Int32>(aLineDash.Style)) + ";" + OUString::number(aLineDash.Dots) + ";" + OUString::number(aLineDash.DotLen) +
 595                 OUString::number(aLineDash.Dashes) + ";" + OUString::number(aLineDash.DashLen) + ";" + OUString::number(aLineDash.Distance);
 596             CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sAxisLineDash);
 597             // Line color
 598             util::Color aAxisLineColor = 0;
 599             xAxisLinePropSet->getPropertyValue("LineColor") >>= aAxisLineColor;
 600             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aAxisLineColor));
 601             // Line width
 602             sal_Int32 nAxisLineWidth = 0;
 603             xAxisLinePropSet->getPropertyValue("LineWidth") >>= nAxisLineWidth;
 604             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nAxisLineWidth);
 605         }
 606     }
 607 }
 608
 609 DECLARE_DUMP_TEST(AxisLabelTest, Chart2DumpTest, false)
 610 {
 611     const std::vector<OUString> aTestFiles =
 612     {
 613         "default_formated_axis.odp",
 614         "rotated_axis_labels.odp",
 615         "formated_axis_labels.odp",
 616         "percent_stacked_column_chart.odp",
 617         "tdf118150.xlsx",
 618         "date-categories.pptx",
 619     };
 620
 621     for (const OUString& sTestFile : aTestFiles)
 622     {
 623         setTestFileName(sTestFile);
 624         loadFromFile(getTestFileName());
 625         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromDrawImpress(0, 0), UNO_SET_THROW);
 626         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 627         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 628         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 629         CPPUNIT_ASSERT(xShapes.is());
 630
 631         const std::vector<OUString> aAxisShapeNames =
 632         {
 633             "CID/D=0:CS=0:Axis=0,0", // X Axis
 634             "CID/D=0:CS=0:Axis=1,0", // Y Axis
 635         };
 636
 637         for (const OUString& sAxisShapeName : aAxisShapeNames)
 638         {
 639             uno::Reference<drawing::XShape> xXAxis = getShapeByName(xShapes, sAxisShapeName,
 640                 // Axis occurs twice in chart xshape representation so need to get the one related to labels
 641                 [](const uno::Reference<drawing::XShape>& rXShape) -> bool
 642                 {
 643                     uno::Reference<drawing::XShapes> xAxisShapes(rXShape, uno::UNO_QUERY);
 644                     CPPUNIT_ASSERT(xAxisShapes.is());
 645                     uno::Reference<drawing::XShape> xChildShape(xAxisShapes->getByIndex(0), uno::UNO_QUERY);
 646                     uno::Reference< drawing::XShapeDescriptor > xShapeDescriptor(xChildShape, uno::UNO_QUERY_THROW);
 647                     return (xShapeDescriptor->getShapeType() == "com.sun.star.drawing.TextShape");
 648                 });
 649             CPPUNIT_ASSERT(xXAxis.is());
 650             CPPUNIT_DUMP_ASSERT_NOTE(sAxisShapeName);
 651
 652             // Check label count
 653             uno::Reference<container::XIndexAccess> xIndexAccess(xXAxis, UNO_QUERY_THROW);
 654             sal_Int32 nAxisLabelsCount = xIndexAccess->getCount();
 655             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nAxisLabelsCount);
 656
 657             // Check labels's text, positioning and font properties
 658             for (sal_Int32 nLabelIndex = 0; nLabelIndex < nAxisLabelsCount; ++nLabelIndex)
 659             {
 660                 // Check text
 661                 uno::Reference<text::XTextRange> xLabel(xIndexAccess->getByIndex(nLabelIndex), uno::UNO_QUERY);
 662                 CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(xLabel->getString());
 663
 664                 // Check size and position
 665                 uno::Reference<drawing::XShape> xLabelShape(xLabel, uno::UNO_QUERY);
 666                 /*awt::Point aLabelPosition = xLabelShape->getPosition();
 667                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLabelPosition.X, INT_EPS);
 668                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLabelPosition.Y, INT_EPS);
 669                 awt::Size aLabelSize = xLabelShape->getSize();
 670                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLabelSize.Height, INT_EPS);
 671                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLabelSize.Width, INT_EPS);*/
 672
 673                 // Check transformation
 674                 Reference< beans::XPropertySet > xPropSet(xLabelShape, UNO_QUERY_THROW);
 675                 /*drawing::HomogenMatrix3 aLabelTransformation;
 676                 xPropSet->getPropertyValue("Transformation") >>= aLabelTransformation;
 677                 CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aLabelTransformation, INT_EPS);*/
 678
 679                 // Check font color and height
 680                 util::Color aLabelFontColor = 0;
 681                 xPropSet->getPropertyValue("CharColor") >>= aLabelFontColor;
 682                 CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aLabelFontColor));
 683                 float fLabelFontHeight = 0.0f;
 684                 xPropSet->getPropertyValue("CharHeight") >>= fLabelFontHeight;
 685                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(fLabelFontHeight, 1E-12);
 686             }
 687         }
 688     }
 689 }
 690
 691 DECLARE_DUMP_TEST(ColumnBarChartTest, Chart2DumpTest, false)
 692 {
 693     const std::vector<OUString> aTestFiles =
 694     {
 695         "normal_column_chart.ods",
 696         "stacked_column_chart.ods",
 697         "percent_stacked_column_chart.ods",
 698         "column_chart_small_spacing.ods",
 699         "normal_bar_chart.ods",
 700         "stacked_bar_chart.ods",
 701         "percent_stacked_bar_chart.ods",
 702     };
 703
 704     for (const OUString& sTestFile : aTestFiles)
 705     {
 706         setTestFileName(sTestFile);
 707         loadFromFile(getTestFileName());
 708         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromSheet(0, mxComponent), UNO_QUERY_THROW);
 709         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 710         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 711         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 712         CPPUNIT_ASSERT(xShapes.is());
 713
 714         uno::Reference< chart2::XChartDocument > xChartDoc2(xChartDoc, UNO_QUERY_THROW);
 715         Reference<chart2::XChartType> xChartType = getChartTypeFromDoc(xChartDoc2, 0);
 716         CPPUNIT_ASSERT(xChartType.is());
 717         std::vector<std::vector<double> > aDataSeriesYValues = getDataSeriesYValuesFromChartType(xChartType);
 718         size_t nSeriesCount = aDataSeriesYValues.size();
 719         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nSeriesCount);
 720
 721         for (size_t nSeries = 0; nSeries < nSeriesCount; ++nSeries)
 722         {
 723             uno::Reference<drawing::XShape> xSeriesColumnsOrBars = getShapeByName(xShapes, "CID/D=0:CS=0:CT=0:Series=" + OUString::number(nSeries));
 724             CPPUNIT_ASSERT(xSeriesColumnsOrBars.is());
 725             CPPUNIT_DUMP_ASSERT_NOTE("Series " + OUString::number(nSeries) + " ColumnsOrBars");
 726
 727             // Check column/bar count in the series
 728             uno::Reference<container::XIndexAccess> xIndexAccess(xSeriesColumnsOrBars, UNO_QUERY_THROW);
 729             sal_Int32 nColumnOrBarCountInSeries = xIndexAccess->getCount();
 730             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nColumnOrBarCountInSeries);
 731
 732             // Check column/bar fill style and color
 733             Reference< beans::XPropertySet > xColumnOrBarPropSet(xIndexAccess->getByIndex(0), UNO_QUERY_THROW);
 734             drawing::FillStyle aSeriesColumnOrBarFillStyle;
 735             xColumnOrBarPropSet->getPropertyValue(UNO_NAME_FILLSTYLE) >>= aSeriesColumnOrBarFillStyle;
 736             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aSeriesColumnOrBarFillStyle));
 737             util::Color aSeriesColumnOrBarFillColor = 0;
 738             xColumnOrBarPropSet->getPropertyValue(UNO_NAME_FILLCOLOR) >>= aSeriesColumnOrBarFillColor;
 739             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aSeriesColumnOrBarFillColor));
 740
 741             for (sal_Int32 nColumnOrBar = 0; nColumnOrBar < nColumnOrBarCountInSeries; ++nColumnOrBar)
 742             {
 743                 uno::Reference<drawing::XShape> xColumnOrBar(xIndexAccess->getByIndex(nColumnOrBar), UNO_QUERY_THROW);
 744                 uno::Reference<container::XNamed> xNamedShape(xIndexAccess->getByIndex(nColumnOrBar), uno::UNO_QUERY);
 745                 CPPUNIT_DUMP_ASSERT_NOTE(xNamedShape->getName());
 746
 747                 // Check size and position
 748                 awt::Point aColumnOrBarPosition = xColumnOrBar->getPosition();
 749                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aColumnOrBarPosition.X, INT_EPS);
 750                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aColumnOrBarPosition.Y, INT_EPS);
 751                 awt::Size aColumnOrBarSize = xColumnOrBar->getSize();
 752                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aColumnOrBarSize.Height, INT_EPS);
 753                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aColumnOrBarSize.Width, INT_EPS);
 754
 755                 // Check transformation
 756                 Reference< beans::XPropertySet > xPropSet(xColumnOrBar, UNO_QUERY_THROW);
 757                 drawing::HomogenMatrix3 aColumnOrBarTransformation;
 758                 xPropSet->getPropertyValue("Transformation") >>= aColumnOrBarTransformation;
 759                 CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aColumnOrBarTransformation, INT_EPS);
 760             }
 761         }
 762     }
 763 }
 764
 765 DECLARE_DUMP_TEST(ChartWallTest, Chart2DumpTest, false)
 766 {
 767     const std::vector<OUString> aTestFiles =
 768     {
 769         "chartwall_auto_adjust_with_titles.ods",
 770         "chartwall_auto_adjust_without_titles.ods",
 771         "chartwall_custom_positioning.ods"
 772     };
 773
 774     for (const OUString& sTestFile : aTestFiles)
 775     {
 776         setTestFileName(sTestFile);
 777         loadFromFile(getTestFileName());
 778         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromDrawImpress(0, 0), UNO_SET_THROW);
 779         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 780         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 781         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 782         CPPUNIT_ASSERT(xShapes.is());
 783
 784         uno::Reference<drawing::XShape> xChartWall = getShapeByName(xShapes, "CID/DiagramWall=");
 785         CPPUNIT_ASSERT(xChartWall.is());
 786
 787         // Check position and size
 788         /*awt::Point aChartWallPosition = xChartWall->getPosition();
 789         CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aChartWallPosition.X, INT_EPS);
 790         CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aChartWallPosition.Y, INT_EPS);
 791         awt::Size aChartWallSize = xChartWall->getSize();
 792         CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aChartWallSize.Height, INT_EPS);
 793         CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aChartWallSize.Width, INT_EPS);*/
 794
 795         // Check transformation
 796         Reference< beans::XPropertySet > xPropSet(xChartWall, UNO_QUERY_THROW);
 797         /*drawing::HomogenMatrix3 aChartWallTransformation;
 798         xPropSet->getPropertyValue("Transformation") >>= aChartWallTransformation;
 799         CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aChartWallTransformation, INT_EPS);*/
 800
 801         // Check fill properties
 802         drawing::FillStyle aChartWallFillStyle;
 803         xPropSet->getPropertyValue(UNO_NAME_FILLSTYLE) >>= aChartWallFillStyle;
 804         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aChartWallFillStyle));
 805         util::Color aChartWallFillColor = 0;
 806         xPropSet->getPropertyValue(UNO_NAME_FILLCOLOR) >>= aChartWallFillColor;
 807         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aChartWallFillColor));
 808
 809         // Check line properties
 810         // Line type
 811         drawing::LineDash aLineDash;
 812         xPropSet->getPropertyValue("LineDash") >>= aLineDash;
 813         OUString sChartWallLineDash =
 814             OUString::number(static_cast<sal_Int32>(aLineDash.Style)) + ";" + OUString::number(aLineDash.Dots) + ";" + OUString::number(aLineDash.DotLen) +
 815             OUString::number(aLineDash.Dashes) + ";" + OUString::number(aLineDash.DashLen) + ";" + OUString::number(aLineDash.Distance);
 816         CPPUNIT_DUMP_ASSERT_STRINGS_EQUAL(sChartWallLineDash);
 817         // Line color
 818         util::Color aChartWallLineColor = 0;
 819         xPropSet->getPropertyValue("LineColor") >>= aChartWallLineColor;
 820         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aChartWallLineColor));
 821         // Line width
 822         sal_Int32 nChartWallLineWidth = 0;
 823         xPropSet->getPropertyValue("LineWidth") >>= nChartWallLineWidth;
 824         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nChartWallLineWidth);
 825     }
 826 }
 827
 828 DECLARE_DUMP_TEST(PieChartTest, Chart2DumpTest, false)
 829 {
 830     const std::vector<OUString> aTestFiles =
 831     {
 832         "normal_pie_chart.ods",
 833         "rotated_pie_chart.ods",
 834         "exploded_pie_chart.ods",
 835         "donut_chart.ods",
 836         "pie_chart_many_slices.ods",
 837     };
 838
 839     for (const OUString& sTestFile : aTestFiles)
 840     {
 841         setTestFileName(sTestFile);
 842         loadFromFile(getTestFileName());
 843         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromSheet(0, mxComponent), UNO_QUERY_THROW);
 844         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 845         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 846         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 847         CPPUNIT_ASSERT(xShapes.is());
 848
 849         uno::Reference< chart2::XChartDocument > xChartDoc2(xChartDoc, UNO_QUERY_THROW);
 850         Reference<chart2::XChartType> xChartType = getChartTypeFromDoc(xChartDoc2, 0);
 851         CPPUNIT_ASSERT(xChartType.is());
 852
 853         std::vector<std::vector<double> > aDataSeriesYValues = getDataSeriesYValuesFromChartType(xChartType);
 854         size_t nSeriesCount = aDataSeriesYValues.size();
 855         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nSeriesCount);
 856
 857         for (size_t nSeries = 0; nSeries < nSeriesCount; ++nSeries)
 858         {
 859             uno::Reference<drawing::XShape> xSeriesSlices = getShapeByName(xShapes, "CID/D=0:CS=0:CT=0:Series=" + OUString::number(nSeries));
 860             if (!xSeriesSlices.is())
 861                 break; // Normal pie chart displays only one series
 862             CPPUNIT_DUMP_ASSERT_NOTE("Series " + OUString::number(nSeries) + " slices");
 863
 864             // Check slice count in the series
 865             uno::Reference<container::XIndexAccess> xIndexAccess(xSeriesSlices, UNO_QUERY_THROW);
 866             sal_Int32 nSlicesCountInSeries = xIndexAccess->getCount();
 867             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nSlicesCountInSeries);
 868
 869             // Check slices properties
 870             for (sal_Int32 nSlice = 0; nSlice < nSlicesCountInSeries; ++nSlice)
 871             {
 872                 uno::Reference<drawing::XShape> xSlice(xIndexAccess->getByIndex(nSlice), UNO_QUERY_THROW);
 873                 uno::Reference<container::XNamed> xNamedShape(xIndexAccess->getByIndex(nSlice), uno::UNO_QUERY);
 874                 OUString sName = xNamedShape->getName();
 875                 CPPUNIT_DUMP_ASSERT_NOTE(sName.copy(sName.lastIndexOf("/D=0")));
 876
 877                 // Check size and position
 878                 awt::Point aSlicePosition = xSlice->getPosition();
 879                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aSlicePosition.X, INT_EPS);
 880                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aSlicePosition.Y, INT_EPS);
 881                 awt::Size aSliceSize = xSlice->getSize();
 882                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aSliceSize.Height, INT_EPS);
 883                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aSliceSize.Width, INT_EPS);
 884
 885                 // Check transformation
 886                 Reference< beans::XPropertySet > xPropSet(xSlice, UNO_QUERY_THROW);
 887                 drawing::HomogenMatrix3 aSliceTransformation;
 888                 xPropSet->getPropertyValue("Transformation") >>= aSliceTransformation;
 889                 CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aSliceTransformation, INT_EPS);
 890
 891                 // Check slice fill style and color
 892                 drawing::FillStyle aSliceFillStyle;
 893                 xPropSet->getPropertyValue(UNO_NAME_FILLSTYLE) >>= aSliceFillStyle;
 894                 CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aSliceFillStyle));
 895                 util::Color aSliceFillColor = 0;
 896                 xPropSet->getPropertyValue(UNO_NAME_FILLCOLOR) >>= aSliceFillColor;
 897                 CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aSliceFillColor));
 898             }
 899         }
 900     }
 901 }
 902
 903 DECLARE_DUMP_TEST(AreaChartTest, Chart2DumpTest, false)
 904 {
 905     const std::vector<OUString> aTestFiles =
 906     {
 907         "normal_area_chart.ods",
 908         "stacked_area_chart.ods",
 909         "percent_stacked_area_chart.ods"
 910     };
 911
 912     for (const OUString& sTestFile : aTestFiles)
 913     {
 914         setTestFileName(sTestFile);
 915         loadFromFile(getTestFileName());
 916         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromSheet(0, mxComponent), UNO_QUERY_THROW);
 917         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 918         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 919         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 920         CPPUNIT_ASSERT(xShapes.is());
 921
 922         uno::Reference< chart2::XChartDocument > xChartDoc2(xChartDoc, UNO_QUERY_THROW);
 923         Reference<chart2::XChartType> xChartType = getChartTypeFromDoc(xChartDoc2, 0);
 924         CPPUNIT_ASSERT(xChartType.is());
 925
 926         std::vector<std::vector<double> > aDataSeriesYValues = getDataSeriesYValuesFromChartType(xChartType);
 927         size_t nSeriesCount = aDataSeriesYValues.size();
 928         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nSeriesCount);
 929
 930         for (size_t nSeries = 0; nSeries < nSeriesCount; ++nSeries)
 931         {
 932             uno::Reference<drawing::XShape> xSeries = getShapeByName(xShapes, "CID/D=0:CS=0:CT=0:Series=" + OUString::number(nSeries));
 933             CPPUNIT_ASSERT(xSeries.is());
 934             CPPUNIT_DUMP_ASSERT_NOTE("Series " + OUString::number(nSeries));
 935
 936             // One area for one series
 937             uno::Reference<container::XIndexAccess> xIndexAccess(xSeries, UNO_QUERY_THROW);
 938             uno::Reference<container::XIndexAccess> xIndexAccess2(xIndexAccess->getByIndex(0), UNO_QUERY_THROW); // Why this second group shape is here?
 939             uno::Reference<drawing::XShape> xArea(xIndexAccess2->getByIndex(0), UNO_QUERY_THROW);
 940
 941             // Check size and position
 942             awt::Point aAreaPosition = xArea->getPosition();
 943             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aAreaPosition.X, INT_EPS);
 944             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aAreaPosition.Y, INT_EPS);
 945             awt::Size aAreaSize = xArea->getSize();
 946             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aAreaSize.Height, INT_EPS);
 947             CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aAreaSize.Width, INT_EPS);
 948
 949             // Check transformation
 950             Reference< beans::XPropertySet > xPropSet(xArea, UNO_QUERY_THROW);
 951             drawing::HomogenMatrix3 aAreaTransformation;
 952             xPropSet->getPropertyValue("Transformation") >>= aAreaTransformation;
 953             CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aAreaTransformation, INT_EPS);
 954
 955             // Check area fill style and color
 956             drawing::FillStyle aAreaFillStyle;
 957             xPropSet->getPropertyValue(UNO_NAME_FILLSTYLE) >>= aAreaFillStyle;
 958             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aAreaFillStyle));
 959             util::Color aAreaFillColor = 0;
 960             xPropSet->getPropertyValue(UNO_NAME_FILLCOLOR) >>= aAreaFillColor;
 961             CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aAreaFillColor));
 962         }
 963     }
 964 }
 965
 966
 967 DECLARE_DUMP_TEST(PointLineChartTest, Chart2DumpTest, false)
 968 {
 969     const std::vector<OUString> aTestFiles =
 970     {
 971         "normal_line_chart_lines_only.ods",
 972         "normal_line_chart_points_only.ods",
 973         "normal_line_chart_lines_and_points.ods",
 974         "stacked_line_chart_lines_only.ods",
 975         "stacked_line_chart_points_only.ods",
 976         "stacked_line_chart_lines_and_points.ods",
 977         "percent_stacked_line_chart_lines_only.ods",
 978         "percent_stacked_line_chart_points_only.ods",
 979         "percent_stacked_line_chart_lines_and_points.ods",
 980         "scatter_chart_points_only.ods",
 981         "scatter_chart_lines_only.ods",
 982         "scatter_chart_lines_and_points.ods",
 983     };
 984
 985     for (const OUString& sTestFile : aTestFiles)
 986     {
 987         setTestFileName(sTestFile);
 988         loadFromFile(getTestFileName());
 989         uno::Reference< chart::XChartDocument > xChartDoc(getChartDocFromSheet(0, mxComponent), UNO_QUERY_THROW);
 990         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xChartDoc, uno::UNO_QUERY);
 991         uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
 992         uno::Reference<drawing::XShapes> xShapes(xDrawPage->getByIndex(0), uno::UNO_QUERY);
 993         CPPUNIT_ASSERT(xShapes.is());
 994
 995         uno::Reference< chart2::XChartDocument > xChartDoc2(xChartDoc, UNO_QUERY_THROW);
 996         Reference<chart2::XChartType> xChartType = getChartTypeFromDoc(xChartDoc2, 0);
 997         CPPUNIT_ASSERT(xChartType.is());
 998
 999         std::vector<std::vector<double> > aDataSeriesYValues = getDataSeriesYValuesFromChartType(xChartType);
1000         size_t nSeriesCount = aDataSeriesYValues.size();
1001         CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nSeriesCount);
1002
1003         for (size_t nSeries = 0; nSeries < nSeriesCount; ++nSeries)
1004         {
1005             uno::Reference<drawing::XShape> xSeries = getShapeByName(xShapes, "CID/D=0:CS=0:CT=0:Series=" + OUString::number(nSeries));
1006             CPPUNIT_ASSERT(xSeries.is());
1007             CPPUNIT_DUMP_ASSERT_NOTE("Series " + OUString::number(nSeries));
1008
1009             uno::Reference<container::XIndexAccess> xIndexAccess(xSeries, UNO_QUERY_THROW);
1010             uno::Reference<container::XIndexAccess> xIndexAccess2(xIndexAccess->getByIndex(0), UNO_QUERY_THROW);
1011             uno::Reference<drawing::XShape> xLine(xIndexAccess2->getByIndex(0), UNO_QUERY_THROW);
1012             Reference< beans::XPropertySet > xPropSet(xLine, UNO_QUERY_THROW);
1013
1014             // Check whether we have line
1015             drawing::LineStyle aSeriesLineStyle;
1016             xPropSet->getPropertyValue(UNO_NAME_LINESTYLE) >>= aSeriesLineStyle;
1017             if (aSeriesLineStyle != drawing::LineStyle_NONE)
1018             {
1019                 CPPUNIT_DUMP_ASSERT_NOTE("Lines are displayed");
1020                 CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aSeriesLineStyle));
1021
1022                 // Check line shape geometry
1023                 awt::Point aLinePosition = xLine->getPosition();
1024                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLinePosition.X, INT_EPS);
1025                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLinePosition.Y, INT_EPS);
1026                 awt::Size aLineSize = xLine->getSize();
1027                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLineSize.Height, INT_EPS);
1028                 CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aLineSize.Width, INT_EPS);
1029                 CPPUNIT_ASSERT(xPropSet.is());
1030                 drawing::HomogenMatrix3 aLineTransformation;
1031                 xPropSet->getPropertyValue("Transformation") >>= aLineTransformation;
1032                 CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aLineTransformation, INT_EPS);
1033             }
1034
1035             // Check points of series
1036             if (xIndexAccess->getCount() >= 2)
1037             {
1038                 CPPUNIT_DUMP_ASSERT_NOTE("Points are displayed");
1039                 uno::Reference<container::XIndexAccess> xPointsOfSeries(xIndexAccess->getByIndex(1), UNO_QUERY_THROW);
1040                 sal_Int32 nPointCountInSeries = xPointsOfSeries->getCount();
1041                 CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(nPointCountInSeries);
1042                 for (sal_Int32 nPoint = 0; nPoint < nPointCountInSeries; ++nPoint)
1043                 {
1044                     uno::Reference<container::XIndexAccess> XPointContainer (
1045                         getShapeByName(xShapes, "CID/MultiClick/D=0:CS=0:CT=0:Series=" + OUString::number(nSeries) + ":Point=" + OUString::number(nPoint)), UNO_QUERY_THROW);
1046                     uno::Reference<drawing::XShape> XPoint(XPointContainer->getByIndex(0), UNO_QUERY_THROW);
1047                     uno::Reference<container::XNamed> xNamedShape(XPointContainer, uno::UNO_QUERY);
1048                     CPPUNIT_DUMP_ASSERT_NOTE(xNamedShape->getName());
1049
1050                     // Check size and position
1051                     awt::Point aPointPosition = XPoint->getPosition();
1052                     CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aPointPosition.X, INT_EPS);
1053                     CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aPointPosition.Y, INT_EPS);
1054                     awt::Size aPointSize = XPoint->getSize();
1055                     CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aPointSize.Height, INT_EPS);
1056                     CPPUNIT_DUMP_ASSERT_DOUBLES_EQUAL(aPointSize.Width, INT_EPS);
1057
1058                     // Check transformation
1059                     Reference< beans::XPropertySet > xPointPropSet(XPoint, UNO_QUERY_THROW);
1060                     drawing::HomogenMatrix3 aPointTransformation;
1061                     xPointPropSet->getPropertyValue("Transformation") >>= aPointTransformation;
1062                     CPPUNIT_DUMP_ASSERT_TRANSFORMATIONS_EQUAL(aPointTransformation, INT_EPS);
1063
1064                     // Check fill style and color
1065                     drawing::FillStyle aPointFillStyle;
1066                     xPointPropSet->getPropertyValue(UNO_NAME_FILLSTYLE) >>= aPointFillStyle;
1067                     CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aPointFillStyle));
1068                     util::Color aPointFillColor = 0;
1069                     xPointPropSet->getPropertyValue(UNO_NAME_FILLCOLOR) >>= aPointFillColor;
1070                     CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL(static_cast<sal_Int32>(aPointFillColor));
1071                 }
1072             }
1073         }
1074     }
1075 }
1076
1077 DECLARE_DUMP_TEST( PivotChartDataButtonTest, Chart2DumpTest, false )
1078 {
1079     setTestFileName( "pivotchart_data_button.ods" );
1080     loadFromFile(getTestFileName());
1081
1082     // Check that we have pivot chart in the document
1083     uno::Reference<table::XTablePivotCharts> xTablePivotCharts = getTablePivotChartsFromSheet( 1, mxComponent );
1084     uno::Reference<container::XIndexAccess> xIndexAccess( xTablePivotCharts, UNO_QUERY_THROW );
1085     CPPUNIT_ASSERT_EQUAL( sal_Int32(1), xIndexAccess->getCount() );
1086
1087     // Get the pivot chart document so we ca access its data
1088     uno::Reference<chart2::XChartDocument> xChartDoc;
1089     xChartDoc.set( getPivotChartDocFromSheet( xTablePivotCharts, 0 ) );
1090     CPPUNIT_ASSERT( xChartDoc.is() );
1091
1092     uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier( xChartDoc, uno::UNO_QUERY );
1093     uno::Reference<drawing::XDrawPage> xDrawPage = xDrawPageSupplier->getDrawPage();
1094     uno::Reference<drawing::XShapes> xShapes( xDrawPage->getByIndex(0), uno::UNO_QUERY );
1095     CPPUNIT_ASSERT( xShapes.is() );
1096
1097     // Get the shape that represents the "Data" button.
1098     uno::Reference<drawing::XShape> xButton = getShapeByName( xShapes, "FieldButton.Row.8",
1099                                                               []( const uno::Reference<drawing::XShape>& xShapeNode )
1100                                                               {
1101                                                                   return xShapeNode->getShapeType() == "com.sun.star.drawing.TextShape";
1102                                                               } );
1103     CPPUNIT_ASSERT_MESSAGE( "Cannot find Data button shape", xButton.is() );
1104
1105     // Make sure that there is no arrow shape with the Data button
1106     uno::Reference<drawing::XShape> xArrow = getShapeByName( xShapes, "FieldButton.Row.8",
1107                                                              []( const uno::Reference<drawing::XShape>& xShapeNode )
1108                                                              {
1109                                                                  return xShapeNode->getShapeType() == "com.sun.star.drawing.PolyPolygonShape";
1110                                                              } );
1111     CPPUNIT_ASSERT_MESSAGE( "Arrow shape should not be present for the Data button", !xArrow.is() );
1112
1113     // Assert the background color of the Data button
1114     util::Color aButtonFillColor = 0;
1115     uno::Reference<beans::XPropertySet> xPropSet( xButton, UNO_QUERY_THROW );
1116     xPropSet->getPropertyValue( UNO_NAME_FILLCOLOR ) >>= aButtonFillColor;
1117     CPPUNIT_DUMP_ASSERT_NUMBERS_EQUAL( static_cast<sal_Int32>( aButtonFillColor ) );
1118 }
1119
1120 CPPUNIT_PLUGIN_IMPLEMENT();
1121
1122 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */