Google GitGoogle Git
Sign in
ceres-solver/ceres-solver/299c201f1158d1696a005820e2bc837d15b624a9^!/.
commit
299c201f1158d1696a005820e2bc837d15b624a9
[log]
author
Sergiu Deitsch <sergiu.deitsch@gmail.com>
Thu Oct 08 21:18:47 2026 +0200
committer
Sameer Agarwal <sameeragarwal@google.com>
Thu Oct 08 17:30:55 2026 -0700
tree
79cc7e423b02bccaeb7249b9bbae4cf5222f46cf
parent
c478dced7799e2df33b5c23edc818fa7fa1ef985 [diff]
Use the current gMock mocking syntax

The mocks use deprecated macros and Times(1) with WillRepeatedly. Use
MOCK_METHOD, WillOnce and std::make_unique.

Change-Id: I83530eb485996796e22f7684d0ff800ae8a77cf8

diff --git a/internal/ceres/dense_cholesky_test.cc b/internal/ceres/dense_cholesky_test.cc
index b5fa59b..161b57c 100644
--- a/internal/ceres/dense_cholesky_test.cc
+++ b/internal/ceres/dense_cholesky_test.cc

@@ -140,25 +140,27 @@
 
 class MockDenseCholesky : public DenseCholesky {
  public:
-  MOCK_METHOD3(Factorize,
-               LinearSolverTerminationType(int num_cols,
-                                           double* lhs,
-                                           std::string* message));
-  MOCK_METHOD3(Solve,
-               LinearSolverTerminationType(const double* rhs,
-                                           double* solution,
-                                           std::string* message));
+  MOCK_METHOD(LinearSolverTerminationType,
+              Factorize,
+              (int num_cols, double* lhs, std::string* message),
+              (override));
+  MOCK_METHOD(LinearSolverTerminationType,
+              Solve,
+              (const double* rhs, double* solution, std::string* message),
+              (override));
 };
 
 class MockDenseIterativeRefiner : public DenseIterativeRefiner {
  public:
   MockDenseIterativeRefiner() : DenseIterativeRefiner(1) {}
-  MOCK_METHOD5(Refine,
-               void(int num_cols,
-                    const double* lhs,
-                    const double* rhs,
-                    DenseCholesky* dense_cholesky,
-                    double* solution));
+  MOCK_METHOD(void,
+              Refine,
+              (int num_cols,
+               const double* lhs,
+               const double* rhs,
+               DenseCholesky* dense_cholesky,
+               double* solution),
+              (override));
 };
 
 using testing::_;
@@ -168,8 +170,7 @@
   auto dense_cholesky = std::make_unique<MockDenseCholesky>();
   auto iterative_refiner = std::make_unique<MockDenseIterativeRefiner>();
   EXPECT_CALL(*dense_cholesky, Factorize(_, _, _))
-      .Times(1)
-      .WillRepeatedly(Return(LinearSolverTerminationType::SUCCESS));
+      .WillOnce(Return(LinearSolverTerminationType::SUCCESS));
   EXPECT_CALL(*iterative_refiner, Refine(_, _, _, _, _)).Times(0);
   RefinedDenseCholesky refined_dense_cholesky(std::move(dense_cholesky),
                                               std::move(iterative_refiner));
@@ -177,14 +178,13 @@
   std::string message;
   EXPECT_EQ(refined_dense_cholesky.Factorize(1, &lhs, &message),
             LinearSolverTerminationType::SUCCESS);
-};
+}
 
 TEST(RefinedDenseCholesky, FactorAndSolveWithUnsuccessfulFactorization) {
   auto dense_cholesky = std::make_unique<MockDenseCholesky>();
   auto iterative_refiner = std::make_unique<MockDenseIterativeRefiner>();
   EXPECT_CALL(*dense_cholesky, Factorize(_, _, _))
-      .Times(1)
-      .WillRepeatedly(Return(LinearSolverTerminationType::FAILURE));
+      .WillOnce(Return(LinearSolverTerminationType::FAILURE));
   EXPECT_CALL(*dense_cholesky, Solve(_, _, _)).Times(0);
   EXPECT_CALL(*iterative_refiner, Refine(_, _, _, _, _)).Times(0);
   RefinedDenseCholesky refined_dense_cholesky(std::move(dense_cholesky),
@@ -196,17 +196,15 @@
   EXPECT_EQ(
       refined_dense_cholesky.FactorAndSolve(1, &lhs, &rhs, &solution, &message),
       LinearSolverTerminationType::FAILURE);
-};
+}
 
 TEST(RefinedDenseCholesky, FactorAndSolveWithSuccess) {
   auto dense_cholesky = std::make_unique<MockDenseCholesky>();
   auto iterative_refiner = std::make_unique<MockDenseIterativeRefiner>();
   EXPECT_CALL(*dense_cholesky, Factorize(_, _, _))
-      .Times(1)
-      .WillRepeatedly(Return(LinearSolverTerminationType::SUCCESS));
+      .WillOnce(Return(LinearSolverTerminationType::SUCCESS));
   EXPECT_CALL(*dense_cholesky, Solve(_, _, _))
-      .Times(1)
-      .WillRepeatedly(Return(LinearSolverTerminationType::SUCCESS));
+      .WillOnce(Return(LinearSolverTerminationType::SUCCESS));
   EXPECT_CALL(*iterative_refiner, Refine(_, _, _, _, _)).Times(1);
 
   RefinedDenseCholesky refined_dense_cholesky(std::move(dense_cholesky),
@@ -218,6 +216,6 @@
   EXPECT_EQ(
       refined_dense_cholesky.FactorAndSolve(1, &lhs, &rhs, &solution, &message),
       LinearSolverTerminationType::SUCCESS);
-};
+}
 
 }  // namespace ceres::internal

diff --git a/internal/ceres/problem_test.cc b/internal/ceres/problem_test.cc
index 29524d1..6ac8d48 100644
--- a/internal/ceres/problem_test.cc
+++ b/internal/ceres/problem_test.cc

@@ -2208,7 +2208,10 @@
 
 class MockEvaluationCallback : public EvaluationCallback {
  public:
-  MOCK_METHOD2(PrepareForEvaluation, void(bool, bool));
+  MOCK_METHOD(void,
+              PrepareForEvaluation,
+              (bool evaluate_jacobians, bool new_evaluation_point),
+              (override));
 };
 
 TEST(ProblemEvaluate, CallsEvaluationCallbackWithoutJacobian) {

diff --git a/internal/ceres/sparse_cholesky_test.cc b/internal/ceres/sparse_cholesky_test.cc
index 4142a4c..5375150 100644
--- a/internal/ceres/sparse_cholesky_test.cc
+++ b/internal/ceres/sparse_cholesky_test.cc

@@ -289,24 +289,30 @@
 
 class MockSparseCholesky : public SparseCholesky {
  public:
-  MOCK_CONST_METHOD0(StorageType, CompressedRowSparseMatrix::StorageType());
-  MOCK_METHOD2(Factorize,
-               LinearSolverTerminationType(CompressedRowSparseMatrix* lhs,
-                                           std::string* message));
-  MOCK_METHOD3(Solve,
-               LinearSolverTerminationType(const double* rhs,
-                                           double* solution,
-                                           std::string* message));
+  MOCK_METHOD(CompressedRowSparseMatrix::StorageType,
+              StorageType,
+              (),
+              (const, override));
+  MOCK_METHOD(LinearSolverTerminationType,
+              Factorize,
+              (CompressedRowSparseMatrix * lhs, std::string* message),
+              (override));
+  MOCK_METHOD(LinearSolverTerminationType,
+              Solve,
+              (const double* rhs, double* solution, std::string* message),
+              (override));
 };
 
 class MockSparseIterativeRefiner : public SparseIterativeRefiner {
  public:
   MockSparseIterativeRefiner() : SparseIterativeRefiner(1) {}
-  MOCK_METHOD4(Refine,
-               void(const SparseMatrix& lhs,
-                    const double* rhs,
-                    SparseCholesky* sparse_cholesky,
-                    double* solution));
+  MOCK_METHOD(void,
+              Refine,
+              (const SparseMatrix& lhs,
+               const double* rhs,
+               SparseCholesky* sparse_cholesky,
+               double* solution),
+              (override));
 };
 
 using testing::_;
@@ -316,45 +322,36 @@
   auto sparse_cholesky = std::make_unique<MockSparseCholesky>();
   auto iterative_refiner = std::make_unique<MockSparseIterativeRefiner>();
   EXPECT_CALL(*sparse_cholesky, StorageType())
-      .Times(1)
-      .WillRepeatedly(
+      .WillOnce(
           Return(CompressedRowSparseMatrix::StorageType::UPPER_TRIANGULAR));
   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(),
             CompressedRowSparseMatrix::StorageType::UPPER_TRIANGULAR);
-};
+}
 
 TEST(RefinedSparseCholesky, Factorize) {
-  auto* mock_sparse_cholesky = new MockSparseCholesky;
-  auto* mock_iterative_refiner = new MockSparseIterativeRefiner;
-  EXPECT_CALL(*mock_sparse_cholesky, Factorize(_, _))
-      .Times(1)
-      .WillRepeatedly(Return(LinearSolverTerminationType::SUCCESS));
-  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);
+  auto sparse_cholesky = std::make_unique<MockSparseCholesky>();
+  auto iterative_refiner = std::make_unique<MockSparseIterativeRefiner>();
+  EXPECT_CALL(*sparse_cholesky, Factorize(_, _))
+      .WillOnce(Return(LinearSolverTerminationType::SUCCESS));
+  EXPECT_CALL(*iterative_refiner, Refine(_, _, _, _)).Times(0);
   RefinedSparseCholesky refined_sparse_cholesky(std::move(sparse_cholesky),
                                                 std::move(iterative_refiner));
   CompressedRowSparseMatrix m(1, 1, 1);
   std::string message;
   EXPECT_EQ(refined_sparse_cholesky.Factorize(&m, &message),
             LinearSolverTerminationType::SUCCESS);
-};
+}
 
 TEST(RefinedSparseCholesky, FactorAndSolveWithUnsuccessfulFactorization) {
-  auto* mock_sparse_cholesky = new MockSparseCholesky;
-  auto* mock_iterative_refiner = new MockSparseIterativeRefiner;
-  EXPECT_CALL(*mock_sparse_cholesky, Factorize(_, _))
-      .Times(1)
-      .WillRepeatedly(Return(LinearSolverTerminationType::FAILURE));
-  EXPECT_CALL(*mock_sparse_cholesky, Solve(_, _, _)).Times(0);
-  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);
+  auto sparse_cholesky = std::make_unique<MockSparseCholesky>();
+  auto iterative_refiner = std::make_unique<MockSparseIterativeRefiner>();
+  EXPECT_CALL(*sparse_cholesky, Factorize(_, _))
+      .WillOnce(Return(LinearSolverTerminationType::FAILURE));
+  EXPECT_CALL(*sparse_cholesky, Solve(_, _, _)).Times(0);
+  EXPECT_CALL(*iterative_refiner, Refine(_, _, _, _)).Times(0);
   RefinedSparseCholesky refined_sparse_cholesky(std::move(sparse_cholesky),
                                                 std::move(iterative_refiner));
   CompressedRowSparseMatrix m(1, 1, 1);
@@ -364,23 +361,17 @@
   EXPECT_EQ(
       refined_sparse_cholesky.FactorAndSolve(&m, &rhs, &solution, &message),
       LinearSolverTerminationType::FAILURE);
-};
+}
 
 TEST(RefinedSparseCholesky, FactorAndSolveWithSuccess) {
-  auto* mock_sparse_cholesky = new MockSparseCholesky;
-  std::unique_ptr<MockSparseIterativeRefiner> mock_iterative_refiner(
-      new MockSparseIterativeRefiner);
-  EXPECT_CALL(*mock_sparse_cholesky, Factorize(_, _))
-      .Times(1)
-      .WillRepeatedly(Return(LinearSolverTerminationType::SUCCESS));
-  EXPECT_CALL(*mock_sparse_cholesky, Solve(_, _, _))
-      .Times(1)
-      .WillRepeatedly(Return(LinearSolverTerminationType::SUCCESS));
-  EXPECT_CALL(*mock_iterative_refiner, Refine(_, _, _, _)).Times(1);
+  auto sparse_cholesky = std::make_unique<MockSparseCholesky>();
+  auto iterative_refiner = std::make_unique<MockSparseIterativeRefiner>();
+  EXPECT_CALL(*sparse_cholesky, Factorize(_, _))
+      .WillOnce(Return(LinearSolverTerminationType::SUCCESS));
+  EXPECT_CALL(*sparse_cholesky, Solve(_, _, _))
+      .WillOnce(Return(LinearSolverTerminationType::SUCCESS));
+  EXPECT_CALL(*iterative_refiner, Refine(_, _, _, _)).Times(1);
 
-  std::unique_ptr<SparseCholesky> sparse_cholesky(mock_sparse_cholesky);
-  std::unique_ptr<SparseIterativeRefiner> iterative_refiner(
-      std::move(mock_iterative_refiner));
   RefinedSparseCholesky refined_sparse_cholesky(std::move(sparse_cholesky),
                                                 std::move(iterative_refiner));
   CompressedRowSparseMatrix m(1, 1, 1);
@@ -390,7 +381,7 @@
   EXPECT_EQ(
       refined_sparse_cholesky.FactorAndSolve(&m, &rhs, &solution, &message),
       LinearSolverTerminationType::SUCCESS);
-};
+}
 
 }  // namespace