added unit tests for sizeof and dynamic memory allocation
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index a7bb8fa..c53f55c 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt
@@ -68,6 +68,8 @@ ADD_DEFINITIONS("-DEIGEN_EXTERN_INSTANCIATION=1") +EI_ADD_TEST(sizeof) +EI_ADD_TEST(nomalloc) EI_ADD_TEST(basicstuff) EI_ADD_TEST(linearstructure) EI_ADD_TEST(cwiseop)
diff --git a/test/main.h b/test/main.h index 88e7f91..4a5af42 100644 --- a/test/main.h +++ b/test/main.h
@@ -53,7 +53,7 @@ { static const bool should_raise_an_assert = false; - // Used to avoid to raise two exceptions at the time in which + // Used to avoid to raise two exceptions at a time in which // case the exception is not properly catched. // This may happen when a second exceptions is raise in a destructor. static bool no_more_assert = false; @@ -93,6 +93,7 @@ #define VERIFY_RAISES_ASSERT(a) \ { \ + Eigen::no_more_assert = false; \ try { \ Eigen::ei_assert_list.clear(); \ Eigen::ei_push_assert = true; \ @@ -101,25 +102,25 @@ std::cerr << "One of the following asserts should have been raised:\n"; \ for (uint ai=0 ; ai<ei_assert_list.size() ; ++ai) \ std::cerr << " " << ei_assert_list[ai] << "\n"; \ - VERIFY(Eigen::should_raise_an_assert && # a); \ + VERIFY(Eigen::should_raise_an_assert && # a); \ } catch (Eigen::ei_assert_exception e) { \ - Eigen::ei_push_assert = false; VERIFY(true); \ + Eigen::ei_push_assert = false; VERIFY(true); \ } \ } #else // EIGEN_DEBUG_ASSERTS - #define ei_assert(a) \ + #define ei_assert(a) \ if( (!(a)) && (!no_more_assert) ) \ { \ Eigen::no_more_assert = true; \ throw Eigen::ei_assert_exception(); \ } - #define VERIFY_RAISES_ASSERT(a) \ - { \ - try { a; VERIFY(Eigen::should_raise_an_assert && # a); } \ - catch (Eigen::ei_assert_exception e) { VERIFY(true); } \ + #define VERIFY_RAISES_ASSERT(a) { \ + Eigen::no_more_assert = false; \ + try { a; VERIFY(Eigen::should_raise_an_assert && # a); } \ + catch (Eigen::ei_assert_exception e) { VERIFY(true); } \ } #endif // EIGEN_DEBUG_ASSERTS
diff --git a/test/nomalloc.cpp b/test/nomalloc.cpp new file mode 100644 index 0000000..277e986 --- /dev/null +++ b/test/nomalloc.cpp
@@ -0,0 +1,87 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. Eigen itself is part of the KDE project. +// +// Copyright (C) 2006-2008 Benoit Jacob <jacob@math.jussieu.fr> +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, you can redistribute it and/or +// modify it under the terms of the GNU General Public License as +// published by the Free Software Foundation; either version 2 of +// the License, or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see <http://www.gnu.org/licenses/>. + +#define EIGEN_DONT_VECTORIZE 1 +#include "main.h" + +// #define CUSTOM_NEW_DELETE(TYPE) + +void* operator new[] (size_t n) + { + ei_assert(false && "operator new should never be called with fixed size path"); + // the following is in case assertion are disabled + std::cerr << "operator new should never be called with fixed size path" << std::endl; + exit(2); + void* p = malloc(n); + return p; + } + +void operator delete[](void* p) throw() +{ + free(p); +} + +template<typename MatrixType> void nomalloc(const MatrixType& m) +{ + /* this test check no dynamic memory allocation are issued with fixed-size matrices + */ + + typedef typename MatrixType::Scalar Scalar; + typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType; + + int rows = m.rows(); + int cols = m.cols(); + + // this test relies a lot on Random.h, and there's not much more that we can do + // to test it, hence I consider that we will have tested Random.h + MatrixType m1 = MatrixType::random(rows, cols), + m2 = MatrixType::random(rows, cols), + m3(rows, cols), + mzero = MatrixType::zero(rows, cols), + identity = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> + ::identity(rows, rows), + square = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> + ::random(rows, rows); + VectorType v1 = VectorType::random(rows), + v2 = VectorType::random(rows), + vzero = VectorType::zero(rows); + + Scalar s1 = ei_random<Scalar>(); + + int r = ei_random<int>(0, rows-1), + c = ei_random<int>(0, cols-1); + + VERIFY_IS_APPROX((m1+m2)*s1, s1*m1+s1*m2); + VERIFY_IS_APPROX((m1+m2)(r,c), (m1(r,c))+(m2(r,c))); + VERIFY_IS_APPROX(m1.cwiseProduct(m1.block(0,0,rows,cols)), m1.cwiseProduct(m1)); + VERIFY_IS_APPROX((m1*m1.transpose())*m2, m1*(m1.transpose()*m2)); +} + +void test_nomalloc() +{ + // check that our operator new is indeed called: + VERIFY_RAISES_ASSERT(MatrixXd dummy = MatrixXd::random(3,3)); + CALL_SUBTEST( nomalloc(Matrix<float, 1, 1>()) ); + CALL_SUBTEST( nomalloc(Matrix4d()) ); +}
diff --git a/test/sizeof.cpp b/test/sizeof.cpp new file mode 100644 index 0000000..4aaeb2d --- /dev/null +++ b/test/sizeof.cpp
@@ -0,0 +1,46 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. Eigen itself is part of the KDE project. +// +// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr> +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, you can redistribute it and/or +// modify it under the terms of the GNU General Public License as +// published by the Free Software Foundation; either version 2 of +// the License, or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see <http://www.gnu.org/licenses/>. + +#include "main.h" + +template<typename MatrixType> void verifySizeOf(const MatrixType& m) +{ + typedef typename MatrixType::Scalar Scalar; + if (MatrixType::RowsAtCompileTime!=Dynamic && MatrixType::ColsAtCompileTime!=Dynamic) + VERIFY(sizeof(MatrixType)==sizeof(Scalar)*MatrixType::SizeAtCompileTime); + else + VERIFY(sizeof(MatrixType)==sizeof(Scalar*) + 2 * sizeof(int)); +} + +void test_sizeof() +{ + CALL_SUBTEST( verifySizeOf(Matrix<float, 1, 1>()) ); + CALL_SUBTEST( verifySizeOf(Matrix4d()) ); + CALL_SUBTEST( verifySizeOf(Matrix<double, 4, 2>()) ); + CALL_SUBTEST( verifySizeOf(Matrix<bool, 7, 5>()) ); + CALL_SUBTEST( verifySizeOf(MatrixXcf(3, 3)) ); + CALL_SUBTEST( verifySizeOf(MatrixXi(8, 12)) ); + CALL_SUBTEST( verifySizeOf(MatrixXcd(20, 20)) ); + CALL_SUBTEST( verifySizeOf(Matrix<float, 100, 100>()) ); +}