ctorleak.cpp File Reference

#include "main.h"
#include <exception>

Classes
struct	Foo
class	Foo::Fail

Macros
#define	EIGEN_TEST_MAX_SIZE   3

Functions
	EIGEN_DECLARE_TEST (ctorleak)

Macro Definition Documentation

EIGEN_TEST_MAX_SIZE

#define EIGEN_TEST_MAX_SIZE   3

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

ctorleak

)

                             {
  typedef Matrix<Foo, Dynamic, Dynamic> MatrixX;
  typedef Matrix<Foo, Dynamic, 1> VectorX;
 
  Foo::object_count = 0;
  for (int i = 0; i < g_repeat; i++) {
    Index rows = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE),
          cols = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
    Foo::object_limit = rows * cols;
    {
      MatrixX r(rows, cols);
      Foo::object_limit = r.size() + internal::random<Index>(0, rows * cols - 2);
      std::cout << "object_limit =" << Foo::object_limit << std::endl;
#ifdef EIGEN_EXCEPTIONS
      try {
#endif
        if (internal::random<bool>()) {
          std::cout << "\nMatrixX m(" << rows << ", " << cols << ");\n";
          MatrixX m(rows, cols);
        } else {
          std::cout << "\nMatrixX m(r);\n";
          MatrixX m(r);
        }
#ifdef EIGEN_EXCEPTIONS
        VERIFY(false);             // not reached if exceptions are enabled
      } catch (const Foo::Fail&) { /* ignore */
      }
#endif
    }
    VERIFY_IS_EQUAL(Index(0), Foo::object_count);
 
    {
      Foo::object_limit = (rows + 1) * (cols + 1);
      MatrixX A(rows, cols);
      VERIFY_IS_EQUAL(Foo::object_count, rows * cols);
      VectorX v = A.row(0);
      VERIFY_IS_EQUAL(Foo::object_count, (rows + 1) * cols);
      v = A.col(0);
      VERIFY_IS_EQUAL(Foo::object_count, rows * (cols + 1));
    }
    VERIFY_IS_EQUAL(Index(0), Foo::object_count);
  }
  std::cout << "\n";
}

References cols, EIGEN_TEST_MAX_SIZE, Eigen::g_repeat, i, m, Foo::object_count, Foo::object_limit, UniformPSDSelfTest::r, rows, v, VERIFY, and VERIFY_IS_EQUAL.