Report the failure context in the solver and preprocessor tests

Failing solver, preprocessor and tiny solver tests do not report why
the solve or the preprocessing failed, and several tests use the
deprecated gtest tuple aliases, placeholder names or a misspelled
suite name.

Stream the error messages and the compared values into the assertions,
use the standard tuple and give the tests descriptive names.

Change-Id: I164448f4b6abfb9da0cd1d11a063360b26154b75

internal/ceres/block_jacobi_preconditioner_test.cc

diff --git a/internal/ceres/block_jacobi_preconditioner_test.cc b/internal/ceres/block_jacobi_preconditioner_test.cc
index ca19a0d..98ddca1 100644
--- a/internal/ceres/block_jacobi_preconditioner_test.cc
+++ b/internal/ceres/block_jacobi_preconditioner_test.cc
@@ -42,7 +42,7 @@
 
 namespace ceres::internal {
 
-TEST(BlockSparseJacobiPreconditioner, _) {
+TEST(BlockSparseJacobiPreconditioner, InvertsDiagonalBlocksOfHessian) {
   constexpr int kNumtrials = 10;
   BlockSparseMatrix::RandomMatrixOptions options;
   options.num_col_blocks = 3;
@@ -95,7 +95,7 @@
   }
 }
 
-TEST(CompressedRowSparseJacobiPreconditioner, _) {
+TEST(CompressedRowSparseJacobiPreconditioner, InvertsDiagonalBlocksOfHessian) {
   constexpr int kNumtrials = 10;
   CompressedRowSparseMatrix::RandomMatrixOptions options;
   options.num_col_blocks = 3;

internal/ceres/compressed_col_sparse_matrix_utils_test.cc

diff --git a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
index 5e0601f..a5406a5 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
@@ -41,7 +41,7 @@
 
 namespace ceres::internal {
 
-TEST(_, BlockPermutationToScalarPermutation) {
+TEST(CompressedColSparseMatrixUtils, BlockPermutationToScalarPermutation) {
   //  Block structure
   //  0  --1-  ---2---  ---3---  4
   // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
@@ -77,7 +77,7 @@
   }
 }
 
-TEST(_, ScalarMatrixToBlockMatrix) {
+TEST(CompressedColSparseMatrixUtils, ScalarMatrixToBlockMatrix) {
   // Block sparsity.
   //
   //     [1 2 3 2]

internal/ceres/conjugate_gradients_solver_test.cc

diff --git a/internal/ceres/conjugate_gradients_solver_test.cc b/internal/ceres/conjugate_gradients_solver_test.cc
index 4727564..f54e19c 100644
--- a/internal/ceres/conjugate_gradients_solver_test.cc
+++ b/internal/ceres/conjugate_gradients_solver_test.cc
@@ -87,7 +87,7 @@
   ASSERT_DOUBLE_EQ(3, x(2));
 }
 
-TEST(ConjuateGradientTest, Solves3x3SymmetricSystem) {
+TEST(ConjugateGradientTest, Solves3x3SymmetricSystem) {
   std::unique_ptr<TripletSparseMatrix> A(new TripletSparseMatrix(3, 3, 9));
   Vector b(3);
   Vector x(3);

internal/ceres/dense_cholesky_test.cc

diff --git a/internal/ceres/dense_cholesky_test.cc b/internal/ceres/dense_cholesky_test.cc
index 161b57c..d5d5eec 100644
--- a/internal/ceres/dense_cholesky_test.cc
+++ b/internal/ceres/dense_cholesky_test.cc
@@ -34,6 +34,7 @@
 #include <memory>
 #include <sstream>
 #include <string>
+#include <tuple>
 #include <utility>
 
 #include "Eigen/Core"
@@ -49,7 +50,7 @@
 
 namespace ceres::internal {
 
-using Param = ::testing::tuple<DenseLinearAlgebraLibraryType, bool>;
+using Param = std::tuple<DenseLinearAlgebraLibraryType, bool>;
 constexpr bool kMixedPrecision = true;
 constexpr bool kFullPrecision = false;
 
@@ -58,8 +59,8 @@
 std::string ParamInfoToString(testing::TestParamInfo<Param> info) {
   Param param = info.param;
   std::stringstream ss;
-  ss << DenseLinearAlgebraLibraryTypeToString(::testing::get<0>(param)) << "_"
-     << (::testing::get<1>(param) ? "MixedPrecision" : "FullPrecision");
+  ss << DenseLinearAlgebraLibraryTypeToString(std::get<0>(param)) << "_"
+     << (std::get<1>(param) ? "MixedPrecision" : "FullPrecision");
   return ss.str();
 }
 }  // namespace
@@ -81,8 +82,8 @@
   std::string error;
   ASSERT_TRUE(context.InitCuda(&error)) << error;
 #endif  // CERES_NO_CUDA
-  options.dense_linear_algebra_library_type = ::testing::get<0>(GetParam());
-  options.use_mixed_precision_solves = ::testing::get<1>(GetParam());
+  options.dense_linear_algebra_library_type = std::get<0>(GetParam());
+  options.use_mixed_precision_solves = std::get<1>(GetParam());
   const int kNumRefinementSteps = 4;
   if (options.use_mixed_precision_solves) {
     options.max_num_refinement_iterations = kNumRefinementSteps;

internal/ceres/dense_linear_solver_test.cc

diff --git a/internal/ceres/dense_linear_solver_test.cc b/internal/ceres/dense_linear_solver_test.cc
index f764713..3556788 100644
--- a/internal/ceres/dense_linear_solver_test.cc
+++ b/internal/ceres/dense_linear_solver_test.cc
@@ -32,6 +32,7 @@
 #include <memory>
 #include <sstream>
 #include <string>
+#include <tuple>
 
 #include "ceres/casts.h"
 #include "ceres/context_impl.h"
@@ -52,21 +53,21 @@
 static std::string ParamInfoToString(testing::TestParamInfo<Param> info) {
   Param param = info.param;
   std::stringstream ss;
-  ss << LinearSolverTypeToString(::testing::get<0>(param)) << "_"
-     << DenseLinearAlgebraLibraryTypeToString(::testing::get<1>(param)) << "_"
-     << (::testing::get<2>(param) ? "Regularized" : "Unregularized") << "_"
-     << ::testing::get<3>(param);
+  ss << LinearSolverTypeToString(std::get<0>(param)) << "_"
+     << DenseLinearAlgebraLibraryTypeToString(std::get<1>(param)) << "_"
+     << (std::get<2>(param) ? "Regularized" : "Unregularized") << "_"
+     << std::get<3>(param);
   return ss.str();
 }
 
 class DenseLinearSolverTest : public ::testing::TestWithParam<Param> {};
 
-TEST_P(DenseLinearSolverTest, _) {
+TEST_P(DenseLinearSolverTest, SolvesNormalEquations) {
   Param param = GetParam();
-  const bool regularized = testing::get<2>(param);
+  const bool regularized = std::get<2>(param);
 
   std::unique_ptr<LinearLeastSquaresProblem> problem =
-      CreateLinearLeastSquaresProblemFromId(testing::get<3>(param));
+      CreateLinearLeastSquaresProblemFromId(std::get<3>(param));
   DenseSparseMatrix lhs(*down_cast<TripletSparseMatrix*>(problem->A.get()));
 
   const int num_cols = lhs.num_cols();
@@ -76,8 +77,8 @@
   rhs.head(num_rows) = ConstVectorRef(problem->b.get(), num_rows);
 
   LinearSolver::Options options;
-  options.type = ::testing::get<0>(param);
-  options.dense_linear_algebra_library_type = ::testing::get<1>(param);
+  options.type = std::get<0>(param);
+  options.dense_linear_algebra_library_type = std::get<1>(param);
   ContextImpl context;
   options.context = &context;
   std::unique_ptr<LinearSolver> solver(LinearSolver::Create(options));

internal/ceres/line_search_preprocessor_test.cc

diff --git a/internal/ceres/line_search_preprocessor_test.cc b/internal/ceres/line_search_preprocessor_test.cc
index 7119973..c3f7e23 100644
--- a/internal/ceres/line_search_preprocessor_test.cc
+++ b/internal/ceres/line_search_preprocessor_test.cc
@@ -47,7 +47,7 @@
   options.minimizer_type = LINE_SEARCH;
   LineSearchPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp)) << pp.error;
 }
 
 TEST(LineSearchPreprocessor, ProblemWithInvalidParameterBlock) {
@@ -104,7 +104,7 @@
 
   LineSearchPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp)) << pp.error;
 }
 
 template <int kNumResiduals, int... Ns>
@@ -130,9 +130,9 @@
 
   LineSearchPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp)) << pp.error;
   EXPECT_EQ(pp.evaluator_options.linear_solver_type, CGNR);
-  EXPECT_TRUE(pp.evaluator.get() != nullptr);
+  EXPECT_NE(pp.evaluator.get(), nullptr);
 }
 
 }  // namespace ceres::internal

internal/ceres/partitioned_matrix_view_test.cc

diff --git a/internal/ceres/partitioned_matrix_view_test.cc b/internal/ceres/partitioned_matrix_view_test.cc
index 72ad1c4..0ab744a 100644
--- a/internal/ceres/partitioned_matrix_view_test.cc
+++ b/internal/ceres/partitioned_matrix_view_test.cc
@@ -34,6 +34,7 @@
 #include <random>
 #include <sstream>
 #include <string>
+#include <tuple>
 #include <vector>
 
 #include "absl/log/check.h"
@@ -50,20 +51,20 @@
 const double kEpsilon = 1e-14;
 
 // Param = <problem_id, num_threads>
-using Param = ::testing::tuple<int, int>;
+using Param = std::tuple<int, int>;
 
 static std::string ParamInfoToString(testing::TestParamInfo<Param> info) {
   Param param = info.param;
   std::stringstream ss;
-  ss << ::testing::get<0>(param) << "_" << ::testing::get<1>(param);
+  ss << std::get<0>(param) << "_" << std::get<1>(param);
   return ss.str();
 }
 
 class PartitionedMatrixViewTest : public ::testing::TestWithParam<Param> {
  protected:
   void SetUp() final {
-    const int problem_id = ::testing::get<0>(GetParam());
-    const int num_threads = ::testing::get<1>(GetParam());
+    const int problem_id = std::get<0>(GetParam());
+    const int num_threads = std::get<1>(GetParam());
     auto problem = CreateLinearLeastSquaresProblemFromId(problem_id);
     ASSERT_TRUE(problem != nullptr);
     A_ = std::move(problem->A);

internal/ceres/reorder_program_test.cc

diff --git a/internal/ceres/reorder_program_test.cc b/internal/ceres/reorder_program_test.cc
index a2cbeb3..33f17c4 100644
--- a/internal/ceres/reorder_program_test.cc
+++ b/internal/ceres/reorder_program_test.cc
@@ -68,7 +68,7 @@
 class BinaryCostFunction : public MockCostFunctionBase<2, 1, 1> {};
 class TernaryCostFunction : public MockCostFunctionBase<2, 1, 1, 1> {};
 
-TEST(_, ReorderResidualBlockNormalFunction) {
+TEST(ReorderProgram, ReorderResidualBlockNormalFunction) {
   ProblemImpl problem;
   double x;
   double y;
@@ -122,7 +122,7 @@
   }
 }
 
-TEST(_, ApplyOrderingOrderingTooSmall) {
+TEST(ReorderProgram, ApplyOrderingOrderingTooSmall) {
   ProblemImpl problem;
   double x;
   double y;
@@ -142,7 +142,7 @@
       problem.parameter_map(), linear_solver_ordering, &program, &message));
 }
 
-TEST(_, ApplyOrderingNormal) {
+TEST(ReorderProgram, ApplyOrderingNormal) {
   ProblemImpl problem;
   double x;
   double y;
@@ -175,7 +175,7 @@
 // group. This is essential for deterministic behavior - without preserving
 // the original order, the ordering would depend on pointer addresses which
 // can vary between runs due to ASLR or different memory allocation patterns.
-TEST(_, ApplyOrderingPreservesOrderWithinGroups) {
+TEST(ReorderProgram, ApplyOrderingPreservesOrderWithinGroups) {
   // Use heap-allocated parameter blocks to ensure pointer addresses are
   // not in any predictable order (simulating what happens in real usage).
   std::vector<std::unique_ptr<double[]>> params;
@@ -318,7 +318,7 @@
 }
 #endif  // CERES_NO_SUITESPARSE
 
-TEST(_, ReorderResidualBlocksbyPartition) {
+TEST(ReorderProgram, ReorderResidualBlocksbyPartition) {
   ProblemImpl problem;
   double x;
   double y;

internal/ceres/solver_test.cc

diff --git a/internal/ceres/solver_test.cc b/internal/ceres/solver_test.cc
index 0623903..22043f9 100644
--- a/internal/ceres/solver_test.cc
+++ b/internal/ceres/solver_test.cc
@@ -43,10 +43,14 @@
 #include "ceres/problem.h"
 #include "ceres/problem_impl.h"
 #include "ceres/sized_cost_function.h"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
 
+using ::testing::Each;
+using ::testing::IsEmpty;
+
 TEST(SolverOptions, DefaultTrustRegionOptionsAreValid) {
   Solver::Options options;
   options.minimizer_type = TRUST_REGION;
@@ -116,9 +120,7 @@
   num_iterations =
       summary.num_successful_steps + summary.num_unsuccessful_steps;
   EXPECT_GT(num_iterations, 1);
-  for (double value : callback.x_values) {
-    EXPECT_EQ(50.0, value);
-  }
+  EXPECT_THAT(callback.x_values, Each(50.0));
 
   // Second: update_state_every_iteration=true, evaluation_callback=nullptr.
   x = 50.0;
@@ -128,8 +130,9 @@
   num_iterations =
       summary.num_successful_steps + summary.num_unsuccessful_steps;
   EXPECT_GT(num_iterations, 1);
-  EXPECT_EQ(original_x, callback.x_values[0]);
-  EXPECT_NE(original_x, callback.x_values[1]);
+  ASSERT_GE(callback.x_values.size(), 2);
+  EXPECT_EQ(callback.x_values[0], original_x);
+  EXPECT_NE(callback.x_values[1], original_x);
 }
 
 TEST(Solver, UpdateStateEveryIterationOptionWithEvaluationCallback) {
@@ -160,8 +163,9 @@
   num_iterations =
       summary.num_successful_steps + summary.num_unsuccessful_steps;
   EXPECT_GT(num_iterations, 1);
-  EXPECT_EQ(original_x, callback.x_values[0]);
-  EXPECT_NE(original_x, callback.x_values[1]);
+  ASSERT_GE(callback.x_values.size(), 2);
+  EXPECT_EQ(callback.x_values[0], original_x);
+  EXPECT_NE(callback.x_values[1], original_x);
 
   // Second: update_state_every_iteration=false, evaluation_callback=!nullptr.
   x = 50.0;
@@ -171,8 +175,9 @@
   num_iterations =
       summary.num_successful_steps + summary.num_unsuccessful_steps;
   EXPECT_GT(num_iterations, 1);
-  EXPECT_EQ(original_x, callback.x_values[0]);
-  EXPECT_NE(original_x, callback.x_values[1]);
+  ASSERT_GE(callback.x_values.size(), 2);
+  EXPECT_EQ(callback.x_values[0], original_x);
+  EXPECT_NE(callback.x_values[1], original_x);
 }
 
 TEST(Solver, CantMixEvaluationCallbackWithInnerIterations) {
@@ -335,11 +340,11 @@
   Solver::Options options;
   Solver::Summary summary;
   Solve(options, &problem, &summary);
-  EXPECT_TRUE(summary.IsSolutionUsable());
+  EXPECT_TRUE(summary.IsSolutionUsable()) << summary.message;
   EXPECT_EQ(summary.fixed_cost, expected_cost);
   EXPECT_EQ(summary.initial_cost, expected_cost);
   EXPECT_EQ(summary.final_cost, expected_cost);
-  EXPECT_EQ(summary.iterations.size(), 0);
+  EXPECT_THAT(summary.iterations, IsEmpty());
 }
 
 struct LinearCostFunction {
@@ -470,22 +475,22 @@
   std::string message;
   Solver::Options options;
   options.linear_solver_type = DENSE_NORMAL_CHOLESKY;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dense_linear_algebra_library_type = EIGEN;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.use_mixed_precision_solves = true;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   if (IsDenseLinearAlgebraLibraryTypeAvailable(LAPACK)) {
     options.use_mixed_precision_solves = false;
     options.dense_linear_algebra_library_type = LAPACK;
 
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
     options.use_mixed_precision_solves = true;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   } else {
     options.use_mixed_precision_solves = false;
     options.dense_linear_algebra_library_type = LAPACK;
@@ -500,7 +505,7 @@
 
   options.use_mixed_precision_solves = false;
   options.dense_linear_algebra_library_type = EIGEN;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.use_mixed_precision_solves = true;
   EXPECT_FALSE(options.IsValid(&message));
@@ -508,7 +513,7 @@
   if (IsDenseLinearAlgebraLibraryTypeAvailable(LAPACK)) {
     options.use_mixed_precision_solves = false;
     options.dense_linear_algebra_library_type = LAPACK;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
     options.use_mixed_precision_solves = true;
     EXPECT_FALSE(options.IsValid(&message));
   } else {
@@ -536,7 +541,7 @@
   options.use_mixed_precision_solves = false;
   options.dynamic_sparsity = false;
   if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   } else {
     EXPECT_FALSE(options.IsValid(&message));
   }
@@ -544,15 +549,15 @@
   if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = true;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   }
 
 #ifndef CERES_NO_EIGEN_METIS
@@ -560,19 +565,19 @@
   if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = true;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   }
 #else
   options.linear_solver_ordering_type = NESDIS;
@@ -593,7 +598,7 @@
   options.dynamic_sparsity = false;
   if (IsSparseLinearAlgebraLibraryTypeAvailable(
           options.sparse_linear_algebra_library_type)) {
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   } else {
     EXPECT_FALSE(options.IsValid(&message));
   }
@@ -605,19 +610,19 @@
 #ifdef CERES_NO_CHOLMOD_FLOAT
     EXPECT_FALSE(options.IsValid(&message));
 #else
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 #endif
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = true;
 #ifdef CERES_NO_CHOLMOD_FLOAT
     EXPECT_FALSE(options.IsValid(&message));
 #else
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 #endif
   }
 
@@ -627,26 +632,26 @@
           options.sparse_linear_algebra_library_type)) {
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
 #ifdef CERES_NO_CHOLMOD_FLOAT
     EXPECT_FALSE(options.IsValid(&message));
 #else
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 #endif
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = true;
 #ifdef CERES_NO_CHOLMOD_FLOAT
     EXPECT_FALSE(options.IsValid(&message));
 #else
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 #endif
   }
 #else
@@ -668,7 +673,7 @@
   options.dynamic_sparsity = false;
   if (IsSparseLinearAlgebraLibraryTypeAvailable(
           options.sparse_linear_algebra_library_type)) {
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   } else {
     EXPECT_FALSE(options.IsValid(&message));
   }
@@ -677,7 +682,7 @@
           options.sparse_linear_algebra_library_type)) {
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
@@ -693,11 +698,11 @@
           options.sparse_linear_algebra_library_type)) {
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
@@ -717,11 +722,11 @@
 
   options.use_mixed_precision_solves = false;
   options.dynamic_sparsity = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.use_mixed_precision_solves = true;
   options.dynamic_sparsity = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.use_mixed_precision_solves = true;
   options.dynamic_sparsity = true;
@@ -736,11 +741,11 @@
           options.dense_linear_algebra_library_type)) {
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = true;
@@ -770,7 +775,7 @@
   options.use_mixed_precision_solves = false;
   options.dynamic_sparsity = false;
   if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   } else {
     EXPECT_FALSE(options.IsValid(&message));
   }
@@ -778,7 +783,7 @@
   if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
@@ -794,11 +799,11 @@
   if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
@@ -827,7 +832,7 @@
   options.dynamic_sparsity = false;
   if (IsSparseLinearAlgebraLibraryTypeAvailable(
           options.sparse_linear_algebra_library_type)) {
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   } else {
     EXPECT_FALSE(options.IsValid(&message));
   }
@@ -839,7 +844,7 @@
 #ifdef CERES_NO_CHOLMOD_FLOAT
     EXPECT_FALSE(options.IsValid(&message));
 #else
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 #endif
 
     options.use_mixed_precision_solves = false;
@@ -857,14 +862,14 @@
           options.sparse_linear_algebra_library_type)) {
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
 #ifdef CERES_NO_CHOLMOD_FLOAT
     EXPECT_FALSE(options.IsValid(&message));
 #else
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 #endif
 
     options.use_mixed_precision_solves = false;
@@ -894,7 +899,7 @@
   options.dynamic_sparsity = false;
   if (IsSparseLinearAlgebraLibraryTypeAvailable(
           options.sparse_linear_algebra_library_type)) {
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
   } else {
     EXPECT_FALSE(options.IsValid(&message));
   }
@@ -903,7 +908,7 @@
           options.sparse_linear_algebra_library_type)) {
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
@@ -919,11 +924,11 @@
           options.sparse_linear_algebra_library_type)) {
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = true;
     options.dynamic_sparsity = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.use_mixed_precision_solves = false;
     options.dynamic_sparsity = true;
@@ -944,7 +949,7 @@
 
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;
@@ -957,7 +962,7 @@
   options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;
@@ -970,7 +975,7 @@
   options.sparse_linear_algebra_library_type = SUITE_SPARSE;
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;
@@ -983,7 +988,7 @@
   options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;
@@ -1017,7 +1022,7 @@
 
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;
@@ -1031,7 +1036,7 @@
 
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;
@@ -1045,7 +1050,7 @@
 
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;
@@ -1059,7 +1064,7 @@
 
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;
@@ -1113,7 +1118,7 @@
           options.sparse_linear_algebra_library_type)) {
     options.dynamic_sparsity = false;
     options.use_mixed_precision_solves = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.dynamic_sparsity = true;
     options.use_mixed_precision_solves = false;
@@ -1129,7 +1134,7 @@
           options.sparse_linear_algebra_library_type)) {
     options.dynamic_sparsity = false;
     options.use_mixed_precision_solves = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.dynamic_sparsity = true;
     options.use_mixed_precision_solves = false;
@@ -1145,7 +1150,7 @@
           options.sparse_linear_algebra_library_type)) {
     options.dynamic_sparsity = false;
     options.use_mixed_precision_solves = false;
-    EXPECT_TRUE(options.IsValid(&message));
+    EXPECT_TRUE(options.IsValid(&message)) << message;
 
     options.dynamic_sparsity = true;
     options.use_mixed_precision_solves = false;
@@ -1188,11 +1193,11 @@
   options.linear_solver_type = ITERATIVE_SCHUR;
   options.sparse_linear_algebra_library_type = NO_SPARSE;
   options.preconditioner_type = IDENTITY;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = SCHUR_JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = CLUSTER_JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = CLUSTER_TRIDIAGONAL;
@@ -1206,7 +1211,7 @@
   options.preconditioner_type = JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = SCHUR_JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = CLUSTER_JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = CLUSTER_TRIDIAGONAL;
@@ -1219,11 +1224,11 @@
   options.linear_solver_type = ITERATIVE_SCHUR;
   options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
   options.preconditioner_type = IDENTITY;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = SCHUR_JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = CLUSTER_JACOBI;
   EXPECT_EQ(options.IsValid(&message),
             IsSparseLinearAlgebraLibraryTypeAvailable(
@@ -1241,7 +1246,7 @@
   options.preconditioner_type = JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = SCHUR_JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = CLUSTER_JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = CLUSTER_TRIDIAGONAL;
@@ -1254,11 +1259,11 @@
   options.linear_solver_type = ITERATIVE_SCHUR;
   options.sparse_linear_algebra_library_type = SUITE_SPARSE;
   options.preconditioner_type = IDENTITY;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = SCHUR_JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = CLUSTER_JACOBI;
   EXPECT_EQ(options.IsValid(&message),
             IsSparseLinearAlgebraLibraryTypeAvailable(
@@ -1276,7 +1281,7 @@
   options.preconditioner_type = JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = SCHUR_JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = CLUSTER_JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = CLUSTER_TRIDIAGONAL;
@@ -1289,11 +1294,11 @@
   options.linear_solver_type = ITERATIVE_SCHUR;
   options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
   options.preconditioner_type = IDENTITY;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = SCHUR_JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = CLUSTER_JACOBI;
   EXPECT_EQ(options.IsValid(&message),
             IsSparseLinearAlgebraLibraryTypeAvailable(
@@ -1311,7 +1316,7 @@
   options.preconditioner_type = JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = SCHUR_JACOBI;
-  EXPECT_TRUE(options.IsValid(&message));
+  EXPECT_TRUE(options.IsValid(&message)) << message;
   options.preconditioner_type = CLUSTER_JACOBI;
   EXPECT_FALSE(options.IsValid(&message));
   options.preconditioner_type = CLUSTER_TRIDIAGONAL;

internal/ceres/tiny_solver_test.cc

diff --git a/internal/ceres/tiny_solver_test.cc b/internal/ceres/tiny_solver_test.cc
index 9a13c26..900e4ae 100644
--- a/internal/ceres/tiny_solver_test.cc
+++ b/internal/ceres/tiny_solver_test.cc
@@ -132,8 +132,15 @@
   Vec2 expected_residuals;
   Eigen::Matrix<double, 2, 3> expected_jacobian;
   f(x.data(), expected_residuals.data(), expected_jacobian.data());
-  EXPECT_TRUE(expected_residuals.isApprox(solver.Residuals()));
-  EXPECT_TRUE(expected_jacobian.isApprox(solver.Jacobian()));
+  // The comparison must not allocate since the tests forbid heap allocations.
+  // The failure message is only evaluated if the comparison fails.
+  EXPECT_TRUE(expected_residuals.isApprox(solver.Residuals()))
+      << "expected: " << expected_residuals.transpose()
+      << "\nactual: " << solver.Residuals().transpose();
+  EXPECT_TRUE(expected_jacobian.isApprox(solver.Jacobian()))
+      << "expected:\n"
+      << expected_jacobian << "\nactual:\n"
+      << solver.Jacobian();
 }
 
 // A test case for when the cost function is statically sized.

internal/ceres/trust_region_preprocessor_test.cc

diff --git a/internal/ceres/trust_region_preprocessor_test.cc b/internal/ceres/trust_region_preprocessor_test.cc
index 2579361..9d00bf2 100644
--- a/internal/ceres/trust_region_preprocessor_test.cc
+++ b/internal/ceres/trust_region_preprocessor_test.cc
@@ -48,7 +48,7 @@
   Solver::Options options;
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp)) << pp.error;
 }
 
 TEST(TrustRegionPreprocessor, ProblemWithInvalidParameterBlock) {
@@ -113,7 +113,7 @@
   Solver::Options options;
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp)) << pp.error;
 }
 
 template <int kNumResiduals, int... Ns>
@@ -161,12 +161,12 @@
     options.linear_solver_type = linear_solver_type;
     TrustRegionPreprocessor preprocessor;
     PreprocessedProblem pp;
-    EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp));
+    EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp)) << pp.error;
     EXPECT_EQ(pp.options.linear_solver_type, linear_solver_type);
     EXPECT_EQ(pp.linear_solver_options.type, linear_solver_type);
     EXPECT_EQ(pp.evaluator_options.linear_solver_type, linear_solver_type);
-    EXPECT_TRUE(pp.linear_solver.get() != nullptr);
-    EXPECT_TRUE(pp.evaluator.get() != nullptr);
+    EXPECT_NE(pp.linear_solver.get(), nullptr);
+    EXPECT_NE(pp.evaluator.get(), nullptr);
   }
 
  protected:
@@ -213,13 +213,13 @@
   Solver::Options options;
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp)) << pp.error;
   EXPECT_EQ(pp.options.linear_solver_type, options.linear_solver_type);
   EXPECT_EQ(pp.linear_solver_options.type, options.linear_solver_type);
   EXPECT_EQ(pp.evaluator_options.linear_solver_type,
             options.linear_solver_type);
-  EXPECT_TRUE(pp.linear_solver.get() != nullptr);
-  EXPECT_TRUE(pp.evaluator.get() != nullptr);
+  EXPECT_NE(pp.linear_solver.get(), nullptr);
+  EXPECT_NE(pp.evaluator.get(), nullptr);
   EXPECT_TRUE(pp.minimizer_options.is_constrained);
 }
 
@@ -246,12 +246,12 @@
 
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp)) << pp.error;
   EXPECT_EQ(pp.options.linear_solver_type, DENSE_SCHUR);
   EXPECT_EQ(pp.linear_solver_options.type, DENSE_SCHUR);
   EXPECT_EQ(pp.evaluator_options.linear_solver_type, DENSE_SCHUR);
-  EXPECT_TRUE(pp.linear_solver.get() != nullptr);
-  EXPECT_TRUE(pp.evaluator.get() != nullptr);
+  EXPECT_NE(pp.linear_solver.get(), nullptr);
+  EXPECT_NE(pp.evaluator.get(), nullptr);
 }
 
 TEST_F(LinearSolverAndEvaluatorCreationTest,
@@ -268,12 +268,12 @@
 
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp)) << pp.error;
   EXPECT_EQ(pp.options.linear_solver_type, DENSE_QR);
   EXPECT_EQ(pp.linear_solver_options.type, DENSE_QR);
   EXPECT_EQ(pp.evaluator_options.linear_solver_type, DENSE_QR);
-  EXPECT_TRUE(pp.linear_solver.get() != nullptr);
-  EXPECT_TRUE(pp.evaluator.get() != nullptr);
+  EXPECT_NE(pp.linear_solver.get(), nullptr);
+  EXPECT_NE(pp.evaluator.get(), nullptr);
 }
 
 TEST_F(LinearSolverAndEvaluatorCreationTest,
@@ -289,12 +289,12 @@
 
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp));
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp)) << pp.error;
   EXPECT_EQ(pp.options.linear_solver_type, DENSE_SCHUR);
   EXPECT_EQ(pp.linear_solver_options.type, DENSE_SCHUR);
   EXPECT_EQ(pp.evaluator_options.linear_solver_type, DENSE_SCHUR);
-  EXPECT_TRUE(pp.linear_solver.get() != nullptr);
-  EXPECT_TRUE(pp.evaluator.get() != nullptr);
+  EXPECT_NE(pp.linear_solver.get(), nullptr);
+  EXPECT_NE(pp.evaluator.get(), nullptr);
 }
 
 TEST(TrustRegionPreprocessorTest, InnerIterationsWithOneParameterBlock) {
@@ -307,10 +307,10 @@
 
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp));
-  EXPECT_TRUE(pp.linear_solver.get() != nullptr);
-  EXPECT_TRUE(pp.evaluator.get() != nullptr);
-  EXPECT_TRUE(pp.inner_iteration_minimizer.get() == nullptr);
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem, &pp)) << pp.error;
+  EXPECT_NE(pp.linear_solver.get(), nullptr);
+  EXPECT_NE(pp.evaluator.get(), nullptr);
+  EXPECT_EQ(pp.inner_iteration_minimizer.get(), nullptr);
 }
 
 TEST_F(LinearSolverAndEvaluatorCreationTest,
@@ -320,10 +320,10 @@
 
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp));
-  EXPECT_TRUE(pp.linear_solver.get() != nullptr);
-  EXPECT_TRUE(pp.evaluator.get() != nullptr);
-  EXPECT_TRUE(pp.inner_iteration_minimizer.get() != nullptr);
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp)) << pp.error;
+  EXPECT_NE(pp.linear_solver.get(), nullptr);
+  EXPECT_NE(pp.evaluator.get(), nullptr);
+  EXPECT_NE(pp.inner_iteration_minimizer.get(), nullptr);
 }
 
 TEST_F(LinearSolverAndEvaluatorCreationTest, InvalidInnerIterationsOrdering) {
@@ -349,10 +349,10 @@
 
   TrustRegionPreprocessor preprocessor;
   PreprocessedProblem pp;
-  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp));
-  EXPECT_TRUE(pp.linear_solver.get() != nullptr);
-  EXPECT_TRUE(pp.evaluator.get() != nullptr);
-  EXPECT_TRUE(pp.inner_iteration_minimizer.get() != nullptr);
+  EXPECT_TRUE(preprocessor.Preprocess(options, &problem_, &pp)) << pp.error;
+  EXPECT_NE(pp.linear_solver.get(), nullptr);
+  EXPECT_NE(pp.evaluator.get(), nullptr);
+  EXPECT_NE(pp.inner_iteration_minimizer.get(), nullptr);
 }
 
 }  // namespace internal