HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r912:fedc6e2cf64d

Fix format for linux

perrinel -

r912:fedc6e2cf64d

parent child

Context file:

r912:fedc6e2cf64d

core/tests/Data/TestOptionalAxis.cpp +4 -4

             #include <Data/ArrayData.h>
             #include <Data/OptionalAxis.h>
             #include <QObject>
             #include <QtTest>
             Q_DECLARE_METATYPE(OptionalAxis)
             Q_DECLARE_METATYPE(Unit)
             class TestOptionalAxis : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests the creation of a undefined axis
                 void testNotDefinedAxisCtor();
                 /// Tests the creation of a undefined axis
                 void testDefinedAxisCtor_data();
                 void testDefinedAxisCtor();
                 /// Tests @sa OptionalAxis::at() method
                 void testAt_data();
                 void testAt();
                 /// Tests @sa OptionalAxis::size() method
                 void testSize_data();
                 void testSize();
                 /// Tests @sa OptionalAxis::unit() method
                 void testUnit_data();
                 void testUnit();
             };
             void TestOptionalAxis::testNotDefinedAxisCtor()
             {
                 OptionalAxis notDefinedAxis{};
                 QVERIFY(!notDefinedAxis.isDefined());
             }
             void TestOptionalAxis::testDefinedAxisCtor_data()
             {
                 QTest::addColumn<bool>("noData"); // If set to true, nullptr is passed as data of the axis
                 QTest::addColumn<std::vector<double> >(
                     "data"); // Values assigned to the axis when 'noData' flag is set to false
                 QTest::addColumn<Unit>("unit"); // Unit assigned to the axis
                 QTest::newRow("validData") << false << std::vector<double>{1, 2, 3} << Unit{"Hz"};
                 QTest::newRow("invalidData") << true << std::vector<double>{} << Unit{"Hz"};
             }
             void TestOptionalAxis::testDefinedAxisCtor()
             {
                 QFETCH(bool, noData);
                 QFETCH(Unit, unit);
                 // When there is no data, we expect that the constructor returns exception
                 if (noData) {
                     QVERIFY_EXCEPTION_THROWN(OptionalAxis(nullptr, unit), std::invalid_argument);
                 }
                 else {
                     QFETCH(std::vector<double>, data);
                     OptionalAxis axis{std::make_shared<ArrayData<1> >(data), unit};
                     QVERIFY(axis.isDefined());
                 }
             }
             void TestOptionalAxis::testAt_data()
             {
                 QTest::addColumn<OptionalAxis>("axis");    // Axis used for test case (defined or not)
                 QTest::addColumn<int>("index");            // Index to test in the axis
                 QTest::addColumn<double>("expectedValue"); // Expected axis value for the index
                 OptionalAxis definedAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}),
                                          Unit{"Hz"}};
                 QTest::newRow("data1") << definedAxis << 0 << 1.;
                 QTest::newRow("data2") << definedAxis << 1 << 2.;
                 QTest::newRow("data3") << definedAxis << 2 << 3.;
                 QTest::newRow("data4 (index out of bounds)")
                     << definedAxis << 3
                     << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
                 QTest::newRow("data5 (index out of bounds)")
                     << definedAxis << -1
                     << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
                 QTest::newRow("data6 (axis not defined)")
                     << OptionalAxis{} << 0
                     << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for undefined axis
             }
             void TestOptionalAxis::testAt()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(int, index);
                 QFETCH(double, expectedValue);
                 auto value = axis.at(index);
                 QVERIFY((std::isnan(value) && std::isnan(expectedValue)) || value == expectedValue);
             }
             void TestOptionalAxis::testSize_data()
             {
                 QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
                 QTest::addColumn<int>("expectedSize");  // Expected number of data in the axis
                 // Lambda that creates default defined axis (with the values passed in parameter)
                 auto axis = [](std::vector<double> values) {
                     return OptionalAxis{std::make_shared<ArrayData<1> >(std::move(values)), Unit{"Hz"}};
                 };
                 QTest::newRow("data1") << axis({}) << 0;
                 QTest::newRow("data2") << axis({1, 2, 3}) << 3;
                 QTest::newRow("data3") << axis({1, 2, 3, 4}) << 4;
-                QTest::newRow("data4 (axis not defined)")
+                QTest::newRow("data4 (axis not defined)") << OptionalAxis{}
-                    << OptionalAxis{} << 0; // Expects 0 for undefined axis
+                                                          << 0; // Expects 0 for undefined axis
             }
             void TestOptionalAxis::testSize()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(int, expectedSize);
                 QCOMPARE(axis.size(), expectedSize);
             }
             void TestOptionalAxis::testUnit_data()
             {
                 QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
                 QTest::addColumn<Unit>("expectedUnit"); // Expected unit for the axis
                 // Lambda that creates default defined axis (with the unit passed in parameter)
                 auto axis = [](Unit unit) {
                     return OptionalAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}), unit};
                 };
                 QTest::newRow("data1") << axis(Unit{"Hz"}) << Unit{"Hz"};
                 QTest::newRow("data2") << axis(Unit{"t", true}) << Unit{"t", true};
-                QTest::newRow("data3 (axis not defined)")
+                QTest::newRow("data3 (axis not defined)") << OptionalAxis{}
-                    << OptionalAxis{} << Unit{}; // Expects default unit for undefined axis
+                                                          << Unit{}; // Expects default unit for undefined axis
             }
             void TestOptionalAxis::testUnit()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(Unit, expectedUnit);
                 QCOMPARE(axis.unit(), expectedUnit);
             }
             QTEST_MAIN(TestOptionalAxis)
             #include "TestOptionalAxis.moc"

core/tests/Data/TestScalarSeries.cpp +28 -28

             #include "Data/ScalarSeries.h"
             #include "DataSeriesBuilders.h"
             #include "DataSeriesUtils.h"
             #include <QObject>
             #include <QtTest>
             /**
              * @brief The TestScalarSeries class defines unit tests on scalar series.
              *
              * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesUtils)
              */
             class TestScalarSeries : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests construction of a scalar series
                 void testCtor_data();
                 void testCtor();
                 /// Tests merge of two scalar series
                 void testMerge_data();
                 void testMerge();
                 /// Tests merge of a vector series in a scalar series
                 void testMergeWithVector_data();
                 void testMergeWithVector();
                 /// Tests get min x-axis data of a scalar series
                 void testMinXAxisData_data();
                 void testMinXAxisData();
                 /// Tests get max x-axis data of a scalar series
                 void testMaxXAxisData_data();
                 void testMaxXAxisData();
                 /// Tests purge of a scalar series
                 void testPurge_data();
                 void testPurge();
                 /// Tests get x-axis range of a scalar series
                 void testXAxisRange_data();
                 void testXAxisRange();
                 /// Tests get values bounds of a scalar series
                 void testValuesBounds_data();
                 void testValuesBounds();
             };
             void TestScalarSeries::testCtor_data()
             {
                 // x-axis data
                 QTest::addColumn<DataContainer>("xAxisData");
                 // values data
                 QTest::addColumn<DataContainer>("valuesData");
                 // construction expected to be valid
                 QTest::addColumn<bool>("expectOK");
                 // expected x-axis data (when construction is valid)
                 QTest::addColumn<DataContainer>("expectedXAxisData");
                 // expected values data (when construction is valid)
                 QTest::addColumn<DataContainer>("expectedValuesData");
                 QTest::newRow("invalidData (different sizes of vectors)")
                     << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << false
                     << DataContainer{} << DataContainer{};
                 QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
                                             << DataContainer{100., 200., 300., 400., 500.} << true
                                             << DataContainer{1., 2., 3., 4., 5.}
                                             << DataContainer{100., 200., 300., 400., 500.};
                 QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
                                               << DataContainer{100., 200., 300., 400., 500.} << true
                                               << DataContainer{1., 2., 3., 4., 5.}
                                               << DataContainer{500., 400., 300., 200., 100.};
                 QTest::newRow("unsortedData2")
                     << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.} << true
                     << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
             }
             void TestScalarSeries::testCtor()
             {
                 // Creates series
                 QFETCH(DataContainer, xAxisData);
                 QFETCH(DataContainer, valuesData);
                 QFETCH(bool, expectOK);
                 if (expectOK) {
                     auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                                  Unit{}, Unit{});
                     // Validates results : we check that the data series is sorted on its x-axis data
                     QFETCH(DataContainer, expectedXAxisData);
                     QFETCH(DataContainer, expectedValuesData);
                     validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
                 }
                 else {
                     QVERIFY_EXCEPTION_THROWN(std::make_shared<ScalarSeries>(
                                                  std::move(xAxisData), std::move(valuesData), Unit{}, Unit{}),
                                              std::invalid_argument);
                 }
             }
             void TestScalarSeries::testMerge_data()
             {
                 testMerge_struct<ScalarSeries, DataContainer>();
                 QTest::newRow("sortedMerge") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << ScalarBuilder{}
                                                     .setX({6., 7., 8., 9., 10.})
                                                     .setValues({600., 700., 800., 900., 1000.})
                                                     .build()
                                              << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                                              << DataContainer{100., 200., 300., 400., 500.,
 ., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge")
                     << ScalarBuilder{}
                            .setX({6., 7., 8., 9., 10.})
                            .setValues({600., 700., 800., 900., 1000.})
                            .build()
                     << ScalarBuilder{}
                            .setX({1., 2., 3., 4., 5.})
                            .setValues({100., 200., 300., 400., 500.})
                            .build()
                     << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
                     << ScalarBuilder{}
                            .setX({1., 2., 8., 9., 10})
                            .setValues({100., 200., 800., 900., 1000.})
                            .build()
                     << ScalarBuilder{}
                            .setX({3., 4., 5., 6., 7.})
                            .setValues({300., 400., 500., 600., 700.})
                            .build()
                     << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge3")
                     << ScalarBuilder{}
                            .setX({3., 4., 5., 7., 8})
                            .setValues({300., 400., 500., 700., 800.})
                            .build()
                     << ScalarBuilder{}
                            .setX({1., 2., 3., 7., 10.})
                            .setValues({100., 200., 333., 777., 1000.})
                            .build()
                     << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
                     << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
                 QTest::newRow("emptySource") << ScalarBuilder{}
                                                     .setX({3., 4., 5., 7., 8})
                                                     .setValues({300., 400., 500., 700., 800.})
                                                     .build()
                                              << ScalarBuilder{}.setX({}).setValues({}).build()
                                              << DataContainer{3., 4., 5., 7., 8.}
                                              << DataContainer{300., 400., 500., 700., 800.};
             }
             void TestScalarSeries::testMerge()
             {
                 testMerge_t<ScalarSeries, DataContainer>();
             }
             void TestScalarSeries::testMergeWithVector_data()
             {
                 testMergeDifferentTypes_struct<VectorSeries, ScalarSeries>();
-                QTest::newRow("mergeVectorInScalar")
+                QTest::newRow("mergeVectorInScalar") << ScalarBuilder{}
-                    << ScalarBuilder{}
+                                                            .setX({1., 2., 3., 4., 5.})
-                           .setX({1., 2., 3., 4., 5.})
+                                                            .setValues({100., 200., 300., 400., 500.})
-                           .setValues({100., 200., 300., 400., 500.})
+                                                            .build()
-                           .build()
+                                                     << VectorBuilder{}
-                    << VectorBuilder{}
+                                                            .setX({6., 7., 8., 9., 10.})
-                           .setX({6., 7., 8., 9., 10.})
+                                                            .setXValues({600., 700., 800., 900., 1000.})
-                           .setXValues({600., 700., 800., 900., 1000.})
+                                                            .setYValues({610., 710., 810., 910., 1010.})
-                           .setYValues({610., 710., 810., 910., 1010.})
+                                                            .setZValues({620., 720., 820., 920., 1020.})
-                           .setZValues({620., 720., 820., 920., 1020.})
+                                                            .build()
-                           .build()
+                                                     << DataContainer{1., 2., 3., 4., 5.}
-                    << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300., 400., 500.};
+                                                     << DataContainer{100., 200., 300., 400., 500.};
             }
             void TestScalarSeries::testMergeWithVector()
             {
                 testMergeDifferentTypes_t<VectorSeries, ScalarSeries>();
             }
             void TestScalarSeries::testMinXAxisData_data()
             {
                 testMinXAxisData_struct<ScalarSeries>();
                 QTest::newRow("minData1") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 0. << true << 1.;
                 QTest::newRow("minData2") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 1. << true << 1.;
                 QTest::newRow("minData3") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 1.1 << true << 2.;
                 QTest::newRow("minData4") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 5. << true << 5.;
                 QTest::newRow("minData5") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
                 QTest::newRow("minData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false
                                           << std::numeric_limits<double>::quiet_NaN();
             }
             void TestScalarSeries::testMinXAxisData()
             {
                 testMinXAxisData_t<ScalarSeries>();
             }
             void TestScalarSeries::testMaxXAxisData_data()
             {
                 testMaxXAxisData_struct<ScalarSeries>();
                 QTest::newRow("maxData1") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 6. << true << 5.;
                 QTest::newRow("maxData2") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 5. << true << 5.;
                 QTest::newRow("maxData3") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 4.9 << true << 4.;
                 QTest::newRow("maxData4") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 1.1 << true << 1.;
                 QTest::newRow("maxData5") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 1. << true << 1.;
                 QTest::newRow("maxData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false
                                           << std::numeric_limits<double>::quiet_NaN();
             }
             void TestScalarSeries::testMaxXAxisData()
             {
                 testMaxXAxisData_t<ScalarSeries>();
             }
             void TestScalarSeries::testPurge_data()
             {
                 testPurge_struct<ScalarSeries>();
                 QTest::newRow("purgeScalar") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 2. << 4. << DataContainer{2., 3., 4.}
                                              << std::vector<DataContainer>{{200., 300., 400.}};
-                QTest::newRow("purgeScalar1 (min/max swap)")
+                QTest::newRow("purgeScalar1 (min/max swap)") << ScalarBuilder{}
-                    << ScalarBuilder{}
+                                                                    .setX({1., 2., 3., 4., 5.})
-                           .setX({1., 2., 3., 4., 5.})
+                                                                    .setValues({100., 200., 300., 400., 500.})
-                           .setValues({100., 200., 300., 400., 500.})
+                                                                    .build()
-                           .build()
+                                                             << 4. << 2. << DataContainer{2., 3., 4.}
-                    << 4. << 2. << DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}};
+                                                             << std::vector<DataContainer>{{200., 300., 400.}};
                 QTest::newRow("purgeScalar2") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                      .build()
                                               << 0. << 2.5 << DataContainer{1., 2.}
                                               << std::vector<DataContainer>{{100., 200.}};
                 QTest::newRow("purgeScalar3") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                      .build()
                                               << 3.5 << 7. << DataContainer{4., 5.}
                                               << std::vector<DataContainer>{{400., 500.}};
                 QTest::newRow("purgeScalar4") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                      .build()
                                               << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
                                               << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
                 QTest::newRow("purgeScalar5") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                      .build()
                                               << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
             }
             void TestScalarSeries::testPurge()
             {
                 testPurge_t<ScalarSeries>();
             }
             void TestScalarSeries::testXAxisRange_data()
             {
                 testXAxisRange_struct<ScalarSeries>();
                 QTest::newRow("xAxisRange") << ScalarBuilder{}
                                                    .setX({1., 2., 3., 4., 5.})
                                                    .setValues({100., 200., 300., 400., 500.})
                                                    .build()
                                             << -1. << 3.2 << DataContainer{1., 2., 3.}
                                             << DataContainer{100., 200., 300.};
-                QTest::newRow("xAxisRange1 (min/max swap)")
+                QTest::newRow("xAxisRange1 (min/max swap)") << ScalarBuilder{}
-                    << ScalarBuilder{}
+                                                                   .setX({1., 2., 3., 4., 5.})
-                           .setX({1., 2., 3., 4., 5.})
+                                                                   .setValues({100., 200., 300., 400., 500.})
-                           .setValues({100., 200., 300., 400., 500.})
+                                                                   .build()
-                           .build()
+                                                            << 3.2 << -1. << DataContainer{1., 2., 3.}
-                    << 3.2 << -1. << DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.};
+                                                            << DataContainer{100., 200., 300.};
                 QTest::newRow("xAxisRange2") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 1. << 4. << DataContainer{1., 2., 3., 4.}
                                              << DataContainer{100., 200., 300., 400.};
                 QTest::newRow("xAxisRange3") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 1. << 3.9 << DataContainer{1., 2., 3.}
                                              << DataContainer{100., 200., 300.};
                 QTest::newRow("xAxisRange4") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 0. << 0.9 << DataContainer{} << DataContainer{};
                 QTest::newRow("xAxisRange5") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 0. << 1. << DataContainer{1.} << DataContainer{100.};
                 QTest::newRow("xAxisRange6") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 2.1 << 6. << DataContainer{3., 4., 5.}
                                              << DataContainer{300., 400., 500.};
                 QTest::newRow("xAxisRange7") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 6. << 9. << DataContainer{} << DataContainer{};
                 QTest::newRow("xAxisRange8") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 5. << 9. << DataContainer{5.} << DataContainer{500.};
             }
             void TestScalarSeries::testXAxisRange()
             {
                 testXAxisRange_t<ScalarSeries>();
             }
             void TestScalarSeries::testValuesBounds_data()
             {
                 testValuesBounds_struct<ScalarSeries>();
                 auto nan = std::numeric_limits<double>::quiet_NaN();
                 QTest::newRow("scalarBounds1") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 0. << 6. << true << 100. << 500.;
                 QTest::newRow("scalarBounds2") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 2. << 4. << true << 200. << 400.;
                 QTest::newRow("scalarBounds3") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 0. << 0.5 << false << nan << nan;
                 QTest::newRow("scalarBounds4") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 5.1 << 6. << false << nan << nan;
-                QTest::newRow("scalarBounds5")
+                QTest::newRow("scalarBounds5") << ScalarBuilder{}.setX({1.}).setValues({100.}).build() << 0.
-                    << ScalarBuilder{}.setX({1.}).setValues({100.}).build() << 0. << 2. << true << 100. << 100.;
+                                               << 2. << true << 100. << 100.;
-                QTest::newRow("scalarBounds6")
+                QTest::newRow("scalarBounds6") << ScalarBuilder{}.setX({}).setValues({}).build() << 0. << 2.
-                    << ScalarBuilder{}.setX({}).setValues({}).build() << 0. << 2. << false << nan << nan;
+                                               << false << nan << nan;
                 // Tests with NaN values: NaN values are not included in min/max search
                 QTest::newRow("scalarBounds7") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({nan, 200., 300., 400., nan})
                                                       .build()
                                                << 0. << 6. << true << 200. << 400.;
                 QTest::newRow("scalarBounds8")
                     << ScalarBuilder{}.setX({1., 2., 3., 4., 5.}).setValues({nan, nan, nan, nan, nan}).build()
                     << 0. << 6. << true << nan << nan;
             }
             void TestScalarSeries::testValuesBounds()
             {
                 testValuesBounds_t<ScalarSeries>();
             }
             QTEST_MAIN(TestScalarSeries)
             #include "TestScalarSeries.moc"

gui/src/DataSource/DataSourceTreeWidget.cpp +3 -1

             #include "DataSource/DataSourceTreeWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "DataSource/DataSourceController.h"
             #include "DataSource/DataSourceItem.h"
             #include "DataSource/DataSourceTreeWidgetItem.h"
             #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             #include <QMimeData>
-            DataSourceTreeWidget::DataSourceTreeWidget(QWidget *parent) : QTreeWidget(parent) {}
+            DataSourceTreeWidget::DataSourceTreeWidget(QWidget *parent) : QTreeWidget(parent)
+            {
+            }
             QMimeData *DataSourceTreeWidget::mimeData(const QList<QTreeWidgetItem *> items) const
             {
                 auto mimeData = new QMimeData;
                 // Basic check to ensure the item are correctly typed
                 Q_ASSERT(items.isEmpty() || dynamic_cast<DataSourceTreeWidgetItem *>(items.first()) != nullptr);
                 QVariantList productData;
                 for (auto item : items) {
                     auto dataSourceTreeItem = static_cast<DataSourceTreeWidgetItem *>(item);
                     auto dataSource = dataSourceTreeItem->data();
                     if (dataSource->type() == DataSourceItemType::COMPONENT
                         || dataSource->type() == DataSourceItemType::PRODUCT) {
                         auto metaData = dataSource->data();
                         productData << metaData;
                     }
                 }
                 auto encodedData = sqpApp->dataSourceController().mimeDataForProductsData(productData);
                 mimeData->setData(MIME_TYPE_PRODUCT_LIST, encodedData);
                 return mimeData;
             }
             void DataSourceTreeWidget::startDrag(Qt::DropActions supportedActions)
             {
                 // Resets the drag&drop operations before it's starting
                 sqpApp->dragDropHelper().resetDragAndDrop();
                 QTreeWidget::startDrag(supportedActions);
             }

gui/src/DragAndDrop/DragDropHelper.cpp +3 -1

             #include "DragAndDrop/DragDropHelper.h"
             #include "DragAndDrop/DragDropScroller.h"
             #include "DragAndDrop/DragDropTabSwitcher.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Variable/Variable.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
             #include <QLabel>
             #include <QUrl>
             #include <QVBoxLayout>
             Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper")
             struct DragDropHelper::DragDropHelperPrivate {
                 VisualizationDragWidget *m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 QLabel *m_PlaceHolderLabel;
                 QWidget *m_PlaceBackground;
                 std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
                 std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr;
                 QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
                                         // QTemporaryFile to have a name which is not generated.
                 VisualizationDragWidget *m_HighlightedDragWidget = nullptr;
                 QMetaObject::Connection m_DragWidgetDestroyedConnection;
                 QMetaObject::Connection m_HighlightedWidgetDestroyedConnection;
                 QList<QWidget *> m_WidgetToClose;
                 explicit DragDropHelperPrivate()
                         : m_PlaceHolder{std::make_unique<QWidget>()},
                           m_DragDropScroller{std::make_unique<DragDropScroller>()},
                           m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
                 {
                     auto layout = new QVBoxLayout{m_PlaceHolder.get()};
                     layout->setSpacing(0);
                     layout->setContentsMargins(0, 0, 0, 0);
                     m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()};
                     m_PlaceHolderLabel->setMinimumHeight(25);
                     layout->addWidget(m_PlaceHolderLabel);
                     m_PlaceBackground = new QWidget{m_PlaceHolder.get()};
                     m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     layout->addWidget(m_PlaceBackground);
                     sqpApp->installEventFilter(m_DragDropScroller.get());
                     sqpApp->installEventFilter(m_DragDropTabSwitcher.get());
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
                 }
                 void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) const
                 {
                     if (m_CurrentDragWidget) {
                         m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
                         m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
                     }
                     else {
                         // Configuration of the placeHolder when there is no dragWidget
                         // (for instance with a drag from a variable)
                         m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     }
                     switch (type) {
                         case DragDropHelper::PlaceHolderType::Graph:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 1px solid #2A7FD4");
                             break;
                         case DragDropHelper::PlaceHolderType::Zone:
                         case DragDropHelper::PlaceHolderType::Default:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 2px solid #2A7FD4");
                             m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
                             break;
                     }
                     m_PlaceHolderLabel->setText(topLabelText);
                     m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty());
                 }
             };
-            DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} {}
+            DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
+            {
+            }
             DragDropHelper::~DragDropHelper()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
             void DragDropHelper::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
                 impl->m_HighlightedDragWidget = nullptr;
             }
             void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_CurrentDragWidget) {
                     QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_CurrentDragWidget = nullptr; });
                 }
                 impl->m_CurrentDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
             {
                 return impl->m_CurrentDragWidget;
             }
             QWidget &DragDropHelper::placeHolder() const
             {
                 return *impl->m_PlaceHolder;
             }
             void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
                                                    const QString &topLabelText)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder(type, topLabelText);
                 layout->insertWidget(index, impl->m_PlaceHolder.get());
                 impl->m_PlaceHolder->show();
             }
             void DragDropHelper::removePlaceHolder()
             {
                 auto parentWidget = impl->m_PlaceHolder->parentWidget();
                 if (parentWidget) {
                     parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
                     impl->m_PlaceHolder->setParent(nullptr);
                     impl->m_PlaceHolder->hide();
                 }
             }
             bool DragDropHelper::isPlaceHolderSet() const
             {
                 return impl->m_PlaceHolder->parentWidget();
             }
             void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->addScrollArea(scrollArea);
             }
             void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->removeScrollArea(scrollArea);
             }
             void DragDropHelper::addDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->addTabBar(tabBar);
             }
             void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
             }
             QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }
             void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_HighlightedDragWidget) {
                     impl->m_HighlightedDragWidget->highlightForMerge(false);
                     QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     dragWidget->highlightForMerge(true);
                     // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_HighlightedDragWidget = nullptr; });
                 }
                 impl->m_HighlightedDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const
             {
                 return impl->m_HighlightedDragWidget;
             }
             void DragDropHelper::delayedCloseWidget(QWidget *widget)
             {
                 widget->hide();
                 impl->m_WidgetToClose << widget;
             }
             void DragDropHelper::doCloseWidgets()
             {
                 for (auto widget : impl->m_WidgetToClose) {
                     widget->close();
                 }
                 impl->m_WidgetToClose.clear();
             }
             bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
                                                                VisualizationDragDropContainer *dropContainer)
             {
                 if (!mimeData || !dropContainer) {
                     qCWarning(LOG_DragDropHelper()) << QObject::tr(
                         "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
                     Q_ASSERT(false);
                     return false;
                 }
                 auto result = false;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     if (variables.count() == 1) {
                         auto variable = variables.first();
                         if (variable->dataSeries() != nullptr) {
                             // Check that the variable is not already in a graph
                             auto parent = dropContainer->parentWidget();
                             while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
                                 parent = parent->parentWidget(); // Search for the top level VisualizationWidget
                             }
                             if (parent) {
                                 auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
                                 FindVariableOperation findVariableOperation{variable};
                                 visualizationWidget->accept(&findVariableOperation);
                                 auto variableContainers = findVariableOperation.result();
                                 if (variableContainers.empty()) {
                                     result = true;
                                 }
                                 else {
                                     // result = false: the variable already exist in the visualisation
                                 }
                             }
                             else {
                                 qCWarning(LOG_DragDropHelper()) << QObject::tr(
                                     "DragDropHelper::checkMimeDataForVisualization, the parent "
                                     "VisualizationWidget cannot be found. Cannot check if the variable is "
                                     "already used or not.");
                             }
                         }
                         else {
                             // result = false: the variable is not fully loaded
                         }
                     }
                     else {
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
                 else {
                     // Other MIME data
                     // no special rules, accepted by default
                     result = true;
                 }
                 return result;
             }

gui/src/Variable/VariableInspectorTableView.cpp +3 -1

             #include "Variable/VariableInspectorTableView.h"
             #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
-            VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent) {}
+            VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent)
+            {
+            }
             void VariableInspectorTableView::startDrag(Qt::DropActions supportedActions)
             {
                 // Resets the drag&drop operations before it's starting
                 sqpApp->dragDropHelper().resetDragAndDrop();
                 QTableView::startDrag(supportedActions);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages