diff --git a/include/base/libmesh_common.h b/include/base/libmesh_common.h
index 57c65bb38d..95356b7110 100644
--- a/include/base/libmesh_common.h
+++ b/include/base/libmesh_common.h
@@ -212,6 +212,15 @@ template <typename T>
 inline bool libmesh_isinf(std::complex<T> a)
 { return (std::isinf(std::real(a)) || std::isinf(std::imag(a))); }
 
+// std::isfinite() doesn't support complex, but we really want an
+// isfinite to support Number, at least in our own namespace
+template <typename T>
+inline bool isfinite(std::complex<T> a)
+{
+  using std::isfinite;
+  return (isfinite(std::real(a)) && isfinite(std::imag(a)));
+}
+
 // Define the value type for unknowns in simulations.
 // This is either Real or Complex, depending on how
 // the library was configures
diff --git a/include/numerics/dense_matrix.h b/include/numerics/dense_matrix.h
index 0cfa608e35..65367e384b 100644
--- a/include/numerics/dense_matrix.h
+++ b/include/numerics/dense_matrix.h
@@ -1218,6 +1218,18 @@ T DenseMatrix<T>::transpose (const unsigned int i,
 // }
 
 
+template <typename T>
+bool isfinite (const DenseMatrix<T> & var)
+{
+  using std::isfinite;
+  using libMesh::isfinite; // for T==complex
+  const auto m = var.m(), n = var.n();
+  for (auto i : make_range(m))
+    for (auto j : make_range(n))
+      if (!isfinite(var(i,j)))
+        return false;
+  return true;
+}
 
 
 } // namespace libMesh
diff --git a/include/numerics/dense_submatrix.h b/include/numerics/dense_submatrix.h
index c4454ca320..39860ebc40 100644
--- a/include/numerics/dense_submatrix.h
+++ b/include/numerics/dense_submatrix.h
@@ -229,6 +229,20 @@ T & DenseSubMatrix<T>::operator () (const unsigned int i,
 }
 
 
+template <typename T>
+bool isfinite (const DenseSubMatrix<T> & var)
+{
+  using std::isfinite;
+  using libMesh::isfinite; // for T==complex
+  const auto m = var.m(), n = var.n();
+  for (auto i : make_range(m))
+    for (auto j : make_range(n))
+      if (!isfinite(var(i,j)))
+        return false;
+  return true;
+}
+
+
 } // namespace libMesh
 
 
diff --git a/include/numerics/dense_vector.h b/include/numerics/dense_vector.h
index a5e3d39741..199c96c5e3 100644
--- a/include/numerics/dense_vector.h
+++ b/include/numerics/dense_vector.h
@@ -721,6 +721,21 @@ void DenseVector<T>::get_principal_subvector (unsigned int sub_n,
     dest(i) = _val[i];
 }
 
+
+template <typename T>
+bool isfinite (const DenseVector<T> & var)
+{
+  using std::isfinite;
+  using libMesh::isfinite; // for T==complex
+  for (auto i : make_range(var.size()))
+    if (!isfinite(var(i)))
+      return false;
+  return true;
+}
+
+
+
+
 } // namespace libMesh
 
 #ifdef LIBMESH_HAVE_METAPHYSICL
diff --git a/include/numerics/type_tensor.h b/include/numerics/type_tensor.h
index 470b745f12..173dc451a2 100644
--- a/include/numerics/type_tensor.h
+++ b/include/numerics/type_tensor.h
@@ -1435,6 +1435,20 @@ void TypeTensor<T>::print(std::ostream & os) const
 #endif
 }
 
+
+template <typename T>
+bool isfinite (const TypeTensor<T> & var)
+{
+  using std::isfinite;
+  using libMesh::isfinite; // for T==complex
+  for (unsigned int i=0; i<LIBMESH_DIM; i++)
+    for (unsigned int j=0; j<LIBMESH_DIM; j++)
+      if (!isfinite(var(i,j)))
+        return false;
+  return true;
+}
+
+
 template <typename T, typename T2>
 inline
 TypeTensor<typename CompareTypes<T, T2>::supertype>
diff --git a/include/numerics/type_vector.h b/include/numerics/type_vector.h
index 65bf6c3353..b0b95bdab8 100644
--- a/include/numerics/type_vector.h
+++ b/include/numerics/type_vector.h
@@ -1186,6 +1186,19 @@ void TypeVector<T>::print(std::ostream & os) const
 #endif
 }
 
+
+template <typename T>
+bool isfinite (const TypeVector<T> & var)
+{
+  using std::isfinite;
+  using libMesh::isfinite; // for T==complex
+  for (unsigned int i=0; i<LIBMESH_DIM; i++)
+    if (!isfinite(var(i)))
+      return false;
+  return true;
+}
+
+
 template <typename T>
 struct CompareTypes<TypeVector<T>, TypeVector<T>>
 {
diff --git a/tests/libmesh_cppunit.h b/tests/libmesh_cppunit.h
index 9c1e34af8a..80d312a619 100644
--- a/tests/libmesh_cppunit.h
+++ b/tests/libmesh_cppunit.h
@@ -19,12 +19,15 @@
          CPPUNIT_ASSERT_DOUBLES_EQUAL(expected,actual,tolerance)
 #endif
 
-#ifdef LIBMESH_USE_COMPLEX_NUMBERS
-# define LIBMESH_ASSERT_NUMBERS_EQUAL(expected,actual,tolerance) \
+# define LIBMESH_ASSERT_COMPLEX_EQUAL(expected,actual,tolerance) \
   do { \
     LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(expected),libMesh::libmesh_real(actual),tolerance); \
     LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_imag(expected),libMesh::libmesh_imag(actual),tolerance); \
   } while (0)
+
+#ifdef LIBMESH_USE_COMPLEX_NUMBERS
+# define LIBMESH_ASSERT_NUMBERS_EQUAL(expected,actual,tolerance) \
+         LIBMESH_ASSERT_COMPLEX_EQUAL(expected,actual,tolerance)
 #else
 # define LIBMESH_ASSERT_NUMBERS_EQUAL(expected,actual,tolerance) \
          LIBMESH_ASSERT_FP_EQUAL(expected,actual,tolerance)
diff --git a/tests/numerics/dense_matrix_test.C b/tests/numerics/dense_matrix_test.C
index ad89c27eff..7ee26a783d 100644
--- a/tests/numerics/dense_matrix_test.C
+++ b/tests/numerics/dense_matrix_test.C
@@ -1,5 +1,6 @@
 // libmesh includes
 #include <libmesh/dense_matrix.h>
+#include <libmesh/dense_submatrix.h>
 #include <libmesh/dense_vector.h>
 
 #ifdef LIBMESH_HAVE_PETSC
@@ -8,6 +9,7 @@
 
 #include "libmesh_cppunit.h"
 
+#include <limits>
 
 using namespace libMesh;
 
@@ -20,6 +22,7 @@ public:
 
   LIBMESH_CPPUNIT_TEST_SUITE(DenseMatrixTest);
 
+  CPPUNIT_TEST(testIsFinite);
   CPPUNIT_TEST(testOuterProduct);
   CPPUNIT_TEST(testSVD);
   CPPUNIT_TEST(testEVDreal);
@@ -32,6 +35,33 @@ public:
 
 private:
 
+  void testIsFinite()
+  {
+    LOG_UNIT_TEST;
+
+    DenseMatrix<Real> a(2, 2, {1, 2,
+                               3, 4});
+    CPPUNIT_ASSERT(isfinite(a));
+
+    DenseVector<Real> diag = a.diagonal();
+    CPPUNIT_ASSERT(isfinite(diag));
+
+    DenseSubMatrix suba1(a,0,0,1,1);
+    CPPUNIT_ASSERT(isfinite(suba1));
+
+    DenseSubMatrix suba2(a,1,1,1,1);
+    CPPUNIT_ASSERT(isfinite(suba2));
+
+    a(0, 0) = std::numeric_limits<Real>::infinity();
+    CPPUNIT_ASSERT(!isfinite(a));
+    CPPUNIT_ASSERT(!isfinite(suba1));
+    CPPUNIT_ASSERT(isfinite(suba2));
+
+    CPPUNIT_ASSERT(isfinite(diag));
+    diag = a.diagonal();
+    CPPUNIT_ASSERT(!isfinite(diag));
+  }
+
   void testOuterProduct()
   {
     LOG_UNIT_TEST;
diff --git a/tests/numerics/type_tensor_test.C b/tests/numerics/type_tensor_test.C
index 5c2d88e94b..fa9875cecb 100644
--- a/tests/numerics/type_tensor_test.C
+++ b/tests/numerics/type_tensor_test.C
@@ -23,6 +23,7 @@ public:
   CPPUNIT_TEST(testRotation);
 #endif
   CPPUNIT_TEST(testRowCol);
+  CPPUNIT_TEST(testIsFinite);
   CPPUNIT_TEST(testIsZero);
   CPPUNIT_TEST(testIsHPD);
 #ifdef LIBMESH_HAVE_METAPHYSICL
@@ -91,6 +92,21 @@ private:
     LIBMESH_ASSERT_FP_EQUAL(28, product(2, 2), tol);
   }
 
+  void testIsFinite()
+  {
+    LOG_UNIT_TEST;
+
+    {
+      TensorValue<double> tensor;
+      CPPUNIT_ASSERT(isfinite(tensor));
+    }
+    {
+      TensorValue<double> tensor(0,1,0,2,3);
+      tensor(0,0) = std::numeric_limits<double>::infinity();
+      CPPUNIT_ASSERT(!isfinite(tensor));
+    }
+  }
+
   void testIsZero()
   {
     LOG_UNIT_TEST;
diff --git a/tests/numerics/type_vector_test.h b/tests/numerics/type_vector_test.h
index 1a8e6afb8a..b6279b3ecf 100644
--- a/tests/numerics/type_vector_test.h
+++ b/tests/numerics/type_vector_test.h
@@ -30,6 +30,7 @@
   CPPUNIT_TEST( testVectorAddAssign );          \
   CPPUNIT_TEST( testVectorSubAssign );          \
                                                 \
+  CPPUNIT_TEST( testIsFinite );                 \
   CPPUNIT_TEST( testIsZero );                   \
   CPPUNIT_TEST( testSolidAngle );               \
   CPPUNIT_TEST( testCircumcenter );             \
@@ -179,12 +180,12 @@ class TypeVectorTestBase : public CppUnit::TestCase {
 
     DerivedClass avector = 0;
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , avector(i) , TOLERANCE*TOLERANCE );
 
     DerivedClass bvector = 2.0;
-    LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , bvector(0) , TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , bvector(0) , TOLERANCE*TOLERANCE );
     for (int i = 1; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , bvector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , bvector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testScalarMult()
@@ -193,9 +194,9 @@ class TypeVectorTestBase : public CppUnit::TestCase {
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
     {
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 5.0 , ((*m_1_1_1)*5.0)(i) , TOLERANCE*TOLERANCE );
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 5.0 , outer_product(*m_1_1_1,5.0)(i) , TOLERANCE*TOLERANCE );
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 5.0 , outer_product(5.0,*m_1_1_1)(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 5.0 , ((*m_1_1_1)*5.0)(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 5.0 , outer_product(*m_1_1_1,5.0)(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 5.0 , outer_product(5.0,*m_1_1_1)(i) , TOLERANCE*TOLERANCE );
     }
   }
 
@@ -204,7 +205,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     LOG_UNIT_TEST;
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 1/Real(5) , ((*m_1_1_1)/5.0)(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 1/Real(5) , ((*m_1_1_1)/5.0)(i) , TOLERANCE*TOLERANCE );
   }
 
   void testScalarMultAssign()
@@ -215,7 +216,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     avector*=5.0;
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 5.0 , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 5.0 , avector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testScalarDivAssign()
@@ -226,18 +227,18 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     avector/=5.0;
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 1/Real(5) , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 1/Real(5) , avector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorAdd()
   {
     LOG_UNIT_TEST;
 
-    LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , ((*m_1_1_1)+(*m_n1_1_n1))(0) , TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , ((*m_1_1_1)+(*m_n1_1_n1))(0) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 1)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , ((*m_1_1_1)+(*m_n1_1_n1))(1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , ((*m_1_1_1)+(*m_n1_1_n1))(1) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 2)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , ((*m_1_1_1)+(*m_n1_1_n1))(2) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , ((*m_1_1_1)+(*m_n1_1_n1))(2) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorAddScaled()
@@ -248,18 +249,18 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     avector.add_scaled((*m_1_1_1),0.5);
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 1.5 , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 1.5 , avector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorSub()
   {
     LOG_UNIT_TEST;
 
-    LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , ((*m_1_1_1)-(*m_n1_1_n1))(0) , TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , ((*m_1_1_1)-(*m_n1_1_n1))(0) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 1)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , ((*m_1_1_1)-(*m_n1_1_n1))(1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , ((*m_1_1_1)-(*m_n1_1_n1))(1) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 2)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , ((*m_1_1_1)-(*m_n1_1_n1))(2) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , ((*m_1_1_1)-(*m_n1_1_n1))(2) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorMult()
@@ -267,9 +268,9 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     LOG_UNIT_TEST;
 
     if (LIBMESH_DIM == 2)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , (*m_1_1_1)*(*m_n1_1_n1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , (*m_1_1_1)*(*m_n1_1_n1) , TOLERANCE*TOLERANCE );
     else
-      LIBMESH_ASSERT_NUMBERS_EQUAL( -1.0 , (*m_1_1_1)*(*m_n1_1_n1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( -1.0 , (*m_1_1_1)*(*m_n1_1_n1) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorAddAssign()
@@ -280,7 +281,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     avector+=(*m_1_1_1);
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , avector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorSubAssign()
@@ -290,11 +291,11 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     DerivedClass avector {*basem_1_1_1};
     avector-=(*m_n1_1_n1);
 
-    LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , avector(0) , TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , avector(0) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 1)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , avector(1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , avector(1) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 2)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , avector(2) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , avector(2) , TOLERANCE*TOLERANCE );
   }
 
   void testValueBase()
@@ -322,6 +323,29 @@ class TypeVectorTestBase : public CppUnit::TestCase {
       CPPUNIT_ASSERT_EQUAL( T(0), avector(i));
   }
 
+  void testIsFinite()
+  {
+    LOG_UNIT_TEST;
+
+    {
+#if LIBMESH_DIM > 2
+      DerivedClass avector(0,0,0);
+#elif LIBMESH_DIM > 1
+      DerivedClass avector(0,0);
+#else
+      DerivedClass avector(0);
+#endif
+      CPPUNIT_ASSERT(isfinite(avector));
+
+      // numeric_limits isn't specialized for complex, but float
+      // infinity promotes seamlessly to complex<double> etc.
+      avector(0) =
+        std::numeric_limits<float>::infinity();
+      CPPUNIT_ASSERT(!isfinite(avector));
+    }
+  }
+
+
   void testIsZero()
   {
     LOG_UNIT_TEST;
@@ -353,7 +377,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     LOG_UNIT_TEST;
 
     const DerivedClass xvec(1.3);
-    LIBMESH_ASSERT_NUMBERS_EQUAL( solid_angle(xvec, xvec, xvec), 0, TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( solid_angle(xvec, xvec, xvec), 0, TOLERANCE*TOLERANCE );
 
 #if LIBMESH_DIM > 1
     // This is ambiguous with --enable-complex builds?  We really need
@@ -368,18 +392,18 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     xypdiag(0) = 0.8; xypdiag(1) = -.8;
 
     // Yeah, nothing subtends a non-zero solid angle in 2D either.
-    LIBMESH_ASSERT_NUMBERS_EQUAL( solid_angle(xvec, xvec, yvec), 0, TOLERANCE*TOLERANCE );
-    LIBMESH_ASSERT_NUMBERS_EQUAL( solid_angle(xvec, yvec, xydiag), 0, TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( solid_angle(xvec, xvec, yvec), 0, TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( solid_angle(xvec, yvec, xydiag), 0, TOLERANCE*TOLERANCE );
 #endif
 
 #if LIBMESH_DIM > 2
     const DerivedClass zvec(0.,0.,1.1),
                        xzdiag(0.,.7,.7);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(solid_angle(xydiag, yvec, zvec),
+    LIBMESH_ASSERT_COMPLEX_EQUAL(solid_angle(xydiag, yvec, zvec),
                                 libMesh::pi/4, TOLERANCE*TOLERANCE);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(solid_angle(xvec, yvec, xzdiag),
+    LIBMESH_ASSERT_COMPLEX_EQUAL(solid_angle(xvec, yvec, xzdiag),
                                 libMesh::pi/4, TOLERANCE*TOLERANCE);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(solid_angle(xypdiag, xydiag, zvec),
+    LIBMESH_ASSERT_COMPLEX_EQUAL(solid_angle(xypdiag, xydiag, zvec),
                                 libMesh::pi/2, TOLERANCE*TOLERANCE);
 
     // Icosahedron coordinates are a nice analytic test
@@ -387,7 +411,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     const DerivedClass icosa1(1., golden, 0.),
                        icosa2(-1., golden, 0.),
                        icosa3(0., 1., golden);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(solid_angle(icosa1, icosa2, icosa3),
+    LIBMESH_ASSERT_COMPLEX_EQUAL(solid_angle(icosa1, icosa2, icosa3),
                                 libMesh::pi/5, TOLERANCE*TOLERANCE);
 #endif
   }
@@ -400,20 +424,20 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     DerivedClass twoone(2); twoone(1) = 1;
 
     auto cc1 = circumcenter(origin, e_x, twoone);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc1(0), 0.5, TOLERANCE*TOLERANCE);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc1(1), 1.5, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc1(0), 0.5, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc1(1), 1.5, TOLERANCE*TOLERANCE);
 
 #if LIBMESH_DIM > 2
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc1(2), 0, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc1(2), 0, TOLERANCE*TOLERANCE);
     const DerivedClass twozeroone(2,0,1);
     auto cc2 = circumcenter(origin, e_x, twozeroone);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc2(0), 0.5, TOLERANCE*TOLERANCE);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc2(1), 0, TOLERANCE*TOLERANCE);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc2(2), 1.5, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc2(0), 0.5, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc2(1), 0, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc2(2), 1.5, TOLERANCE*TOLERANCE);
     auto cc3 = circumcenter(e_x, twoone, twozeroone);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc3(0), Real(5)/3, TOLERANCE*TOLERANCE);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc3(1), Real(1)/3, TOLERANCE*TOLERANCE);
-    LIBMESH_ASSERT_NUMBERS_EQUAL(cc3(2), Real(1)/3, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc3(0), Real(5)/3, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc3(1), Real(1)/3, TOLERANCE*TOLERANCE);
+    LIBMESH_ASSERT_COMPLEX_EQUAL(cc3(2), Real(1)/3, TOLERANCE*TOLERANCE);
 #endif
   }
 
@@ -464,7 +488,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     LOG_UNIT_TEST;
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 5.0 , ((*basem_1_1_1)*5.0)(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 5.0 , ((*basem_1_1_1)*5.0)(i) , TOLERANCE*TOLERANCE );
   }
 
   void testScalarDivBase()
@@ -472,7 +496,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     LOG_UNIT_TEST;
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 1/Real(5) , ((*basem_1_1_1)/5.0)(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 1/Real(5) , ((*basem_1_1_1)/5.0)(i) , TOLERANCE*TOLERANCE );
   }
 
   void testScalarMultAssignBase()
@@ -483,7 +507,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     avector*=5.0;
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 5.0 , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 5.0 , avector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testScalarDivAssignBase()
@@ -494,18 +518,18 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     avector/=5.0;
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 1/Real(5) , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 1/Real(5) , avector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorAddBase()
   {
     LOG_UNIT_TEST;
 
-    LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , ((*basem_1_1_1)+(*basem_n1_1_n1))(0) , TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , ((*basem_1_1_1)+(*basem_n1_1_n1))(0) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 1)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , ((*basem_1_1_1)+(*basem_n1_1_n1))(1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , ((*basem_1_1_1)+(*basem_n1_1_n1))(1) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 2)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , ((*basem_1_1_1)+(*basem_n1_1_n1))(2) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , ((*basem_1_1_1)+(*basem_n1_1_n1))(2) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorAddScaledBase()
@@ -516,18 +540,18 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     avector.add_scaled((*basem_1_1_1),0.5);
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 1.5 , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 1.5 , avector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorSubBase()
   {
     LOG_UNIT_TEST;
 
-    LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , ((*basem_1_1_1)-(*basem_n1_1_n1))(0) , TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , ((*basem_1_1_1)-(*basem_n1_1_n1))(0) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 1)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , ((*basem_1_1_1)-(*basem_n1_1_n1))(1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , ((*basem_1_1_1)-(*basem_n1_1_n1))(1) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 2)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , ((*basem_1_1_1)-(*basem_n1_1_n1))(2) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , ((*basem_1_1_1)-(*basem_n1_1_n1))(2) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorMultBase()
@@ -535,9 +559,9 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     LOG_UNIT_TEST;
 
     if (LIBMESH_DIM == 2)
-      LIBMESH_ASSERT_NUMBERS_EQUAL(  0.0 , (*basem_1_1_1)*(*basem_n1_1_n1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL(  0.0 , (*basem_1_1_1)*(*basem_n1_1_n1) , TOLERANCE*TOLERANCE );
     else
-      LIBMESH_ASSERT_NUMBERS_EQUAL( -1.0 , (*basem_1_1_1)*(*basem_n1_1_n1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( -1.0 , (*basem_1_1_1)*(*basem_n1_1_n1) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorAddAssignBase()
@@ -548,7 +572,7 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     avector+=(*basem_1_1_1);
 
     for (int i = 0; i != LIBMESH_DIM; ++i)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , avector(i) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , avector(i) , TOLERANCE*TOLERANCE );
   }
 
   void testVectorSubAssignBase()
@@ -558,11 +582,11 @@ class TypeVectorTestBase : public CppUnit::TestCase {
     TypeVector<T> avector(*m_1_1_1);
     avector-=(*basem_n1_1_n1);
 
-    LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , avector(0) , TOLERANCE*TOLERANCE );
+    LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , avector(0) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 1)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 0.0 , avector(1) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 0.0 , avector(1) , TOLERANCE*TOLERANCE );
     if (LIBMESH_DIM > 2)
-      LIBMESH_ASSERT_NUMBERS_EQUAL( 2.0 , avector(2) , TOLERANCE*TOLERANCE );
+      LIBMESH_ASSERT_COMPLEX_EQUAL( 2.0 , avector(2) , TOLERANCE*TOLERANCE );
   }
 
   void testReplaceAlgebraicType()
diff --git a/tests/numerics/vector_value_test.C b/tests/numerics/vector_value_test.C
index 3dde99f512..ed0118102b 100644
--- a/tests/numerics/vector_value_test.C
+++ b/tests/numerics/vector_value_test.C
@@ -49,7 +49,7 @@ public:
     this->libmesh_suite_name = "ComplexVectorValueTest";
   }
 
-  LIBMESH_CPPUNIT_TEST_SUITE( NumberVectorValueTest );
+  CPPUNIT_TEST_SUITE( ComplexVectorValueTest );
 
   VECTORVALUETEST