GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Files · core/tests/Data/TestOneDimArrayData.cpp

Adds plugin column to variable widget...

Adds plugin column to variable widget To retrieve the "plugin" field, we add to the metadata of the variable the name of the data source root item

perrinel - - Load All Authors

File last commit:

r511:bf486b19bffa


                r520:b0a7e1650d9f

Download file

             TestOneDimArrayData.cpp
        
                    199 lines
            
             | 6.2 KiB
            
                | text/x-c
            
             |
                CppLexer
            
             / core / tests / Data / TestOneDimArrayData.cpp
          
                    History
                
                 |
                  Source
                 | Raw
                 |Copy content
                 |Copy permalink

        Alexandre Leroux
    
Inits unit tests for 1-dim and 2-dim array data

              r473
            
      #include "Data/ArrayData.h"

      #include <QObject>

      #include <QtTest>

      class TestOneDimArrayData : public QObject {

          Q_OBJECT

      private slots:

        Alexandre Leroux
    
Tests specific methods of 1-dim array data

              r478
            
          /// Tests @sa ArrayData::data()

          void testData_data();

          void testData();

        Alexandre Leroux
    
Tests get data by index method

              r474
            
          /// Tests @sa ArrayData::data(int componentIndex)

          void testDataByComponentIndex_data();

          void testDataByComponentIndex();

        Alexandre Leroux
    
Tests add() method

              r475
            
          /// Tests @sa ArrayData::add()

          void testAdd_data();

          void testAdd();

        Alexandre Leroux
    
Tests specific methods of 1-dim array data

              r478
            
          /// Tests @sa ArrayData::at(int index)

          void testAt_data();

          void testAt();

        Alexandre Leroux
    
Tests clear() and size() methods

              r476
            
          /// Tests @sa ArrayData::clear()

          void testClear_data();

          void testClear();

          /// Tests @sa ArrayData::size()

          void testSize_data();

          void testSize();

        Alexandre Leroux
    
Tests sort() method

              r477
            
          /// Tests @sa ArrayData::sort()

          void testSort_data();

          void testSort();

        Alexandre Leroux
    
Inits unit tests for 1-dim and 2-dim array data

              r473
            
      };

        Alexandre Leroux
    
Tests sort() method

              r477
            
      void TestOneDimArrayData::testData_data()

      {

          // Test structure

          QTest::addColumn<QVector<double> >("inputData");    // array's data input

          QTest::addColumn<QVector<double> >("expectedData"); // expected data

          // Test cases

          QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.}

                                 << QVector<double>{1., 2., 3., 4., 5.};

      }

      void TestOneDimArrayData::testData()

      {

          QFETCH(QVector<double>, inputData);

          QFETCH(QVector<double>, expectedData);

          ArrayData<1> arrayData{inputData};

          QVERIFY(arrayData.data() == expectedData);

      }

        Alexandre Leroux
    
Tests get data by index method

              r474
            
      void TestOneDimArrayData::testDataByComponentIndex_data()

      {

          // Test structure

          QTest::addColumn<QVector<double> >("inputData");    // array data's input

          QTest::addColumn<int>("componentIndex");            // component index to test

          QTest::addColumn<QVector<double> >("expectedData"); // expected data

          // Test cases

          QTest::newRow("validIndex") << QVector<double>{1., 2., 3., 4., 5.} << 0

                                      << QVector<double>{1., 2., 3., 4., 5.};

        perrinel
    
Add synchronization part of v5 acquisition

              r511
            
          QTest::newRow("invalidIndex1") << QVector<double>{1., 2., 3., 4., 5.} << -1

                                         << QVector<double>{};

        Alexandre Leroux
    
Tests get data by index method

              r474
            
          QTest::newRow("invalidIndex2") << QVector<double>{1., 2., 3., 4., 5.} << 1 << QVector<double>{};

      }

      void TestOneDimArrayData::testDataByComponentIndex()

      {

          QFETCH(QVector<double>, inputData);

          QFETCH(int, componentIndex);

          QFETCH(QVector<double>, expectedData);

          ArrayData<1> arrayData{inputData};

          QVERIFY(arrayData.data(componentIndex) == expectedData);

      }

        Alexandre Leroux
    
Tests add() method

              r475
            
      void TestOneDimArrayData::testAdd_data()

      {

          // Test structure

          QTest::addColumn<QVector<double> >("inputData");    // array's data input

          QTest::addColumn<QVector<double> >("otherData");    // array data's input to merge with

          QTest::addColumn<bool>("prepend");                  // prepend or append merge

          QTest::addColumn<QVector<double> >("expectedData"); // expected data after merge

          // Test cases

          QTest::newRow("appendMerge") << QVector<double>{1., 2., 3., 4., 5.}

                                       << QVector<double>{6., 7., 8.} << false

                                       << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8.};

          QTest::newRow("prependMerge") << QVector<double>{1., 2., 3., 4., 5.}

                                        << QVector<double>{6., 7., 8.} << true

                                        << QVector<double>{6., 7., 8., 1., 2., 3., 4., 5.};

      }

      void TestOneDimArrayData::testAdd()

      {

          QFETCH(QVector<double>, inputData);

          QFETCH(QVector<double>, otherData);

          QFETCH(bool, prepend);

          QFETCH(QVector<double>, expectedData);

          ArrayData<1> arrayData{inputData};

          ArrayData<1> other{otherData};

          arrayData.add(other, prepend);

          QVERIFY(arrayData.data() == expectedData);

      }

        Alexandre Leroux
    
Tests specific methods of 1-dim array data

              r478
            
      void TestOneDimArrayData::testAt_data()

      {

          // Test structure

          QTest::addColumn<QVector<double> >("inputData"); // array data's input

          QTest::addColumn<int>("index");                  // index to retrieve data

          QTest::addColumn<double>("expectedData");        // expected data at index

          // Test cases

          QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 0 << 1.;

          QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << 3 << 4.;

      }

      void TestOneDimArrayData::testAt()

      {

          QFETCH(QVector<double>, inputData);

          QFETCH(int, index);

          QFETCH(double, expectedData);

          ArrayData<1> arrayData{inputData};

          QVERIFY(arrayData.at(index) == expectedData);

      }

      void TestOneDimArrayData::testClear_data()

      {

          // Test structure

          QTest::addColumn<QVector<double> >("inputData"); // array data's input

          // Test cases

          QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.};

      }

        Alexandre Leroux
    
Tests clear() and size() methods

              r476
            
      void TestOneDimArrayData::testClear()

      {

          QFETCH(QVector<double>, inputData);

          ArrayData<1> arrayData{inputData};

          arrayData.clear();

          QVERIFY(arrayData.data() == QVector<double>{});

      }

      void TestOneDimArrayData::testSize_data()

      {

          // Test structure

          QTest::addColumn<QVector<double> >("inputData"); // array data's input

          QTest::addColumn<int>("expectedSize");           // expected array data size

          // Test cases

          QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 5;

      }

      void TestOneDimArrayData::testSize()

      {

          QFETCH(QVector<double>, inputData);

          QFETCH(int, expectedSize);

          ArrayData<1> arrayData{inputData};

          QVERIFY(arrayData.size() == expectedSize);

      }

        Alexandre Leroux
    
Tests sort() method

              r477
            
      void TestOneDimArrayData::testSort_data()

      {

          // Test structure

          QTest::addColumn<QVector<double> >("inputData");        // array data's input

          QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data

          QTest::addColumn<QVector<double> >("expectedData");     // expected data after sorting

          // Test cases

          QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}

                                 << QVector<double>{1., 3., 4., 2., 5.};

          QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}

                                 << QVector<double>{5., 2., 3., 4., 1.};

      }

      void TestOneDimArrayData::testSort()

      {

          QFETCH(QVector<double>, inputData);

          QFETCH(std::vector<int>, sortPermutation);

          QFETCH(QVector<double>, expectedData);

          ArrayData<1> arrayData{inputData};

          auto sortedArrayData = arrayData.sort(sortPermutation);

        Alexandre Leroux
    
Fix compilation on Linux

              r496
            
          QVERIFY(sortedArrayData != nullptr);

        Alexandre Leroux
    
Tests sort() method

              r477
            
          QVERIFY(sortedArrayData->data() == expectedData);

      }

        Alexandre Leroux
    
Inits unit tests for 1-dim and 2-dim array data

              r473
            
      QTEST_MAIN(TestOneDimArrayData)

      #include "TestOneDimArrayData.moc"

	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

Alexandre Leroux Inits unit tests for 1-dim and 2-dim array data	r473	#include "Data/ArrayData.h"
		#include <QObject>
		#include <QtTest>

		class TestOneDimArrayData : public QObject {
		Q_OBJECT
		private slots:
Alexandre Leroux Tests specific methods of 1-dim array data	r478	/// Tests @sa ArrayData::data()
		void testData_data();
		void testData();

Alexandre Leroux Tests get data by index method	r474	/// Tests @sa ArrayData::data(int componentIndex)
		void testDataByComponentIndex_data();
		void testDataByComponentIndex();

Alexandre Leroux Tests add() method	r475	/// Tests @sa ArrayData::add()
		void testAdd_data();
		void testAdd();

Alexandre Leroux Tests specific methods of 1-dim array data	r478	/// Tests @sa ArrayData::at(int index)
		void testAt_data();
		void testAt();

Alexandre Leroux Tests clear() and size() methods	r476	/// Tests @sa ArrayData::clear()
		void testClear_data();
		void testClear();

		/// Tests @sa ArrayData::size()
		void testSize_data();
		void testSize();

Alexandre Leroux Tests sort() method	r477	/// Tests @sa ArrayData::sort()
		void testSort_data();
		void testSort();
Alexandre Leroux Inits unit tests for 1-dim and 2-dim array data	r473	};

Alexandre Leroux Tests sort() method	r477	void TestOneDimArrayData::testData_data()
		{
		// Test structure
		QTest::addColumn<QVector<double> >("inputData"); // array's data input
		QTest::addColumn<QVector<double> >("expectedData"); // expected data

		// Test cases
		QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.}
		<< QVector<double>{1., 2., 3., 4., 5.};
		}

		void TestOneDimArrayData::testData()
		{
		QFETCH(QVector<double>, inputData);
		QFETCH(QVector<double>, expectedData);

		ArrayData<1> arrayData{inputData};
		QVERIFY(arrayData.data() == expectedData);
		}

Alexandre Leroux Tests get data by index method	r474	void TestOneDimArrayData::testDataByComponentIndex_data()
		{
		// Test structure
		QTest::addColumn<QVector<double> >("inputData"); // array data's input
		QTest::addColumn<int>("componentIndex"); // component index to test
		QTest::addColumn<QVector<double> >("expectedData"); // expected data

		// Test cases
		QTest::newRow("validIndex") << QVector<double>{1., 2., 3., 4., 5.} << 0
		<< QVector<double>{1., 2., 3., 4., 5.};
perrinel Add synchronization part of v5 acquisition	r511	QTest::newRow("invalidIndex1") << QVector<double>{1., 2., 3., 4., 5.} << -1
		<< QVector<double>{};
Alexandre Leroux Tests get data by index method	r474	QTest::newRow("invalidIndex2") << QVector<double>{1., 2., 3., 4., 5.} << 1 << QVector<double>{};
		}

		void TestOneDimArrayData::testDataByComponentIndex()
		{
		QFETCH(QVector<double>, inputData);
		QFETCH(int, componentIndex);
		QFETCH(QVector<double>, expectedData);

		ArrayData<1> arrayData{inputData};
		QVERIFY(arrayData.data(componentIndex) == expectedData);
		}

Alexandre Leroux Tests add() method	r475	void TestOneDimArrayData::testAdd_data()
		{
		// Test structure
		QTest::addColumn<QVector<double> >("inputData"); // array's data input
		QTest::addColumn<QVector<double> >("otherData"); // array data's input to merge with
		QTest::addColumn<bool>("prepend"); // prepend or append merge
		QTest::addColumn<QVector<double> >("expectedData"); // expected data after merge

		// Test cases
		QTest::newRow("appendMerge") << QVector<double>{1., 2., 3., 4., 5.}
		<< QVector<double>{6., 7., 8.} << false
		<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8.};
		QTest::newRow("prependMerge") << QVector<double>{1., 2., 3., 4., 5.}
		<< QVector<double>{6., 7., 8.} << true
		<< QVector<double>{6., 7., 8., 1., 2., 3., 4., 5.};
		}

		void TestOneDimArrayData::testAdd()
		{
		QFETCH(QVector<double>, inputData);
		QFETCH(QVector<double>, otherData);
		QFETCH(bool, prepend);
		QFETCH(QVector<double>, expectedData);

		ArrayData<1> arrayData{inputData};
		ArrayData<1> other{otherData};

		arrayData.add(other, prepend);
		QVERIFY(arrayData.data() == expectedData);
		}

Alexandre Leroux Tests specific methods of 1-dim array data	r478	void TestOneDimArrayData::testAt_data()
		{
		// Test structure
		QTest::addColumn<QVector<double> >("inputData"); // array data's input
		QTest::addColumn<int>("index"); // index to retrieve data
		QTest::addColumn<double>("expectedData"); // expected data at index

		// Test cases
		QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 0 << 1.;
		QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << 3 << 4.;
		}

		void TestOneDimArrayData::testAt()
		{
		QFETCH(QVector<double>, inputData);
		QFETCH(int, index);
		QFETCH(double, expectedData);

		ArrayData<1> arrayData{inputData};
		QVERIFY(arrayData.at(index) == expectedData);
		}

		void TestOneDimArrayData::testClear_data()
		{
		// Test structure
		QTest::addColumn<QVector<double> >("inputData"); // array data's input

		// Test cases
		QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.};
		}

Alexandre Leroux Tests clear() and size() methods	r476	void TestOneDimArrayData::testClear()
		{
		QFETCH(QVector<double>, inputData);

		ArrayData<1> arrayData{inputData};
		arrayData.clear();
		QVERIFY(arrayData.data() == QVector<double>{});
		}

		void TestOneDimArrayData::testSize_data()
		{
		// Test structure
		QTest::addColumn<QVector<double> >("inputData"); // array data's input
		QTest::addColumn<int>("expectedSize"); // expected array data size

		// Test cases
		QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 5;
		}

		void TestOneDimArrayData::testSize()
		{
		QFETCH(QVector<double>, inputData);
		QFETCH(int, expectedSize);

		ArrayData<1> arrayData{inputData};
		QVERIFY(arrayData.size() == expectedSize);
		}

Alexandre Leroux Tests sort() method	r477	void TestOneDimArrayData::testSort_data()
		{
		// Test structure
		QTest::addColumn<QVector<double> >("inputData"); // array data's input
		QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
		QTest::addColumn<QVector<double> >("expectedData"); // expected data after sorting

		// Test cases
		QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}
		<< QVector<double>{1., 3., 4., 2., 5.};
		QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
		<< QVector<double>{5., 2., 3., 4., 1.};
		}

		void TestOneDimArrayData::testSort()
		{
		QFETCH(QVector<double>, inputData);
		QFETCH(std::vector<int>, sortPermutation);
		QFETCH(QVector<double>, expectedData);

		ArrayData<1> arrayData{inputData};
		auto sortedArrayData = arrayData.sort(sortPermutation);
Alexandre Leroux Fix compilation on Linux	r496	QVERIFY(sortedArrayData != nullptr);
Alexandre Leroux Tests sort() method	r477	QVERIFY(sortedArrayData->data() == expectedData);
		}

Alexandre Leroux Inits unit tests for 1-dim and 2-dim array data	r473	QTEST_MAIN(TestOneDimArrayData)
		#include "TestOneDimArrayData.moc"