diff --git a/internal/ceres/block_sparse_matrix.cc b/internal/ceres/block_sparse_matrix.cc
index f0dc11a..459d709 100644
--- a/internal/ceres/block_sparse_matrix.cc
+++ b/internal/ceres/block_sparse_matrix.cc
@@ -510,7 +510,7 @@
       options.min_col_block_size, options.max_col_block_size);
   std::uniform_int_distribution<int> row_distribution(
       options.min_row_block_size, options.max_row_block_size);
-  auto* bs = new CompressedRowBlockStructure();
+  auto bs = std::make_unique<CompressedRowBlockStructure>();
   if (options.col_blocks.empty()) {
     CHECK_GT(options.num_col_blocks, 0);
     CHECK_GT(options.min_col_block_size, 0);
@@ -555,7 +555,7 @@
     }
   }
 
-  auto matrix = std::make_unique<BlockSparseMatrix>(bs);
+  auto matrix = std::make_unique<BlockSparseMatrix>(bs.release());
   double* values = matrix->mutable_values();
   std::normal_distribution<double> standard_normal_distribution;
   std::generate_n(
diff --git a/internal/ceres/sparse_cholesky_test.cc b/internal/ceres/sparse_cholesky_test.cc
index 2397fdd..7195c4f 100644
--- a/internal/ceres/sparse_cholesky_test.cc
+++ b/internal/ceres/sparse_cholesky_test.cc
@@ -77,9 +77,9 @@
   return random_matrix;
 }
 
-static bool ComputeExpectedSolution(const CompressedRowSparseMatrix& lhs,
-                                    const Vector& rhs,
-                                    Vector* solution) {
+bool ComputeExpectedSolution(const CompressedRowSparseMatrix& lhs,
+                             const Vector& rhs,
+                             Vector* solution) {
   Matrix eigen_lhs;
   lhs.ToDenseMatrix(&eigen_lhs);
   if (lhs.storage_type() ==
@@ -167,11 +167,14 @@
 class SparseCholeskyTest : public ::testing::TestWithParam<Param> {};
 
 TEST_P(SparseCholeskyTest, FactorAndSolve) {
-  const int kMinNumBlocks = 1;
-  const int kMaxNumBlocks = 10;
-  const int kNumTrials = 10;
-  const int kMinBlockSize = 1;
-  const int kMaxBlockSize = 5;
+  constexpr int kMinNumBlocks = 1;
+  constexpr int kMaxNumBlocks = 10;
+  constexpr int kNumTrials = 10;
+  constexpr int kMinBlockSize = 1;
+  constexpr int kMaxBlockSize = 5;
+
+  Param param = GetParam();
+
   std::mt19937 prng;
   std::uniform_real_distribution<double> distribution(0.1, 1.0);
 
@@ -179,7 +182,6 @@
        ++num_blocks) {
     for (int trial = 0; trial < kNumTrials; ++trial) {
       const double block_density = distribution(prng);
-      Param param = GetParam();
       SparseCholeskySolverUnitTest(::testing::get<0>(param),
                                    ::testing::get<1>(param),
                                    ::testing::get<2>(param),
@@ -302,16 +304,13 @@
 using testing::Return;
 
 TEST(RefinedSparseCholesky, StorageType) {
-  auto* mock_sparse_cholesky = new MockSparseCholesky;
-  auto* mock_iterative_refiner = new MockSparseIterativeRefiner;
-  EXPECT_CALL(*mock_sparse_cholesky, StorageType())
+  auto sparse_cholesky = std::make_unique<MockSparseCholesky>();
+  auto iterative_refiner = std::make_unique<MockSparseIterativeRefiner>();
+  EXPECT_CALL(*sparse_cholesky, StorageType())
       .Times(1)
       .WillRepeatedly(
           Return(CompressedRowSparseMatrix::StorageType::UPPER_TRIANGULAR));
-  EXPECT_CALL(*mock_iterative_refiner, Refine(_, _, _, _)).Times(0);
-  std::unique_ptr<SparseCholesky> sparse_cholesky(mock_sparse_cholesky);
-  std::unique_ptr<SparseIterativeRefiner> iterative_refiner(
-      mock_iterative_refiner);
+  EXPECT_CALL(*iterative_refiner, Refine(_, _, _, _)).Times(0);
   RefinedSparseCholesky refined_sparse_cholesky(std::move(sparse_cholesky),
                                                 std::move(iterative_refiner));
   EXPECT_EQ(refined_sparse_cholesky.StorageType(),