diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index 8ad0862..b07d4f0 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -118,37 +118,242 @@
            internal::EigenSparse::IsNestedDissectionAvailable()));
 }
 
-bool MixedPrecisionOptionIsValid(const Solver::Options& options,
-                                 string* error) {
-  if (!options.use_mixed_precision_solves) {
-    return true;
+bool IsIterativeSolver(LinearSolverType type) {
+  return (type == CGNR || type == ITERATIVE_SCHUR);
+}
+
+bool OptionsAreValidForDenseSolver(const Solver::Options& options,
+                                   string* error) {
+  const char* library_name = DenseLinearAlgebraLibraryTypeToString(
+      options.dense_linear_algebra_library_type);
+  const char* solver_name =
+      LinearSolverTypeToString(options.linear_solver_type);
+  constexpr char kFormat[] =
+      "Can't use %s with dense_linear_algebra_library_type = %s "
+      "because support not enabled when Ceres was built.";
+
+  if (!IsDenseLinearAlgebraLibraryTypeAvailable(
+          options.dense_linear_algebra_library_type)) {
+    *error = StringPrintf(kFormat, solver_name, library_name);
+    return false;
+  }
+  return true;
+}
+
+bool OptionsAreValidForSparseCholeskyBasedSolver(const Solver::Options& options,
+                                                 string* error) {
+  const char* library_name = SparseLinearAlgebraLibraryTypeToString(
+      options.sparse_linear_algebra_library_type);
+  // Sparse factorization based solvers and some preconditioners require a
+  // sparse Cholesky factorization.
+  const char* solver_name =
+      IsIterativeSolver(options.linear_solver_type)
+          ? PreconditionerTypeToString(options.preconditioner_type)
+          : LinearSolverTypeToString(options.linear_solver_type);
+
+  constexpr char kNoSparseFormat[] =
+      "Can't use %s with sparse_linear_algebra_library_type = %s.";
+  constexpr char kNoLibraryFormat[] =
+      "Can't use %s sparse_linear_algebra_library_type = %s, because support "
+      "was not enabled when Ceres Solver was built.";
+  constexpr char kNoNesdisFormat[] =
+      "NESDIS is not available with sparse_linear_algebra_library_type = %s.";
+  constexpr char kMixedFormat[] =
+      "use_mixed_precision_solves with %s is not supported with "
+      "sparse_linear_algebra_library_type = %s";
+  constexpr char kDynamicSparsityFormat[] =
+      "dynamic sparsity is not supported with "
+      "sparse_linear_algebra_library_type = %s";
+
+  if (options.sparse_linear_algebra_library_type == NO_SPARSE) {
+    *error = StringPrintf(kNoSparseFormat, solver_name, library_name);
+    return false;
   }
 
-  // All dense linear algebra backends support mixed precision solves now with
-  // Cholesky factorization.
-  if ((options.linear_solver_type == DENSE_NORMAL_CHOLESKY ||
-       options.linear_solver_type == DENSE_SCHUR)) {
-    return true;
+  if (!IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    *error = StringPrintf(kNoLibraryFormat, solver_name, library_name);
+    return false;
   }
 
-  if ((options.linear_solver_type == SPARSE_NORMAL_CHOLESKY ||
-       options.linear_solver_type == SPARSE_SCHUR)) {
-    if (options.sparse_linear_algebra_library_type == EIGEN_SPARSE ||
-        options.sparse_linear_algebra_library_type == ACCELERATE_SPARSE) {
-      // Mixed precision with any Eigen or Accelerate Cholesky variant: okay.
-      return true;
+  if (options.linear_solver_ordering_type == ceres::NESDIS &&
+      !IsNestedDissectionAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    *error = StringPrintf(kNoNesdisFormat, library_name);
+    return false;
+  }
+
+  if (options.use_mixed_precision_solves &&
+      options.sparse_linear_algebra_library_type == SUITE_SPARSE) {
+    *error = StringPrintf(kMixedFormat, solver_name, library_name);
+    return false;
+  }
+
+  if (options.dynamic_sparsity &&
+      options.sparse_linear_algebra_library_type == ACCELERATE_SPARSE) {
+    *error = StringPrintf(kDynamicSparsityFormat, library_name);
+    return false;
+  }
+
+  return true;
+}
+
+bool OptionsAreValidForDenseNormalCholesky(const Solver::Options& options,
+                                           string* error) {
+  CHECK_EQ(options.linear_solver_type, DENSE_NORMAL_CHOLESKY);
+  return OptionsAreValidForDenseSolver(options, error);
+}
+
+bool OptionsAreValidForDenseQr(const Solver::Options& options, string* error) {
+  CHECK_EQ(options.linear_solver_type, DENSE_QR);
+
+  if (!OptionsAreValidForDenseSolver(options, error)) {
+    return false;
+  }
+
+  if (options.use_mixed_precision_solves) {
+    *error = "Can't use use_mixed_precision_solves with DENSE_QR.";
+    return false;
+  }
+
+  return true;
+}
+
+bool OptionsAreValidForSparseNormalCholesky(const Solver::Options& options,
+                                            string* error) {
+  CHECK_EQ(options.linear_solver_type, SPARSE_NORMAL_CHOLESKY);
+  return OptionsAreValidForSparseCholeskyBasedSolver(options, error);
+}
+
+bool OptionsAreValidForDenseSchur(const Solver::Options& options,
+                                  string* error) {
+  CHECK_EQ(options.linear_solver_type, DENSE_SCHUR);
+
+  if (options.dynamic_sparsity) {
+    *error = "dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY";
+    return false;
+  }
+
+  if (!OptionsAreValidForDenseSolver(options, error)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool OptionsAreValidForSparseSchur(const Solver::Options& options,
+                                   string* error) {
+  CHECK_EQ(options.linear_solver_type, SPARSE_SCHUR);
+  if (options.dynamic_sparsity) {
+    *error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
+    return false;
+  }
+  return OptionsAreValidForSparseCholeskyBasedSolver(options, error);
+}
+
+bool OptionsAreValidForIterativeSchur(const Solver::Options& options,
+                                      string* error) {
+  CHECK_EQ(options.linear_solver_type, ITERATIVE_SCHUR);
+  if (options.dynamic_sparsity) {
+    *error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
+    return false;
+  }
+
+  if (options.use_explicit_schur_complement &&
+      options.preconditioner_type != SCHUR_JACOBI) {
+    *error =
+        "use_explicit_schur_complement only supports "
+        "SCHUR_JACOBI as the preconditioner.";
+    return false;
+  }
+
+  if (options.use_mixed_precision_solves) {
+    *error = "Can't use use_mixed_precision_solves with ITERATIVE_SCHUR";
+    return false;
+  }
+
+  if (options.dynamic_sparsity) {
+    *error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
+    return false;
+  }
+
+  if (options.preconditioner_type == SUBSET) {
+    *error = "Can't use SUBSET preconditioner with ITERATIVE_SCHUR";
+    return false;
+  }
+
+  // CLUSTER_JACOBI and CLUSTER_TRIDIAGONAL require sparse Cholesky
+  // factorization.
+  if (options.preconditioner_type == CLUSTER_JACOBI ||
+      options.preconditioner_type == CLUSTER_TRIDIAGONAL) {
+    return OptionsAreValidForSparseCholeskyBasedSolver(options, error);
+  }
+
+  return true;
+}
+
+bool OptionsAreValidForCgnr(const Solver::Options& options, string* error) {
+  CHECK_EQ(options.linear_solver_type, CGNR);
+
+  if (options.preconditioner_type != IDENTITY &&
+      options.preconditioner_type != JACOBI &&
+      options.preconditioner_type != SUBSET) {
+    *error =
+        StringPrintf("Can't use CGNR with preconditioner_type = %s.",
+                     PreconditionerTypeToString(options.preconditioner_type));
+    return false;
+  }
+
+  if (options.use_mixed_precision_solves) {
+    *error = "use_mixed_precision_solves cannot be used with CGNR";
+    return false;
+  }
+
+  if (options.dynamic_sparsity) {
+    *error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
+    return false;
+  }
+
+  if (options.preconditioner_type == SUBSET) {
+    if (options.residual_blocks_for_subset_preconditioner.empty()) {
+      *error =
+          "When using SUBSET preconditioner, "
+          "residual_blocks_for_subset_preconditioner cannot be empty";
+      return false;
     }
-    if (options.sparse_linear_algebra_library_type == SUITE_SPARSE) {
-      *error = StringPrintf(
-          "use_mixed_precision_solves with %s is not supported with "
-          "SUITE_SPARSE as the sparse_linear_algebra_library_type.",
-          LinearSolverTypeToString(options.linear_solver_type));
+
+    // SUBSET preconditioner requires sparse Cholesky factorization.
+    if (!OptionsAreValidForSparseCholeskyBasedSolver(options, error)) {
       return false;
     }
   }
 
-  *error = StringPrintf("use_mixed_precision_solves with %s is not supported.",
-                        LinearSolverTypeToString(options.linear_solver_type));
+  return true;
+}
+
+bool OptionsAreValidForLinearSolver(const Solver::Options& options,
+                                    string* error) {
+  switch (options.linear_solver_type) {
+    case DENSE_NORMAL_CHOLESKY:
+      return OptionsAreValidForDenseNormalCholesky(options, error);
+    case DENSE_QR:
+      return OptionsAreValidForDenseQr(options, error);
+    case SPARSE_NORMAL_CHOLESKY:
+      return OptionsAreValidForSparseNormalCholesky(options, error);
+    case DENSE_SCHUR:
+      return OptionsAreValidForDenseSchur(options, error);
+    case SPARSE_SCHUR:
+      return OptionsAreValidForSparseSchur(options, error);
+    case ITERATIVE_SCHUR:
+      return OptionsAreValidForIterativeSchur(options, error);
+    case CGNR:
+      return OptionsAreValidForCgnr(options, error);
+    default:
+      LOG(FATAL) << "Congratulations you have found a bug. Please report "
+                    "this to the "
+                    "Ceres Solver developers. Unknown linear solver type: "
+                 << LinearSolverTypeToString(options.linear_solver_type);
+  }
   return false;
 }
 
@@ -177,106 +382,19 @@
     OPTION_GT(max_consecutive_nonmonotonic_steps, 0);
   }
 
-  if (options.linear_solver_type == ITERATIVE_SCHUR &&
-      options.use_explicit_schur_complement &&
-      options.preconditioner_type != SCHUR_JACOBI) {
+  if ((options.trust_region_strategy_type == DOGLEG) &&
+      IsIterativeSolver(options.linear_solver_type)) {
     *error =
-        "use_explicit_schur_complement only supports "
-        "SCHUR_JACOBI as the preconditioner.";
+        "DOGLEG only supports exact factorization based linear "
+        "solvers. If you want to use an iterative solver please "
+        "use LEVENBERG_MARQUARDT as the trust_region_strategy_type";
     return false;
   }
 
-  if (!IsDenseLinearAlgebraLibraryTypeAvailable(
-          options.dense_linear_algebra_library_type) &&
-      (options.linear_solver_type == DENSE_NORMAL_CHOLESKY ||
-       options.linear_solver_type == DENSE_QR ||
-       options.linear_solver_type == DENSE_SCHUR)) {
-    *error = StringPrintf(
-        "Can't use %s with "
-        "Solver::Options::dense_linear_algebra_library_type = %s "
-        "because %s was not enabled when Ceres was built.",
-        LinearSolverTypeToString(options.linear_solver_type),
-        DenseLinearAlgebraLibraryTypeToString(
-            options.dense_linear_algebra_library_type),
-        DenseLinearAlgebraLibraryTypeToString(
-            options.dense_linear_algebra_library_type));
+  if (!OptionsAreValidForLinearSolver(options, error)) {
     return false;
   }
 
-  {
-    const char* sparse_linear_algebra_library_name =
-        SparseLinearAlgebraLibraryTypeToString(
-            options.sparse_linear_algebra_library_type);
-    const char* name = nullptr;
-    if (options.linear_solver_type == SPARSE_NORMAL_CHOLESKY ||
-        options.linear_solver_type == SPARSE_SCHUR) {
-      name = LinearSolverTypeToString(options.linear_solver_type);
-    } else if ((options.linear_solver_type == ITERATIVE_SCHUR &&
-                (options.preconditioner_type == CLUSTER_JACOBI ||
-                 options.preconditioner_type == CLUSTER_TRIDIAGONAL)) ||
-               (options.linear_solver_type == CGNR &&
-                options.preconditioner_type == SUBSET)) {
-      name = PreconditionerTypeToString(options.preconditioner_type);
-    }
-
-    if (name) {
-      if (options.sparse_linear_algebra_library_type == NO_SPARSE) {
-        *error = StringPrintf(
-            "Can't use %s with "
-            "Solver::Options::sparse_linear_algebra_library_type = %s.",
-            name,
-            sparse_linear_algebra_library_name);
-        return false;
-      }
-
-      if (!IsSparseLinearAlgebraLibraryTypeAvailable(
-              options.sparse_linear_algebra_library_type)) {
-        *error = StringPrintf(
-            "Can't use %s with "
-            "Solver::Options::sparse_linear_algebra_library_type = %s, "
-            "because support was not enabled when Ceres Solver was built.",
-            name,
-            sparse_linear_algebra_library_name);
-        return false;
-      }
-
-      if (options.linear_solver_ordering_type == ceres::NESDIS &&
-          !IsNestedDissectionAvailable(
-              options.sparse_linear_algebra_library_type)) {
-        if (options.sparse_linear_algebra_library_type == SUITE_SPARSE) {
-          *error = StringPrintf(
-              "Can't use NESDIS with SUITE_SPARSE because SuiteSparse was "
-              "compiled without support for Metis.");
-        } else if (options.sparse_linear_algebra_library_type == EIGEN_SPARSE) {
-          *error = StringPrintf(
-              "Can't use NESDIS with EIGEN_SPARSE because Ceres was "
-              "compiled without support for Metis.");
-        } else {
-          *error = StringPrintf(
-              "Can't use NESDIS with "
-              "Solver::Options::sparse_linear_algebra_library_type = %s.",
-              sparse_linear_algebra_library_name);
-        }
-        return false;
-      }
-    }
-  }
-
-  if (!MixedPrecisionOptionIsValid(options, error)) {
-    return false;
-  }
-
-  if (options.trust_region_strategy_type == DOGLEG) {
-    if (options.linear_solver_type == ITERATIVE_SCHUR ||
-        options.linear_solver_type == CGNR) {
-      *error =
-          "DOGLEG only supports exact factorization based linear "
-          "solvers. If you want to use an iterative solver please "
-          "use LEVENBERG_MARQUARDT as the trust_region_strategy_type";
-      return false;
-    }
-  }
-
   if (!options.trust_region_minimizer_iterations_to_dump.empty() &&
       options.trust_region_problem_dump_format_type != CONSOLE &&
       options.trust_region_problem_dump_directory.empty()) {
@@ -284,31 +402,6 @@
     return false;
   }
 
-  if (options.dynamic_sparsity) {
-    if (options.linear_solver_type != SPARSE_NORMAL_CHOLESKY) {
-      *error =
-          "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
-      return false;
-    }
-    if (options.sparse_linear_algebra_library_type == ACCELERATE_SPARSE) {
-      *error =
-          "ACCELERATE_SPARSE is not currently supported with dynamic "
-          "sparsity.";
-      return false;
-    }
-  }
-
-  if (options.linear_solver_type == CGNR &&
-      options.preconditioner_type == SUBSET &&
-      options.residual_blocks_for_subset_preconditioner.empty()) {
-    *error =
-        "When using SUBSET preconditioner, "
-        "Solver::Options::residual_blocks_for_subset_preconditioner cannot "
-        "be "
-        "empty";
-    return false;
-  }
-
   return true;
 }
 
@@ -785,8 +878,7 @@
                   LinearSolverTypeToString(linear_solver_type_given),
                   LinearSolverTypeToString(linear_solver_type_used));
 
-    if (linear_solver_type_given == CGNR ||
-        linear_solver_type_given == ITERATIVE_SCHUR) {
+    if (IsIterativeSolver(linear_solver_type_given)) {
       StringAppendF(&report,
                     "Preconditioner      %25s%25s\n",
                     PreconditionerTypeToString(preconditioner_type_given),
diff --git a/internal/ceres/solver_test.cc b/internal/ceres/solver_test.cc
index 5abd723..1b61b18 100644
--- a/internal/ceres/solver_test.cc
+++ b/internal/ceres/solver_test.cc
@@ -312,160 +312,6 @@
   EXPECT_EQ(summary.final_cost, 1.0 / 2.0);
 }
 
-#if defined(CERES_NO_SUITESPARSE)
-TEST(Solver, SparseNormalCholeskyNoSuiteSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = SUITE_SPARSE;
-  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver, SparseSchurNoSuiteSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = SUITE_SPARSE;
-  options.linear_solver_type = SPARSE_SCHUR;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-#endif
-
-#if defined(CERES_NO_CXSPARSE)
-TEST(Solver, SparseNormalCholeskyNoCXSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = CX_SPARSE;
-  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver, SparseSchurNoCXSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = CX_SPARSE;
-  options.linear_solver_type = SPARSE_SCHUR;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-#endif
-
-#if defined(CERES_NO_ACCELERATE_SPARSE)
-TEST(Solver, SparseNormalCholeskyNoAccelerateSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
-  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver, SparseSchurNoAccelerateSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
-  options.linear_solver_type = SPARSE_SCHUR;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-#else
-TEST(Solver, DynamicSparseNormalCholeskyUnsupportedWithAccelerateSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
-  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
-  options.dynamic_sparsity = true;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-#endif
-
-#if !defined(CERES_USE_EIGEN_SPARSE)
-TEST(Solver, SparseNormalCholeskyNoEigenSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
-  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver, SparseSchurNoEigenSparse) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
-  options.linear_solver_type = SPARSE_SCHUR;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-#endif
-
-TEST(Solver, SparseNormalCholeskyNoSparseLibrary) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = NO_SPARSE;
-  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver, SparseSchurNoSparseLibrary) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = NO_SPARSE;
-  options.linear_solver_type = SPARSE_SCHUR;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver, IterativeSchurWithClusterJacobiPerconditionerNoSparseLibrary) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = NO_SPARSE;
-  options.linear_solver_type = ITERATIVE_SCHUR;
-  // Requires SuiteSparse.
-  options.preconditioner_type = CLUSTER_JACOBI;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver,
-     IterativeSchurWithClusterTridiagonalPerconditionerNoSparseLibrary) {
-  Solver::Options options;
-  options.sparse_linear_algebra_library_type = NO_SPARSE;
-  options.linear_solver_type = ITERATIVE_SCHUR;
-  // Requires SuiteSparse.
-  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
-  string message;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver, IterativeLinearSolverForDogleg) {
-  Solver::Options options;
-  options.trust_region_strategy_type = DOGLEG;
-  string message;
-  options.linear_solver_type = ITERATIVE_SCHUR;
-  EXPECT_FALSE(options.IsValid(&message));
-
-  options.linear_solver_type = CGNR;
-  EXPECT_FALSE(options.IsValid(&message));
-}
-
-TEST(Solver, LinearSolverTypeNormalOperation) {
-  Solver::Options options;
-  options.linear_solver_type = DENSE_QR;
-
-  string message;
-  EXPECT_TRUE(options.IsValid(&message));
-
-  options.linear_solver_type = DENSE_NORMAL_CHOLESKY;
-  EXPECT_TRUE(options.IsValid(&message));
-
-  options.linear_solver_type = DENSE_SCHUR;
-  EXPECT_TRUE(options.IsValid(&message));
-
-  options.linear_solver_type = SPARSE_SCHUR;
-#if defined(CERES_NO_SUITESPARSE) && defined(CERES_NO_CXSPARSE) && \
-    !defined(CERES_USE_EIGEN_SPARSE)
-  EXPECT_FALSE(options.IsValid(&message));
-#else
-  EXPECT_TRUE(options.IsValid(&message));
-#endif
-
-  options.linear_solver_type = ITERATIVE_SCHUR;
-  EXPECT_TRUE(options.IsValid(&message));
-}
-
 template <int kNumResiduals, int... Ns>
 class DummyCostFunction : public SizedCostFunction<kNumResiduals, Ns...> {
  public:
@@ -529,4 +375,793 @@
   EXPECT_EQ(y, 1.0);
 }
 
+TEST(Solver, DenseNormalCholeskyOptions) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = DENSE_NORMAL_CHOLESKY;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dense_linear_algebra_library_type = EIGEN;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.use_mixed_precision_solves = true;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  if (IsDenseLinearAlgebraLibraryTypeAvailable(LAPACK)) {
+    options.use_mixed_precision_solves = false;
+    options.dense_linear_algebra_library_type = LAPACK;
+
+    EXPECT_TRUE(options.IsValid(&message));
+    options.use_mixed_precision_solves = true;
+    EXPECT_TRUE(options.IsValid(&message));
+  } else {
+    options.use_mixed_precision_solves = false;
+    options.dense_linear_algebra_library_type = LAPACK;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+}
+
+TEST(Solver, DenseQrOptions) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = DENSE_QR;
+
+  options.use_mixed_precision_solves = false;
+  options.dense_linear_algebra_library_type = EIGEN;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  if (IsDenseLinearAlgebraLibraryTypeAvailable(LAPACK)) {
+    options.use_mixed_precision_solves = false;
+    options.dense_linear_algebra_library_type = LAPACK;
+    EXPECT_TRUE(options.IsValid(&message));
+    options.use_mixed_precision_solves = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  } else {
+    options.use_mixed_precision_solves = false;
+    options.dense_linear_algebra_library_type = LAPACK;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+}
+
+TEST(Solver, SparseNormalCholeskyOptionsNoSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
+  options.sparse_linear_algebra_library_type = NO_SPARSE;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
+TEST(Solver, SparseNormalCholeskyOptionsEigenSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
+  options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
+  options.linear_solver_ordering_type = AMD;
+
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
+    EXPECT_TRUE(options.IsValid(&message));
+  } else {
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_TRUE(options.IsValid(&message));
+  }
+
+#ifndef CERES_NO_EIGEN_METIS
+  options.linear_solver_ordering_type = NESDIS;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_TRUE(options.IsValid(&message));
+  }
+#else
+  options.linear_solver_ordering_type = NESDIS;
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  EXPECT_FALSE(options.IsValid(&message));
+#endif
+}
+
+TEST(Solver, SparseNormalCholeskyOptionsSuiteSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
+  options.sparse_linear_algebra_library_type = SUITE_SPARSE;
+  options.linear_solver_ordering_type = AMD;
+
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    EXPECT_TRUE(options.IsValid(&message));
+  } else {
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+#ifndef CERES_NO_CHOLMOD_PARTITION
+  options.linear_solver_ordering_type = NESDIS;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+#else
+  options.linear_solver_ordering_type = NESDIS;
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  EXPECT_FALSE(options.IsValid(&message));
+#endif
+}
+
+TEST(Solver, SparseNormalCholeskyOptionsAccelerateSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
+  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
+  options.linear_solver_ordering_type = AMD;
+
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    EXPECT_TRUE(options.IsValid(&message));
+  } else {
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  options.linear_solver_ordering_type = NESDIS;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+}
+
+TEST(Solver, DenseSchurOptions) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = DENSE_SCHUR;
+  options.dense_linear_algebra_library_type = EIGEN;
+
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.use_mixed_precision_solves = true;
+  options.dynamic_sparsity = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.use_mixed_precision_solves = true;
+  options.dynamic_sparsity = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dense_linear_algebra_library_type = LAPACK;
+  if (IsDenseLinearAlgebraLibraryTypeAvailable(
+          options.dense_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+}
+
+TEST(Solver, SparseSchurOptionsNoSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = SPARSE_SCHUR;
+  options.sparse_linear_algebra_library_type = NO_SPARSE;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
+TEST(Solver, SparseSchurOptionsEigenSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = SPARSE_SCHUR;
+  options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
+  options.linear_solver_ordering_type = AMD;
+
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
+    EXPECT_TRUE(options.IsValid(&message));
+  } else {
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+#ifndef CERES_NO_EIGEN_METIS
+  options.linear_solver_ordering_type = NESDIS;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(EIGEN_SPARSE)) {
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+#else
+  options.linear_solver_ordering_type = NESDIS;
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  EXPECT_FALSE(options.IsValid(&message));
+#endif
+}
+
+TEST(Solver, SparseSchurOptionsSuiteSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = SPARSE_SCHUR;
+  options.sparse_linear_algebra_library_type = SUITE_SPARSE;
+  options.linear_solver_ordering_type = AMD;
+
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    EXPECT_TRUE(options.IsValid(&message));
+  } else {
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+#ifndef CERES_NO_CHOLMOD_PARTITION
+  options.linear_solver_ordering_type = NESDIS;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+#else
+  options.linear_solver_ordering_type = NESDIS;
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  EXPECT_FALSE(options.IsValid(&message));
+#endif
+}
+
+TEST(Solver, SparseSchurOptionsAccelerateSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = SPARSE_SCHUR;
+  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
+  options.linear_solver_ordering_type = AMD;
+
+  options.use_mixed_precision_solves = false;
+  options.dynamic_sparsity = false;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    EXPECT_TRUE(options.IsValid(&message));
+  } else {
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  options.linear_solver_ordering_type = NESDIS;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = false;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.use_mixed_precision_solves = true;
+    options.dynamic_sparsity = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+}
+
+TEST(Solver, CgnrOptionsIdentityPreconditioner) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = CGNR;
+  options.preconditioner_type = IDENTITY;
+  options.sparse_linear_algebra_library_type = NO_SPARSE;
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.dynamic_sparsity = false;
+    options.use_mixed_precision_solves = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.dynamic_sparsity = true;
+    options.use_mixed_precision_solves = false;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.dynamic_sparsity = false;
+    options.use_mixed_precision_solves = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  options.sparse_linear_algebra_library_type = SUITE_SPARSE;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.dynamic_sparsity = false;
+    options.use_mixed_precision_solves = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.dynamic_sparsity = true;
+    options.use_mixed_precision_solves = false;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.dynamic_sparsity = false;
+    options.use_mixed_precision_solves = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+
+  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
+  if (IsSparseLinearAlgebraLibraryTypeAvailable(
+          options.sparse_linear_algebra_library_type)) {
+    options.dynamic_sparsity = false;
+    options.use_mixed_precision_solves = false;
+    EXPECT_TRUE(options.IsValid(&message));
+
+    options.dynamic_sparsity = true;
+    options.use_mixed_precision_solves = false;
+    EXPECT_FALSE(options.IsValid(&message));
+
+    options.dynamic_sparsity = false;
+    options.use_mixed_precision_solves = true;
+    EXPECT_FALSE(options.IsValid(&message));
+  }
+}
+
+TEST(Solver, CgnrOptionsJacobiPreconditioner) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = CGNR;
+  options.preconditioner_type = JACOBI;
+  options.sparse_linear_algebra_library_type = NO_SPARSE;
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.sparse_linear_algebra_library_type = SUITE_SPARSE;
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
+TEST(Solver, CgnrOptionsSubsetPreconditioner) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = CGNR;
+  options.preconditioner_type = SUBSET;
+
+  options.sparse_linear_algebra_library_type = NO_SPARSE;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.residual_blocks_for_subset_preconditioner.insert(nullptr);
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.sparse_linear_algebra_library_type = SUITE_SPARSE;
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = false;
+  EXPECT_TRUE(options.IsValid(&message));
+
+  options.dynamic_sparsity = true;
+  options.use_mixed_precision_solves = false;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.dynamic_sparsity = false;
+  options.use_mixed_precision_solves = true;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
+TEST(Solver, CgnrOptionsSchurPreconditioners) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = CGNR;
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
+TEST(Solver, IterativeSchurOptionsNoSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = ITERATIVE_SCHUR;
+  options.sparse_linear_algebra_library_type = NO_SPARSE;
+  options.preconditioner_type = IDENTITY;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = SUBSET;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.use_explicit_schur_complement = true;
+  options.preconditioner_type = IDENTITY;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
+TEST(Solver, IterativeSchurOptionsEigenSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = ITERATIVE_SCHUR;
+  options.sparse_linear_algebra_library_type = EIGEN_SPARSE;
+  options.preconditioner_type = IDENTITY;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_EQ(options.IsValid(&message),
+            IsSparseLinearAlgebraLibraryTypeAvailable(
+                options.sparse_linear_algebra_library_type));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_EQ(options.IsValid(&message),
+            IsSparseLinearAlgebraLibraryTypeAvailable(
+                options.sparse_linear_algebra_library_type));
+  options.preconditioner_type = SUBSET;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.use_explicit_schur_complement = true;
+  options.preconditioner_type = IDENTITY;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
+TEST(Solver, IterativeSchurOptionsSuiteSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = ITERATIVE_SCHUR;
+  options.sparse_linear_algebra_library_type = SUITE_SPARSE;
+  options.preconditioner_type = IDENTITY;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_EQ(options.IsValid(&message),
+            IsSparseLinearAlgebraLibraryTypeAvailable(
+                options.sparse_linear_algebra_library_type));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_EQ(options.IsValid(&message),
+            IsSparseLinearAlgebraLibraryTypeAvailable(
+                options.sparse_linear_algebra_library_type));
+  options.preconditioner_type = SUBSET;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.use_explicit_schur_complement = true;
+  options.preconditioner_type = IDENTITY;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
+TEST(Solver, IterativeSchurOptionsAccelerateSparse) {
+  std::string message;
+  Solver::Options options;
+  options.linear_solver_type = ITERATIVE_SCHUR;
+  options.sparse_linear_algebra_library_type = ACCELERATE_SPARSE;
+  options.preconditioner_type = IDENTITY;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_EQ(options.IsValid(&message),
+            IsSparseLinearAlgebraLibraryTypeAvailable(
+                options.sparse_linear_algebra_library_type));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_EQ(options.IsValid(&message),
+            IsSparseLinearAlgebraLibraryTypeAvailable(
+                options.sparse_linear_algebra_library_type));
+  options.preconditioner_type = SUBSET;
+  EXPECT_FALSE(options.IsValid(&message));
+
+  options.use_explicit_schur_complement = true;
+  options.preconditioner_type = IDENTITY;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = SCHUR_JACOBI;
+  EXPECT_TRUE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_JACOBI;
+  EXPECT_FALSE(options.IsValid(&message));
+  options.preconditioner_type = CLUSTER_TRIDIAGONAL;
+  EXPECT_FALSE(options.IsValid(&message));
+}
+
 }  // namespace ceres::internal
diff --git a/internal/ceres/types.cc b/internal/ceres/types.cc
index 5d1bcea..c0e3355 100644
--- a/internal/ceres/types.cc
+++ b/internal/ceres/types.cc
@@ -418,6 +418,10 @@
 #endif
   }
 
+  if (type == NO_SPARSE) {
+    return true;
+  }
+
   LOG(WARNING) << "Unknown sparse linear algebra library " << type;
   return false;
 }