diff --git a/docs/source/nnls_modeling.rst b/docs/source/nnls_modeling.rst
index 593fcab..b6bec4a 100644
--- a/docs/source/nnls_modeling.rst
+++ b/docs/source/nnls_modeling.rst
@@ -1725,14 +1725,17 @@
 
     Default: `nullptr`
 
-    Using this callback interface, Ceres can notify you when it is
-    about to evaluate the residuals or Jacobians. With the callback,
-    you can share computation between residual blocks by doing the
-    shared computation in
+    Using this callback interface, Ceres will notify you when it is
+    about to evaluate the residuals or Jacobians.
+
+    If an ``evaluation_callback`` is present, Ceres will update the
+    user's parameter blocks to the values that will be used when
+    calling :func:`CostFunction::Evaluate` before calling
+    :func:`EvaluationCallback::PrepareForEvaluation`. One can then use
+    this callback to share (or cache) computation between cost
+    functions by doing the shared computation in
     :func:`EvaluationCallback::PrepareForEvaluation` before Ceres
-    calls :func:`CostFunction::Evaluate`. It also enables caching
-    results between a pure residual evaluation and a residual &
-    Jacobian evaluation.
+    calls :func:`CostFunction::Evaluate`.
 
     Problem does NOT take ownership of the callback.
 
@@ -1752,8 +1755,8 @@
    parameter blocks it expects. The function checks that these match
    the sizes of the parameter blocks listed in parameter_blocks. The
    program aborts if a mismatch is detected. loss_function can be
-   nullptr, in which case the cost of the term is just the squared norm
-   of the residuals.
+   `nullptr`, in which case the cost of the term is just the squared
+   norm of the residuals.
 
    The parameter blocks may be passed together as a
    ``vector<double*>``, or as up to ten separate ``double*`` pointers.
@@ -1997,22 +2000,35 @@
    ``apply_loss_function`` as the name implies allows the user to
    switch the application of the loss function on and off.
 
-   .. NOTE::
+   .. NOTE:: If an :class:`EvaluationCallback` is associated with the
+      problem, then its
+      :func:`EvaluationCallback::PrepareForEvaluation` method will be
+      called every time this method is called with `new_point =
+      true`. This conservatively assumes that the user may have
+      changed the parameter values since the previous call to evaluate
+      / solve.  For improved efficiency, and only if you know that the
+      parameter values have not changed between calls, see
+      :func:`Problem::EvaluateResidualBlockAssumingParametersUnchanged`.
 
-      If an :class:`EvaluationCallback` is associated with the problem
-      then it is the user's responsibility to call
-      :func:`EvaluationCalback::PrepareForEvaluation` it before
-      calling this method.
 
-      This is because, if the user calls this method multiple times,
-      we cannot tell if the underlying parameter blocks have changed
-      between calls or not. So if ``EvaluateResidualBlock`` was
-      responsible for calling the
-      :func:`EvaluationCalback::PrepareForEvaluation`, it will have to
-      do it everytime it is called. Which makes the common case where
-      the parameter blocks do not change, inefficient. So we leave it
-      to the user to call the
-      :func:`EvaluationCalback::PrepareForEvaluation` as needed.
+.. function::  bool EvaluateResidualBlockAssumingParametersUnchanged(ResidualBlockId residual_block_id, bool apply_loss_function, double* cost,double* residuals, double** jacobians) const
+
+    Same as :func:`Problem::EvaluateResidualBlock` except that if an
+    :class:`EvaluationCallback` is associated with the problem, then
+    its :func:`EvaluationCallback::PrepareForEvaluation` method will
+    be called every time this method is called with new_point = false.
+
+    This means, if an :class:`EvaluationCallback` is associated with
+    the problem then it is the user's responsibility to call
+    :func:`EvaluationCallback::PrepareForEvaluation` before calling
+    this method if necessary, i.e. iff the parameter values have been
+    changed since the last call to evaluate / solve.'
+
+    This is because, as the name implies, we assume that the parameter
+    blocks did not change since the last time
+    :func:`EvaluationCallback::PrepareForEvaluation` was called (via
+    :func:`Solve`, :func:`Problem:Evaluate` or
+    :func:`Problem:EvaluateResidualBlock`).
 
 
 .. function:: bool Problem::Evaluate(const Problem::EvaluateOptions& options, double* cost, vector<double>* residuals, vector<double>* gradient, CRSMatrix* jacobian)
@@ -2126,11 +2142,15 @@
                                             bool new_evaluation_point) = 0;
       };
 
-   Ceres will call ``PrepareForEvaluation()`` every time, and once
-   before it computes the residuals and/or the Jacobians.
+.. function:: void EvaluationCallback::PrepareForEvaluation(bool evaluate_jacobians, bool new_evaluation_point)
 
-   User parameters (the double* values provided by the us)
-   are fixed until the next call to ``PrepareForEvaluation()``. If
+   Ceres will call :func:`EvaluationCallback::PrepareForEvaluation`
+   every time, and once before it computes the residuals and/or the
+   Jacobians.
+
+   User parameters (the double* values provided by the us) are fixed
+   until the next call to
+   :func:`EvaluationCallback::PrepareForEvaluation`. If
    ``new_evaluation_point == true``, then this is a new point that is
    different from the last evaluated point. Otherwise, it is the same
    point that was evaluated previously (either Jacobian or residual)
@@ -2138,33 +2158,37 @@
    ``evaluate_jacobians`` is true, then Ceres will request Jacobians
    in the upcoming cost evaluation.
 
-   Using this callback interface, Ceres can notify you when it is about
-   to evaluate the residuals or Jacobians. With the callback, you can
-   share computation between residual blocks by doing the shared
-   computation in PrepareForEvaluation() before Ceres calls
-   CostFunction::Evaluate() on all the residuals. It also enables
-   caching results between a pure residual evaluation and a residual &
-   Jacobian evaluation, via the new_evaluation_point argument.
+   Using this callback interface, Ceres can notify you when it is
+   about to evaluate the residuals or Jacobians. With the callback,
+   you can share computation between residual blocks by doing the
+   shared computation in
+   :func:`EvaluationCallback::PrepareForEvaluation` before Ceres calls
+   :func:`CostFunction::Evaluate` on all the residuals. It also
+   enables caching results between a pure residual evaluation and a
+   residual & Jacobian evaluation, via the ``new_evaluation_point``
+   argument.
 
    One use case for this callback is if the cost function compute is
-   moved to the GPU. In that case, the prepare call does the actual cost
-   function evaluation, and subsequent calls from Ceres to the actual
-   cost functions merely copy the results from the GPU onto the
+   moved to the GPU. In that case, the prepare call does the actual
+   cost function evaluation, and subsequent calls from Ceres to the
+   actual cost functions merely copy the results from the GPU onto the
    corresponding blocks for Ceres to plug into the solver.
 
    **Note**: Ceres provides no mechanism to share data other than the
    notification from the callback. Users must provide access to
    pre-computed shared data to their cost functions behind the scenes;
    this all happens without Ceres knowing. One approach is to put a
-   pointer to the shared data in each cost function (recommended) or to
-   use a global shared variable (discouraged; bug-prone).  As far as
-   Ceres is concerned, it is evaluating cost functions like any other;
-   it just so happens that behind the scenes the cost functions reuse
-   pre-computed data to execute faster.
+   pointer to the shared data in each cost function (recommended) or
+   to use a global shared variable (discouraged; bug-prone).  As far
+   as Ceres is concerned, it is evaluating cost functions like any
+   other; it just so happens that behind the scenes the cost functions
+   reuse pre-computed data to execute faster.
 
-   See ``evaluation_callback_test.cc`` for code that explicitly verifies
-   the preconditions between ``PrepareForEvaluation()`` and
-   ``CostFunction::Evaluate()``.
+   See ``evaluation_callback_test.cc`` for code that explicitly
+   verifies the preconditions between
+   :func:`EvaluationCallback::PrepareForEvaluation` and
+   :func:`CostFunction::Evaluate`.
+
 
 ``rotation.h``
 ==============
diff --git a/include/ceres/problem.h b/include/ceres/problem.h
index 88f9966..76d115b 100644
--- a/include/ceres/problem.h
+++ b/include/ceres/problem.h
@@ -475,7 +475,7 @@
   // at the end of an iteration during a solve.
   //
   // Note 4: If an EvaluationCallback is associated with the problem,
-  // then its PrepareForEvaluation method will be called everytime
+  // then its PrepareForEvaluation method will be called every time
   // this method is called with new_point = true.
   bool Evaluate(const EvaluateOptions& options,
                 double* cost,
@@ -509,23 +509,41 @@
   // apply_loss_function as the name implies allows the user to switch
   // the application of the loss function on and off.
   //
-  // WARNING: If an EvaluationCallback is associated with the problem
-  // then it is the user's responsibility to call it before calling
-  // this method.
-  //
-  // This is because, if the user calls this method multiple times, we
-  // cannot tell if the underlying parameter blocks have changed
-  // between calls or not. So if EvaluateResidualBlock was responsible
-  // for calling the EvaluationCallback, it will have to do it
-  // everytime it is called. Which makes the common case where the
-  // parameter blocks do not change, inefficient. So we leave it to
-  // the user to call the EvaluationCallback as needed.
+  // If an EvaluationCallback is associated with the problem, then its
+  // PrepareForEvaluation method will be called every time this method
+  // is called with new_point = true. This conservatively assumes that
+  // the user may have changed the parameter values since the previous
+  // call to evaluate / solve.  For improved efficiency, and only if
+  // you know that the parameter values have not changed between
+  // calls, see EvaluateResidualBlockAssumingParametersUnchanged().
   bool EvaluateResidualBlock(ResidualBlockId residual_block_id,
                              bool apply_loss_function,
                              double* cost,
                              double* residuals,
                              double** jacobians) const;
 
+  // Same as EvaluateResidualBlock except that if an
+  // EvaluationCallback is associated with the problem, then its
+  // PrepareForEvaluation method will be called every time this method
+  // is called with new_point = false.
+  //
+  // This means, if an EvaluationCallback is associated with the
+  // problem then it is the user's responsibility to call
+  // PrepareForEvaluation before calling this method if necessary,
+  // i.e. iff the parameter values have been changed since the last
+  // call to evaluate / solve.'
+  //
+  // This is because, as the name implies, we assume that the
+  // parameter blocks did not change since the last time
+  // PrepareForEvaluation was called (via Solve, Evaluate or
+  // EvaluateResidualBlock).
+  bool EvaluateResidualBlockAssumingParametersUnchanged(
+      ResidualBlockId residual_block_id,
+      bool apply_loss_function,
+      double* cost,
+      double* residuals,
+      double** jacobians) const;
+
  private:
   friend class Solver;
   friend class Covariance;
diff --git a/internal/ceres/problem.cc b/internal/ceres/problem.cc
index 767fe97..f3ffd54 100644
--- a/internal/ceres/problem.cc
+++ b/internal/ceres/problem.cc
@@ -139,8 +139,26 @@
                                     double* cost,
                                     double* residuals,
                                     double** jacobians) const {
-  return impl_->EvaluateResidualBlock(
-      residual_block_id, apply_loss_function, cost, residuals, jacobians);
+  return impl_->EvaluateResidualBlock(residual_block_id,
+                                      apply_loss_function,
+                                      /* new_point = */ true,
+                                      cost,
+                                      residuals,
+                                      jacobians);
+}
+
+bool Problem::EvaluateResidualBlockAssumingParametersUnchanged(
+    ResidualBlockId residual_block_id,
+    bool apply_loss_function,
+    double* cost,
+    double* residuals,
+    double** jacobians) const {
+  return impl_->EvaluateResidualBlock(residual_block_id,
+                                      apply_loss_function,
+                                      /* new_point = */ false,
+                                      cost,
+                                      residuals,
+                                      jacobians);
 }
 
 int Problem::NumParameterBlocks() const { return impl_->NumParameterBlocks(); }
diff --git a/internal/ceres/problem_impl.cc b/internal/ceres/problem_impl.cc
index 6cc4d33..20da652 100644
--- a/internal/ceres/problem_impl.cc
+++ b/internal/ceres/problem_impl.cc
@@ -601,7 +601,6 @@
                            CRSMatrix* jacobian) {
   if (cost == nullptr && residuals == nullptr && gradient == nullptr &&
       jacobian == nullptr) {
-    LOG(INFO) << "Nothing to do.";
     return true;
   }
 
@@ -768,9 +767,15 @@
 
 bool ProblemImpl::EvaluateResidualBlock(ResidualBlock* residual_block,
                                         bool apply_loss_function,
+                                        bool new_point,
                                         double* cost,
                                         double* residuals,
                                         double** jacobians) const {
+  auto evaluation_callback = program_->mutable_evaluation_callback();
+  if (evaluation_callback) {
+    evaluation_callback->PrepareForEvaluation(jacobians != nullptr, new_point);
+  }
+
   ParameterBlock* const* parameter_blocks = residual_block->parameter_blocks();
   const int num_parameter_blocks = residual_block->NumParameterBlocks();
   for (int i = 0; i < num_parameter_blocks; ++i) {
@@ -789,7 +794,8 @@
   }
 
   double dummy_cost = 0.0;
-  FixedArray<double> scratch(residual_block->NumScratchDoublesForEvaluate());
+  FixedArray<double, 32> scratch(
+      residual_block->NumScratchDoublesForEvaluate());
   return residual_block->Evaluate(apply_loss_function,
                                   cost ? cost : &dummy_cost,
                                   residuals,
diff --git a/internal/ceres/problem_impl.h b/internal/ceres/problem_impl.h
index 8bbe723..004918a 100644
--- a/internal/ceres/problem_impl.h
+++ b/internal/ceres/problem_impl.h
@@ -124,6 +124,7 @@
 
   bool EvaluateResidualBlock(ResidualBlock* residual_block,
                              bool apply_loss_function,
+                             bool new_point,
                              double* cost,
                              double* residuals,
                              double** jacobians) const;
diff --git a/internal/ceres/problem_test.cc b/internal/ceres/problem_test.cc
index 9093b7a..e3c77a0 100644
--- a/internal/ceres/problem_test.cc
+++ b/internal/ceres/problem_test.cc
@@ -49,6 +49,7 @@
 #include "ceres/sparse_matrix.h"
 #include "ceres/types.h"
 #include "gtest/gtest.h"
+#include "gmock/gmock.h"
 
 namespace ceres {
 namespace internal {
@@ -1570,6 +1571,8 @@
  public:
   static constexpr bool kApplyLossFunction = true;
   static constexpr bool kDoNotApplyLossFunction = false;
+  static constexpr bool kNewPoint = true;
+  static constexpr bool kNotNewPoint = false;
   static double loss_function_scale_;
 
  protected:
@@ -1599,6 +1602,7 @@
   double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -1625,8 +1629,12 @@
        OneResidualBlockNoLossFunctionNullEval) {
   ResidualBlockId residual_block_id =
       problem_.AddResidualBlock(IdentityFunctor::Create(), nullptr, x_, y_);
-  EXPECT_TRUE(problem_.EvaluateResidualBlock(
-      residual_block_id, kApplyLossFunction, nullptr, nullptr, nullptr));
+  EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
+                                             kApplyLossFunction,
+                                             kNewPoint,
+                                             nullptr,
+                                             nullptr,
+                                             nullptr));
 }
 
 TEST_F(ProblemEvaluateResidualBlockTest, OneResidualBlockNoLossFunctionCost) {
@@ -1637,8 +1645,12 @@
   double expected_cost = expected_f.squaredNorm() / 2.0;
 
   double actual_cost;
-  EXPECT_TRUE(problem_.EvaluateResidualBlock(
-      residual_block_id, kApplyLossFunction, &actual_cost, nullptr, nullptr));
+  EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
+                                             kApplyLossFunction,
+                                             kNewPoint,
+                                             &actual_cost,
+                                             nullptr,
+                                             nullptr));
 
   EXPECT_NEAR(std::abs(expected_cost - actual_cost) / actual_cost,
               0,
@@ -1658,6 +1670,7 @@
   Vector actual_f(5);
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              nullptr));
@@ -1688,6 +1701,7 @@
   double* jacobians[2] = {actual_dfdx.data(), nullptr};
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -1715,6 +1729,7 @@
   Vector actual_f(5);
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              nullptr,
                                              actual_f.data(),
                                              nullptr));
@@ -1749,6 +1764,7 @@
   double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -1793,6 +1809,7 @@
   double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kDoNotApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -1836,6 +1853,7 @@
   double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -1880,6 +1898,7 @@
   double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -1923,6 +1942,7 @@
   double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
   EXPECT_FALSE(problem_.EvaluateResidualBlock(residual_block_id,
                                               kApplyLossFunction,
+                                              kNewPoint,
                                               &actual_cost,
                                               actual_f.data(),
                                               jacobians));
@@ -1930,6 +1950,7 @@
   jacobians[0] = nullptr;
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -1968,6 +1989,7 @@
   double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
   EXPECT_FALSE(problem_.EvaluateResidualBlock(residual_block_id,
                                               kApplyLossFunction,
+                                              kNewPoint,
                                               &actual_cost,
                                               actual_f.data(),
                                               jacobians));
@@ -1975,12 +1997,14 @@
   jacobians[0] = nullptr;
   EXPECT_FALSE(problem_.EvaluateResidualBlock(residual_block_id,
                                               kApplyLossFunction,
+                                              kNewPoint,
                                               &actual_cost,
                                               actual_f.data(),
                                               jacobians));
   jacobians[1] = nullptr;
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -2018,6 +2042,7 @@
   double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
   EXPECT_FALSE(problem_.EvaluateResidualBlock(residual_block_id,
                                               kApplyLossFunction,
+                                              kNewPoint,
                                               &actual_cost,
                                               actual_f.data(),
                                               jacobians));
@@ -2025,6 +2050,7 @@
   jacobians[0] = nullptr;
   EXPECT_TRUE(problem_.EvaluateResidualBlock(residual_block_id,
                                              kApplyLossFunction,
+                                             kNewPoint,
                                              &actual_cost,
                                              actual_f.data(),
                                              jacobians));
@@ -2132,5 +2158,119 @@
   EXPECT_TRUE(problem.IsParameterBlockConstant(&y));
 }
 
+class MockEvaluationCallback : public EvaluationCallback {
+ public:
+  MOCK_METHOD2(PrepareForEvaluation, void(bool, bool));
+};
+
+TEST(ProblemEvaluate, CallsEvaluationCallbackWithoutJacobian) {
+  constexpr bool kDoNotComputeJacobians = false;
+  constexpr bool kNewPoint = true;
+
+  MockEvaluationCallback evaluation_callback;
+  EXPECT_CALL(evaluation_callback,
+              PrepareForEvaluation(kDoNotComputeJacobians, kNewPoint))
+      .Times(1);
+
+  Problem::Options options;
+  options.evaluation_callback = &evaluation_callback;
+  ProblemImpl problem(options);
+  double x_[2] = {1, 2};
+  double y_[3] = {1, 2, 3};
+  ResidualBlockId residual_block_id =
+      problem.AddResidualBlock(IdentityFunctor::Create(), nullptr, x_, y_);
+
+  double actual_cost;
+  Vector actual_f(5);
+  Matrix actual_dfdx(5, 2);
+  Matrix actual_dfdy(5, 3);
+  double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
+  EXPECT_TRUE(problem.Evaluate(
+      Problem::EvaluateOptions(), &actual_cost, nullptr, nullptr, nullptr));
+}
+
+TEST(ProblemEvaluate, CallsEvaluationCallbackWithJacobian) {
+  constexpr bool kComputeJacobians = true;
+  constexpr bool kNewPoint = true;
+
+  MockEvaluationCallback evaluation_callback;
+  EXPECT_CALL(evaluation_callback,
+              PrepareForEvaluation(kComputeJacobians, kNewPoint))
+      .Times(1);
+
+  Problem::Options options;
+  options.evaluation_callback = &evaluation_callback;
+  ProblemImpl problem(options);
+  double x_[2] = {1, 2};
+  double y_[3] = {1, 2, 3};
+  ResidualBlockId residual_block_id =
+      problem.AddResidualBlock(IdentityFunctor::Create(), nullptr, x_, y_);
+
+  double actual_cost;
+  Vector actual_f(5);
+  Matrix actual_dfdx(5, 2);
+  Matrix actual_dfdy(5, 3);
+  double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
+  ceres::CRSMatrix jacobian;
+  EXPECT_TRUE(problem.Evaluate(
+      Problem::EvaluateOptions(), &actual_cost, nullptr, nullptr, &jacobian));
+}
+
+TEST(ProblemEvaluateResidualBlock, NewPointCallsEvaluationCallback) {
+  constexpr bool kComputeJacobians = true;
+  constexpr bool kNewPoint = true;
+
+  MockEvaluationCallback evaluation_callback;
+  EXPECT_CALL(evaluation_callback,
+              PrepareForEvaluation(kComputeJacobians, kNewPoint))
+      .Times(1);
+
+  Problem::Options options;
+  options.evaluation_callback = &evaluation_callback;
+  ProblemImpl problem(options);
+  double x_[2] = {1, 2};
+  double y_[3] = {1, 2, 3};
+  ResidualBlockId residual_block_id =
+      problem.AddResidualBlock(IdentityFunctor::Create(), nullptr, x_, y_);
+
+  double actual_cost;
+  Vector actual_f(5);
+  Matrix actual_dfdx(5, 2);
+  Matrix actual_dfdy(5, 3);
+  double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
+  EXPECT_TRUE(problem.EvaluateResidualBlock(
+      residual_block_id, true, true, &actual_cost, actual_f.data(), jacobians));
+}
+
+TEST(ProblemEvaluateResidualBlock, OldPointCallsEvaluationCallback) {
+  constexpr bool kComputeJacobians = true;
+  constexpr bool kOldPoint = false;
+
+  MockEvaluationCallback evaluation_callback;
+  EXPECT_CALL(evaluation_callback,
+              PrepareForEvaluation(kComputeJacobians, kOldPoint))
+      .Times(1);
+
+  Problem::Options options;
+  options.evaluation_callback = &evaluation_callback;
+  ProblemImpl problem(options);
+  double x_[2] = {1, 2};
+  double y_[3] = {1, 2, 3};
+  ResidualBlockId residual_block_id =
+      problem.AddResidualBlock(IdentityFunctor::Create(), nullptr, x_, y_);
+
+  double actual_cost;
+  Vector actual_f(5);
+  Matrix actual_dfdx(5, 2);
+  Matrix actual_dfdy(5, 3);
+  double* jacobians[2] = {actual_dfdx.data(), actual_dfdy.data()};
+  EXPECT_TRUE(problem.EvaluateResidualBlock(residual_block_id,
+                                            true,
+                                            false,
+                                            &actual_cost,
+                                            actual_f.data(),
+                                            jacobians));
+}
+
 }  // namespace internal
 }  // namespace ceres