added unit tests for sizeof and dynamic memory allocation

test/CMakeLists.txt

@@ -68,6 +68,8 @@ ENABLE_TESTING()
 
 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)

test/main.h

@@ -53,7 +53,7 @@ namespace Eigen
   {
     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 @@ namespace Eigen
 
     #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 @@ namespace Eigen
           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)                                 \
+    #define VERIFY_RAISES_ASSERT(a) {                             \
-      {                                                             \
+        Eigen::no_more_assert = false;                            \
-        try { a; VERIFY(Eigen::should_raise_an_assert && # a); }   \
+        try { a; VERIFY(Eigen::should_raise_an_assert && # a); }  \
-        catch (Eigen::ei_assert_exception e) { VERIFY(true); }     \
+        catch (Eigen::ei_assert_exception e) { VERIFY(true); }    \
       }
 
   #endif // EIGEN_DEBUG_ASSERTS

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()) );
+}

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>()) );
+}