diff --git a/test/basicstuff.cpp b/test/basicstuff.cpp
index 2f1dc222b..882d4a9c0 100644
--- a/test/basicstuff.cpp
+++ b/test/basicstuff.cpp
@@ -44,15 +44,15 @@ void basicStuff(const MatrixType& m) {
   Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
 
   m1.coeffRef(r, c) = x;
-  VERIFY_IS_EQUAL(x, m1.coeff(r, c));
+  VERIFY_IS_APPROX(x, m1.coeff(r, c));
   m1(r, c) = x;
-  VERIFY_IS_EQUAL(x, m1(r, c));
+  VERIFY_IS_APPROX(x, m1(r, c));
   v1.coeffRef(r) = x;
-  VERIFY_IS_EQUAL(x, v1.coeff(r));
+  VERIFY_IS_APPROX(x, v1.coeff(r));
   v1(r) = x;
-  VERIFY_IS_EQUAL(x, v1(r));
+  VERIFY_IS_APPROX(x, v1(r));
   v1[r] = x;
-  VERIFY_IS_EQUAL(x, v1[r]);
+  VERIFY_IS_APPROX(x, v1[r]);
 
   // test fetching with various index types.
   Index r1 = internal::random<Index>(0, numext::mini(Index(127), rows - 1));
@@ -68,13 +68,13 @@ void basicStuff(const MatrixType& m) {
   if (sizeof(Index) >= sizeof(long long int)) x = v1(static_cast<long long int>(r1));
   if (sizeof(Index) >= sizeof(unsigned long long int)) x = v1(static_cast<unsigned long long int>(r1));
 
-  VERIFY_IS_EQUAL(v1, v1);
+  VERIFY_IS_APPROX(v1, v1);
   VERIFY_IS_NOT_APPROX(v1, 2 * v1);
   VERIFY_IS_MUCH_SMALLER_THAN(vzero, v1);
   VERIFY_IS_MUCH_SMALLER_THAN(vzero, v1.squaredNorm());
   VERIFY_IS_NOT_MUCH_SMALLER_THAN(v1, v1);
   VERIFY_IS_APPROX(vzero, v1 - v1);
-  VERIFY_IS_EQUAL(m1, m1);
+  VERIFY_IS_APPROX(m1, m1);
   VERIFY_IS_NOT_APPROX(m1, 2 * m1);
   VERIFY_IS_MUCH_SMALLER_THAN(mzero, m1);
   VERIFY_IS_NOT_MUCH_SMALLER_THAN(m1, m1);
@@ -95,7 +95,7 @@ void basicStuff(const MatrixType& m) {
   rv = square.row(r);
   cv = square.col(r);
 
-  VERIFY_IS_EQUAL(rv, cv.transpose());
+  VERIFY_IS_APPROX(rv, cv.transpose());
 
   if (cols != 1 && rows != 1 && MatrixType::SizeAtCompileTime != Dynamic) {
     VERIFY_RAISES_ASSERT(m1 = (m2.block(0, 0, rows - 1, cols - 1)));
@@ -105,13 +105,13 @@ void basicStuff(const MatrixType& m) {
     check_index(m1);
   }
 
-  VERIFY_IS_EQUAL(m3 = m1, m1);
+  VERIFY_IS_APPROX(m3 = m1, m1);
   MatrixType m4;
-  VERIFY_IS_EQUAL(m4 = m1, m1);
+  VERIFY_IS_APPROX(m4 = m1, m1);
 
   m3.real() = m1.real();
-  VERIFY_IS_EQUAL(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
-  VERIFY_IS_EQUAL(static_cast<const MatrixType&>(m3).real(), m1.real());
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), m1.real());
 
   // check == / != operators
   VERIFY(m1 == m1);
@@ -125,38 +125,38 @@ void basicStuff(const MatrixType& m) {
   // check automatic transposition
   sm2.setZero();
   for (Index i = 0; i < rows; ++i) sm2.col(i) = sm1.row(i);
-  VERIFY_IS_EQUAL(sm2, sm1.transpose());
+  VERIFY_IS_APPROX(sm2, sm1.transpose());
 
   sm2.setZero();
   for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() = sm1.row(i);
-  VERIFY_IS_EQUAL(sm2, sm1.transpose());
+  VERIFY_IS_APPROX(sm2, sm1.transpose());
 
   sm2.setZero();
   for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() += sm1.row(i);
-  VERIFY_IS_EQUAL(sm2, sm1.transpose());
+  VERIFY_IS_APPROX(sm2, sm1.transpose());
 
   sm2.setZero();
   for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() -= sm1.row(i);
-  VERIFY_IS_EQUAL(sm2, -sm1.transpose());
+  VERIFY_IS_APPROX(sm2, -sm1.transpose());
 
   // check ternary usage
   {
     bool b = internal::random<int>(0, 10) > 5;
     m3 = b ? m1 : m2;
     if (b)
-      VERIFY_IS_EQUAL(m3, m1);
+      VERIFY_IS_APPROX(m3, m1);
     else
-      VERIFY_IS_EQUAL(m3, m2);
+      VERIFY_IS_APPROX(m3, m2);
     m3 = b ? -m1 : m2;
     if (b)
-      VERIFY_IS_EQUAL(m3, -m1);
+      VERIFY_IS_APPROX(m3, -m1);
     else
-      VERIFY_IS_EQUAL(m3, m2);
+      VERIFY_IS_APPROX(m3, m2);
     m3 = b ? m1 : -m2;
     if (b)
-      VERIFY_IS_EQUAL(m3, m1);
+      VERIFY_IS_APPROX(m3, m1);
     else
-      VERIFY_IS_EQUAL(m3, -m2);
+      VERIFY_IS_APPROX(m3, -m2);
   }
 }
 
diff --git a/test/determinant.cpp b/test/determinant.cpp
index d8f9107c6..0f2d4f85e 100644
--- a/test/determinant.cpp
+++ b/test/determinant.cpp
@@ -27,8 +27,10 @@ void determinant(const MatrixType& m) {
   VERIFY_IS_APPROX((m1 * m2).eval().determinant(), m1.determinant() * m2.determinant());
   if (size == 1) return;
   Index i = internal::random<Index>(0, size - 1);
-  Index j = internal::random<Index>(0, size - 2);
-  if (j >= i) ++j;
+  Index j;
+  do {
+    j = internal::random<Index>(0, size - 1);
+  } while (j == i);
   m2 = m1;
   m2.row(i).swap(m2.row(j));
   VERIFY_IS_APPROX(m2.determinant(), -m1.determinant());
diff --git a/test/integer_types.cpp b/test/integer_types.cpp
index 7367b556f..142854cf2 100644
--- a/test/integer_types.cpp
+++ b/test/integer_types.cpp
@@ -26,13 +26,24 @@ void signed_integer_type_tests(const MatrixType& m) {
 
   MatrixType m1(rows, cols), m2 = MatrixType::Random(rows, cols), mzero = MatrixType::Zero(rows, cols);
 
-  m1 = MatrixType::Random(rows, cols);
-  if (m1 == mzero || m1 == m2) m1(0, 0) = m2(0, 0) + Scalar(1);
+  {
+    int guard = 0;
+    do {
+      m1 = MatrixType::Random(rows, cols);
+    } while ((m1 == mzero || m1 == m2) && (++guard) < 100);
+    VERIFY(guard < 100);
+  }
 
   // check linear structure
 
-  Scalar s1 = internal::random<Scalar>();
-  if (s1 == 0) s1 = Scalar(1);
+  Scalar s1;
+  {
+    int guard = 0;
+    do {
+      s1 = internal::random<Scalar>();
+    } while (s1 == 0 && (++guard) < 100);
+    VERIFY(guard < 100);
+  }
 
   VERIFY_IS_EQUAL(-(-m1), m1);
   VERIFY_IS_EQUAL(-m2 + m1 + m2, m1);
@@ -60,26 +71,36 @@ void integer_type_tests(const MatrixType& m) {
   SquareMatrixType identity = SquareMatrixType::Identity(rows, rows), square = SquareMatrixType::Random(rows, rows);
   VectorType v1(rows), v2 = VectorType::Random(rows), vzero = VectorType::Zero(rows);
 
-  m1 = MatrixType::Random(rows, cols);
-  if (m1 == mzero || m1 == m2) m1(0, 0) = m2(0, 0) + Scalar(1);
+  {
+    int guard = 0;
+    do {
+      m1 = MatrixType::Random(rows, cols);
+    } while ((m1 == mzero || m1 == m2) && (++guard) < 100);
+    VERIFY(guard < 100);
+  }
 
-  v1 = VectorType::Random(rows);
-  if (v1 == vzero || v1 == v2) v1(0) = v2(0) + Scalar(1);
+  {
+    int guard = 0;
+    do {
+      v1 = VectorType::Random(rows);
+    } while ((v1 == vzero || v1 == v2) && (++guard) < 100);
+    VERIFY(guard < 100);
+  }
 
-  VERIFY_IS_EQUAL(v1, v1);
+  VERIFY_IS_APPROX(v1, v1);
   VERIFY_IS_NOT_APPROX(v1, 2 * v1);
-  VERIFY_IS_EQUAL(vzero, v1 - v1);
-  VERIFY_IS_EQUAL(m1, m1);
+  VERIFY_IS_APPROX(vzero, v1 - v1);
+  VERIFY_IS_APPROX(m1, m1);
   VERIFY_IS_NOT_APPROX(m1, 2 * m1);
-  VERIFY_IS_EQUAL(mzero, m1 - m1);
+  VERIFY_IS_APPROX(mzero, m1 - m1);
 
-  VERIFY_IS_EQUAL(m3 = m1, m1);
+  VERIFY_IS_APPROX(m3 = m1, m1);
   MatrixType m4;
-  VERIFY_IS_EQUAL(m4 = m1, m1);
+  VERIFY_IS_APPROX(m4 = m1, m1);
 
   m3.real() = m1.real();
-  VERIFY_IS_EQUAL(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
-  VERIFY_IS_EQUAL(static_cast<const MatrixType&>(m3).real(), m1.real());
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), m1.real());
 
   // check == / != operators
   VERIFY(m1 == m1);
@@ -92,8 +113,10 @@ void integer_type_tests(const MatrixType& m) {
 
   // check linear structure
 
-  Scalar s1 = internal::random<Scalar>();
-  if (s1 == 0) s1 = Scalar(1);
+  Scalar s1;
+  do {
+    s1 = internal::random<Scalar>();
+  } while (s1 == 0);
 
   VERIFY_IS_EQUAL(m1 + m1, 2 * m1);
   VERIFY_IS_EQUAL(m1 + m2 - m1, m2);
@@ -111,10 +134,10 @@ void integer_type_tests(const MatrixType& m) {
 
   // check matrix product.
 
-  VERIFY_IS_EQUAL(identity * m1, m1);
-  VERIFY_IS_EQUAL(square * (m1 + m2), square * m1 + square * m2);
-  VERIFY_IS_EQUAL((m1 + m2).transpose() * square, m1.transpose() * square + m2.transpose() * square);
-  VERIFY_IS_EQUAL((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
+  VERIFY_IS_APPROX(identity * m1, m1);
+  VERIFY_IS_APPROX(square * (m1 + m2), square * m1 + square * m2);
+  VERIFY_IS_APPROX((m1 + m2).transpose() * square, m1.transpose() * square + m2.transpose() * square);
+  VERIFY_IS_APPROX((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
 }
 
 template <int>
diff --git a/test/jacobi.cpp b/test/jacobi.cpp
index a9fa1042a..76346049c 100644
--- a/test/jacobi.cpp
+++ b/test/jacobi.cpp
@@ -28,8 +28,10 @@ void jacobi(const MatrixType& m = MatrixType()) {
 
   {
     Index p = internal::random<Index>(0, rows - 1);
-    Index q = internal::random<Index>(0, rows - 2);
-    if (q >= p) ++q;
+    Index q;
+    do {
+      q = internal::random<Index>(0, rows - 1);
+    } while (q == p);
 
     MatrixType b = a;
     b.applyOnTheLeft(p, q, rot);
@@ -39,8 +41,10 @@ void jacobi(const MatrixType& m = MatrixType()) {
 
   {
     Index p = internal::random<Index>(0, cols - 1);
-    Index q = internal::random<Index>(0, cols - 2);
-    if (q >= p) ++q;
+    Index q;
+    do {
+      q = internal::random<Index>(0, cols - 1);
+    } while (q == p);
 
     MatrixType b = a;
     b.applyOnTheRight(p, q, rot);
diff --git a/test/linearstructure.cpp b/test/linearstructure.cpp
index d6c6bc396..80cf4c331 100644
--- a/test/linearstructure.cpp
+++ b/test/linearstructure.cpp
@@ -35,35 +35,35 @@ void linearStructure(const MatrixType& m) {
 
   Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
 
-  VERIFY_IS_EQUAL(-(-m1), m1);
-  VERIFY_IS_EQUAL(m1 + m1, 2 * m1);
+  VERIFY_IS_APPROX(-(-m1), m1);
+  VERIFY_IS_APPROX(m1 + m1, 2 * m1);
   VERIFY_IS_APPROX(m1 + m2 - m1, m2);
   VERIFY_IS_APPROX(-m2 + m1 + m2, m1);
-  VERIFY_IS_EQUAL(m1 * s1, s1 * m1);
+  VERIFY_IS_APPROX(m1 * s1, s1 * m1);
   VERIFY_IS_APPROX((m1 + m2) * s1, s1 * m1 + s1 * m2);
   VERIFY_IS_APPROX((-m1 + m2) * s1, -s1 * m1 + s1 * m2);
   m3 = m2;
   m3 += m1;
-  VERIFY_IS_EQUAL(m3, m1 + m2);
+  VERIFY_IS_APPROX(m3, m1 + m2);
   m3 = m2;
   m3 -= m1;
-  VERIFY_IS_EQUAL(m3, m2 - m1);
+  VERIFY_IS_APPROX(m3, m2 - m1);
   m3 = m2;
   m3 *= s1;
-  VERIFY_IS_EQUAL(m3, s1 * m2);
+  VERIFY_IS_APPROX(m3, s1 * m2);
   if (!NumTraits<Scalar>::IsInteger) {
     m3 = m2;
     m3 /= s1;
-    VERIFY_IS_EQUAL(m3, m2 / s1);
+    VERIFY_IS_APPROX(m3, m2 / s1);
   }
 
   // again, test operator() to check const-qualification
-  VERIFY_IS_EQUAL((-m1)(r, c), -(m1(r, c)));
-  VERIFY_IS_EQUAL((m1 - m2)(r, c), (m1(r, c)) - (m2(r, c)));
-  VERIFY_IS_EQUAL((m1 + m2)(r, c), (m1(r, c)) + (m2(r, c)));
-  VERIFY_IS_EQUAL((s1 * m1)(r, c), s1 * (m1(r, c)));
-  VERIFY_IS_EQUAL((m1 * s1)(r, c), (m1(r, c)) * s1);
-  if (!NumTraits<Scalar>::IsInteger) VERIFY_IS_EQUAL((m1 / s1)(r, c), (m1(r, c)) / s1);
+  VERIFY_IS_APPROX((-m1)(r, c), -(m1(r, c)));
+  VERIFY_IS_APPROX((m1 - m2)(r, c), (m1(r, c)) - (m2(r, c)));
+  VERIFY_IS_APPROX((m1 + m2)(r, c), (m1(r, c)) + (m2(r, c)));
+  VERIFY_IS_APPROX((s1 * m1)(r, c), s1 * (m1(r, c)));
+  VERIFY_IS_APPROX((m1 * s1)(r, c), (m1(r, c)) * s1);
+  if (!NumTraits<Scalar>::IsInteger) VERIFY_IS_APPROX((m1 / s1)(r, c), (m1(r, c)) / s1);
 
   // use .block to disable vectorization and compare to the vectorized version
   VERIFY_IS_APPROX(m1 + m1.block(0, 0, rows, cols), m1 + m1);
diff --git a/test/nullary.cpp b/test/nullary.cpp
index 7ea1c8259..71cf9cbea 100644
--- a/test/nullary.cpp
+++ b/test/nullary.cpp
@@ -219,9 +219,9 @@ void testMatrixType(const MatrixType& m) {
   A = MatrixType::Constant(rows, cols, s1);
   Index i = internal::random<Index>(0, rows - 1);
   Index j = internal::random<Index>(0, cols - 1);
-  VERIFY_IS_EQUAL(MatrixType::Constant(rows, cols, s1)(i, j), s1);
-  VERIFY_IS_EQUAL(MatrixType::Constant(rows, cols, s1).coeff(i, j), s1);
-  VERIFY_IS_EQUAL(A(i, j), s1);
+  VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, s1)(i, j), s1);
+  VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, s1).coeff(i, j), s1);
+  VERIFY_IS_APPROX(A(i, j), s1);
 }
 
 template <int>