From 9187c893fdd0081bb7da507c7f733dea35784d08 Mon Sep 17 00:00:00 2001
From: Mohammad Mahadi Hasan <mahadi.hasan@tum.de>
Date: Wed, 29 Jan 2014 13:05:05 +0100
Subject: [PATCH] Unit tests with Eigen Matrix for: 1. OutputData.h 2.
MathFuctions.h
---
Tests/UnitTests/TestCore/MathFunctionsTest.h | 75 ++++++++++++++++++++
Tests/UnitTests/TestCore/OutputDataTest.h | 73 +++++++++++++++++++
Tests/UnitTests/TestCore/main.cpp | 1 +
3 files changed, 149 insertions(+)
create mode 100644 Tests/UnitTests/TestCore/MathFunctionsTest.h
diff --git a/Tests/UnitTests/TestCore/MathFunctionsTest.h b/Tests/UnitTests/TestCore/MathFunctionsTest.h
new file mode 100644
index 00000000000..da713cc5d12
--- /dev/null
+++ b/Tests/UnitTests/TestCore/MathFunctionsTest.h
@@ -0,0 +1,75 @@
+#ifndef MATHFUNCTIONSTEST_H
+#define MATHFUNCTIONSTEST_H
+
+#include "MathFunctions.h"
+#include "gtest/gtest.h"
+
+class MathFunctionsTest : public::testing::Test
+{
+protected:
+ MathFunctionsTest();
+ virtual ~MathFunctionsTest(){}
+
+ Eigen::Matrix2cd matrix_2cd;
+};
+
+MathFunctionsTest::MathFunctionsTest(){
+ matrix_2cd(0,0) = complex_t(2.0, 1.0);
+ matrix_2cd(0,1) = complex_t(3.0, 1.0);
+ matrix_2cd(1,0) = complex_t(4.0, 1.0);
+ matrix_2cd(1,1) = complex_t(5.0, 1.0);
+}
+
+TEST_F(MathFunctionsTest, Norm)
+{
+
+ Eigen::Matrix2d matrix_norm = MathFunctions::Norm(matrix_2cd);
+ EXPECT_EQ(std::norm((complex_t)matrix_2cd(0,0)), matrix_norm(0,0));
+ EXPECT_EQ(std::norm((complex_t)matrix_2cd(0,1)), matrix_norm(0,1));
+ EXPECT_EQ(std::norm((complex_t)matrix_2cd(1,0)), matrix_norm(1,0));
+ EXPECT_EQ(std::norm((complex_t)matrix_2cd(1,1)), matrix_norm(1,1));
+}
+
+TEST_F(MathFunctionsTest, Abs)
+{
+ Eigen::Matrix2d matrix_abs = MathFunctions::Abs(matrix_2cd);
+ EXPECT_EQ(std::abs((complex_t)matrix_2cd(0,0)), matrix_abs(0,0));
+ EXPECT_EQ(std::abs((complex_t)matrix_2cd(0,1)), matrix_abs(0,1));
+ EXPECT_EQ(std::abs((complex_t)matrix_2cd(1,0)), matrix_abs(1,0));
+ EXPECT_EQ(std::abs((complex_t)matrix_2cd(1,1)), matrix_abs(1,1));
+}
+
+TEST_F(MathFunctionsTest, ProductByElement)
+{
+ Eigen::Matrix2cd matrix_2cd2;// = Eigen::Matrix2cd::Identity();
+ matrix_2cd2(0,0) = complex_t(2.0, 1.0);
+ matrix_2cd2(0,1) = complex_t(3.0, 1.0);
+ matrix_2cd2(1,0) = complex_t(4.0, 1.0);
+ matrix_2cd2(1,1) = complex_t(5.0, 1.0);
+
+ Eigen::Matrix2cd matrix_prod = MathFunctions::ProductByElement(matrix_2cd, matrix_2cd2);
+ EXPECT_EQ(complex_t(3.0, 4.0), matrix_prod(0,0));
+ EXPECT_EQ(complex_t(8.0, 6.0), matrix_prod(0,1));
+ EXPECT_EQ(complex_t(15.0, 8.0), matrix_prod(1,0));
+ EXPECT_EQ(complex_t(24.0, 10.0), matrix_prod(1,1));
+}
+
+TEST_F(MathFunctionsTest, Conj)
+{
+ Eigen::Matrix2cd matrix_conj = MathFunctions::Conj(matrix_2cd);
+ EXPECT_EQ(std::conj((complex_t)matrix_2cd(0,0)), matrix_conj(0,0));
+ EXPECT_EQ(std::conj((complex_t)matrix_2cd(0,1)), matrix_conj(0,1));
+ EXPECT_EQ(std::conj((complex_t)matrix_2cd(1,0)), matrix_conj(1,0));
+ EXPECT_EQ(std::conj((complex_t)matrix_2cd(1,1)), matrix_conj(1,1));
+}
+
+TEST_F(MathFunctionsTest, Real)
+{
+ Eigen::Matrix2d matrix_conj = MathFunctions::Real(matrix_2cd);
+ EXPECT_EQ(((complex_t)matrix_2cd(0,0)).real(), matrix_conj(0,0));
+ EXPECT_EQ(((complex_t)matrix_2cd(0,1)).real(), matrix_conj(0,1));
+ EXPECT_EQ(((complex_t)matrix_2cd(1,0)).real(), matrix_conj(1,0));
+ EXPECT_EQ(((complex_t)matrix_2cd(1,1)).real(), matrix_conj(1,1));
+}
+
+#endif //MATHFUNCTIONSTEST_H
diff --git a/Tests/UnitTests/TestCore/OutputDataTest.h b/Tests/UnitTests/TestCore/OutputDataTest.h
index f5ad77c4aec..bdaa70d0db5 100644
--- a/Tests/UnitTests/TestCore/OutputDataTest.h
+++ b/Tests/UnitTests/TestCore/OutputDataTest.h
@@ -17,6 +17,8 @@ class OutputDataTest : public ::testing::Test
OutputData<float> fl_data_1d;
OutputData<double> db_data_3d;
std::vector<size_t> zero_3d_coordinate;
+
+ OutputData<Eigen::Matrix2d> matrix_data_2d;
};
OutputDataTest::OutputDataTest()
@@ -38,6 +40,12 @@ OutputDataTest::OutputDataTest()
*it = (double)i;
++it;
}
+
+
+
+ matrix_data_2d.addAxis(angle_axis);
+ matrix_data_2d.addAxis(length_axis);
+ matrix_data_2d.setAllTo(Eigen::Matrix2d::Identity());
}
OutputDataTest::~OutputDataTest()
@@ -54,6 +62,8 @@ TEST_F(OutputDataTest, SizeAfterAddingAxes)
EXPECT_EQ((size_t)1, int_data_0d.getAllocatedSize());
EXPECT_EQ((size_t)20, fl_data_1d.getAllocatedSize());
EXPECT_EQ((size_t)2000, db_data_3d.getAllocatedSize());
+
+ EXPECT_EQ((size_t)200, matrix_data_2d.getAllocatedSize());
}
TEST_F(OutputDataTest, DataInitialization)
@@ -63,8 +73,15 @@ TEST_F(OutputDataTest, DataInitialization)
coordinates.push_back(4);
coordinates.push_back(3);
EXPECT_DOUBLE_EQ((double)1143, db_data_3d[db_data_3d.toIndex(coordinates)]);
+
+
+ std::vector<int> coordinates2;
+ coordinates2.push_back(1);
+ coordinates2.push_back(55);
+ EXPECT_EQ(Eigen::Matrix2d::Identity(), matrix_data_2d[matrix_data_2d.toIndex(coordinates2)]);
}
+
TEST_F(OutputDataTest, DataCopying)
{
OutputData<double> data1;
@@ -100,6 +117,34 @@ TEST_F(OutputDataTest, DataCopying)
EXPECT_TRUE( data2.hasSameDimensions(data2));
EXPECT_TRUE( data2.hasSameShape(data2));
+
+
+ OutputData<Eigen::Matrix2d> mdata1;
+ OutputData<Eigen::Matrix2d> mdata2;
+ mdata1.addAxis("axis1", 10, 0., 10.);
+ mdata2.addAxis("axis1", 10, 0., 10.);
+ EXPECT_TRUE( mdata1.hasSameDimensions(mdata2));
+ EXPECT_TRUE( mdata1.hasSameShape(mdata2));
+
+ mdata1.addAxis("axis2", 10, 0., 10.);
+ mdata2.addAxis("axis2", 10, 1., 10.);
+ EXPECT_TRUE( mdata1.hasSameDimensions(mdata2));
+ EXPECT_FALSE( mdata1.hasSameShape(mdata2));
+
+ mdata2.copyFrom(mdata1);
+ EXPECT_TRUE( mdata1.hasSameDimensions(mdata2));
+ EXPECT_TRUE( mdata1.hasSameShape(mdata2));
+
+ mdata1.setAllTo(Eigen::Matrix2d::Identity());
+ mdata2.copyFrom(mdata1);
+ EXPECT_TRUE( mdata1.hasSameDimensions(mdata2));
+ EXPECT_TRUE( mdata1.hasSameShape(mdata2));
+ EXPECT_TRUE( mdata2.hasSameDimensions(mdata1));
+ EXPECT_TRUE( mdata2.hasSameShape(mdata1));
+ EXPECT_TRUE( mdata1.hasSameDimensions(mdata1));
+ EXPECT_TRUE( mdata1.hasSameShape(mdata1));
+ EXPECT_TRUE( mdata2.hasSameDimensions(mdata2));
+ EXPECT_TRUE( mdata2.hasSameShape(mdata2));
}
TEST_F(OutputDataTest, MaxElement)
@@ -113,6 +158,17 @@ TEST_F(OutputDataTest, MaxElement)
for (size_t i=0; i<data.getAllocatedSize(); ++i) if(i==10) (*it)=10.0;
OutputData<double >::const_iterator cit = std::max_element(data.begin(), data.end());
EXPECT_EQ( double(10.0), (*cit));
+
+
+// OutputData<Eigen::Matrix2d > mdata;
+// mdata.addAxis("axis1", 10, 0., 10.);
+// mdata.addAxis("axis2", 2, 0., 10.);
+// mdata.setAllTo(Eigen::Matrix2d::Identity());
+
+// OutputData<Eigen::Matrix2d >::iterator it2 = mdata.begin();
+// for (size_t i=0; i<mdata.getAllocatedSize(); ++i) if(i==10) (*it2) = 5*Eigen::Matrix2d::Identity();
+// OutputData<Eigen::Matrix2d >::const_iterator cit2 = std::max_element(mdata.begin(), mdata.end());
+// EXPECT_EQ( 5*Eigen::Matrix2d::Identity(), (*cit2));
}
TEST_F(OutputDataTest, ValueOfAxis)
@@ -128,6 +184,18 @@ TEST_F(OutputDataTest, ValueOfAxis)
EXPECT_EQ( double(0.0), data.getValueOfAxis("axis2", 2));
EXPECT_EQ( double(9.0), data.getValueOfAxis("axis1", 19));
EXPECT_EQ( double(10.0), data.getValueOfAxis("axis2", 19));
+
+ OutputData<Eigen::Matrix2d > mdata;
+ mdata.addAxis("axis1", 10, 0., 9.);
+ mdata.addAxis("axis2", 2, 0., 10.);
+ EXPECT_EQ( double(0.0), mdata.getValueOfAxis("axis1", 0));
+ EXPECT_EQ( double(0.0), mdata.getValueOfAxis("axis2", 0));
+ EXPECT_EQ( double(0.0), mdata.getValueOfAxis("axis1", 1));
+ EXPECT_EQ( double(10.0), mdata.getValueOfAxis("axis2", 1));
+ EXPECT_EQ( double(1.0), mdata.getValueOfAxis("axis1", 2));
+ EXPECT_EQ( double(0.0), mdata.getValueOfAxis("axis2", 2));
+ EXPECT_EQ( double(9.0), mdata.getValueOfAxis("axis1", 19));
+ EXPECT_EQ( double(10.0), mdata.getValueOfAxis("axis2", 19));
}
@@ -154,6 +222,7 @@ TEST_F(OutputDataTest, SetRectangularMask)
for(OutputData<double>::iterator it = data.begin(); it!=data.end(); ++it) {
EXPECT_EQ( int(index++), int(it.getIndex()) );
}
+
}
TEST_F(OutputDataTest, SetEllipticMask)
@@ -178,6 +247,10 @@ TEST_F(OutputDataTest, SetCleared)
db_data_3d.clear();
db_data_3d.setAllTo(1.0);
EXPECT_EQ( db_data_3d[0], 1.0);
+
+ matrix_data_2d.clear();
+ matrix_data_2d.setAllTo(10*Eigen::Matrix2d::Identity());
+ EXPECT_EQ(10*Eigen::Matrix2d::Identity(), matrix_data_2d[0]);
}
diff --git a/Tests/UnitTests/TestCore/main.cpp b/Tests/UnitTests/TestCore/main.cpp
index 22b9050d247..a3eb8cdfd97 100644
--- a/Tests/UnitTests/TestCore/main.cpp
+++ b/Tests/UnitTests/TestCore/main.cpp
@@ -36,6 +36,7 @@
#include "MatrixRTCoefficientsTest.h"
#include "ScalarSpecularInfoMapTest.h"
#include "MatrixSpecularInfoMapTest.h"
+#include "MathFunctionsTest.h"
struct ErrorStreamRedirect {
ErrorStreamRedirect( std::streambuf * new_buffer )
--
GitLab