HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Files · core/tests/Data/TestOneDimArrayData.cpp

Reads variable metadata to get the data type...

Reads variable metadata to get the data type The data type is then parsed to determine the value type expected when reading result file

perrinel - - Load All Authors

File last commit:

r540:bf486b19bffa


                r566:a6f250cc335f

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

              r514
            
      #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

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

          void testData_data();

          void testData();

        Alexandre Leroux
    
Tests get data by index method

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

          void testDataByComponentIndex_data();

          void testDataByComponentIndex();

        Alexandre Leroux
    
Tests add() method

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

          void testAdd_data();

          void testAdd();

        Alexandre Leroux
    
Tests specific methods of 1-dim array data

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

          void testAt_data();

          void testAt();

        Alexandre Leroux
    
Tests clear() and size() methods

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

          void testClear_data();

          void testClear();

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

          void testSize_data();

          void testSize();

        Alexandre Leroux
    
Tests sort() method

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

          void testSort_data();

          void testSort();

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

              r514
            
      };

        Alexandre Leroux
    
Tests sort() method

              r518
            
      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

              r515
            
      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

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

                                         << QVector<double>{};

        Alexandre Leroux
    
Tests get data by index method

              r515
            
          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

              r516
            
      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

              r519
            
      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

              r517
            
      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

              r518
            
      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

              r524
            
          QVERIFY(sortedArrayData != nullptr);

        Alexandre Leroux
    
Tests sort() method

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

      }

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

              r514
            
      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	r514	#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	r519	/// Tests @sa ArrayData::data()
		void testData_data();
		void testData();

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

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

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

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

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

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

Alexandre Leroux Tests sort() method	r518	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	r515	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	r540	QTest::newRow("invalidIndex1") << QVector<double>{1., 2., 3., 4., 5.} << -1
		<< QVector<double>{};
Alexandre Leroux Tests get data by index method	r515	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	r516	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	r519	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	r517	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	r518	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	r524	QVERIFY(sortedArrayData != nullptr);
Alexandre Leroux Tests sort() method	r518	QVERIFY(sortedArrayData->data() == expectedData);
		}

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