diff --git a/internal/ceres/program_test.cc b/internal/ceres/program_test.cc
index 6cb8e9e..1d9f49c 100644
--- a/internal/ceres/program_test.cc
+++ b/internal/ceres/program_test.cc
@@ -33,6 +33,7 @@
 #include <cmath>
 #include <limits>
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "ceres/internal/integer_sequence_algorithm.h"
@@ -51,9 +52,9 @@
 // A cost function that simply returns its argument.
 class UnaryIdentityCostFunction : public SizedCostFunction<1, 1> {
  public:
-  virtual bool Evaluate(double const* const* parameters,
-                        double* residuals,
-                        double** jacobians) const {
+  bool Evaluate(double const* const* parameters,
+                double* residuals,
+                double** jacobians) const final {
     residuals[0] = parameters[0][0];
     if (jacobians != nullptr && jacobians[0] != nullptr) {
       jacobians[0][0] = 1.0;
@@ -66,10 +67,10 @@
 template <int kNumResiduals, int... Ns>
 class MockCostFunctionBase : public SizedCostFunction<kNumResiduals, Ns...> {
  public:
-  virtual bool Evaluate(double const* const* parameters,
-                        double* residuals,
-                        double** jacobians) const {
-    const int kNumParameters = Sum<integer_sequence<int, Ns...>>::Value;
+  bool Evaluate(double const* const* parameters,
+                double* residuals,
+                double** jacobians) const final {
+    const int kNumParameters = Sum<std::integer_sequence<int, Ns...>>::Value;
 
     for (int i = 0; i < kNumResiduals; ++i) {
       residuals[i] = kNumResiduals + kNumParameters;
@@ -98,7 +99,8 @@
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
   string message;
-  std::unique_ptr<Program> reduced_program(problem.program().CreateReducedProgram(
+  std::unique_ptr<Program> reduced_program(
+      problem.program().CreateReducedProgram(
           &removed_parameter_blocks, &fixed_cost, &message));
 
   EXPECT_EQ(reduced_program->NumParameterBlocks(), 3);
@@ -129,7 +131,6 @@
   EXPECT_EQ(fixed_cost, 9.0);
 }
 
-
 TEST(Program, RemoveFixedBlocksNoResidualBlocks) {
   ProblemImpl problem;
   double x;
@@ -214,17 +215,13 @@
   problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
   problem.SetParameterBlockConstant(&x);
 
-  ResidualBlock *expected_removed_block =
+  ResidualBlock* expected_removed_block =
       problem.program().residual_blocks()[0];
   std::unique_ptr<double[]> scratch(
       new double[expected_removed_block->NumScratchDoublesForEvaluate()]);
   double expected_fixed_cost;
-  expected_removed_block->Evaluate(true,
-                                   &expected_fixed_cost,
-                                   nullptr,
-                                   nullptr,
-                                   scratch.get());
-
+  expected_removed_block->Evaluate(
+      true, &expected_fixed_cost, nullptr, nullptr, scratch.get());
 
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
@@ -238,7 +235,9 @@
   EXPECT_DOUBLE_EQ(fixed_cost, expected_fixed_cost);
 }
 
-TEST(Program, CreateJacobianBlockSparsityTranspose) {
+class BlockJacobianTest : public ::testing::TestWithParam<int> {};
+
+TEST_P(BlockJacobianTest, CreateJacobianBlockSparsityTranspose) {
   ProblemImpl problem;
   double x[2];
   double y[3];
@@ -304,17 +303,24 @@
   Program* program = problem.mutable_program();
   program->SetParameterOffsetsAndIndex();
 
+  const int start_row_block = GetParam();
   std::unique_ptr<TripletSparseMatrix> actual_block_sparse_jacobian(
-      program->CreateJacobianBlockSparsityTranspose());
+      program->CreateJacobianBlockSparsityTranspose(start_row_block));
 
-  Matrix expected_dense_jacobian;
-  expected_block_sparse_jacobian.ToDenseMatrix(&expected_dense_jacobian);
+  Matrix expected_full_dense_jacobian;
+  expected_block_sparse_jacobian.ToDenseMatrix(&expected_full_dense_jacobian);
+  Matrix expected_dense_jacobian =
+      expected_full_dense_jacobian.rightCols(8 - start_row_block);
 
   Matrix actual_dense_jacobian;
   actual_block_sparse_jacobian->ToDenseMatrix(&actual_dense_jacobian);
+  EXPECT_EQ(expected_dense_jacobian.rows(), actual_dense_jacobian.rows());
+  EXPECT_EQ(expected_dense_jacobian.cols(), actual_dense_jacobian.cols());
   EXPECT_EQ((expected_dense_jacobian - actual_dense_jacobian).norm(), 0.0);
 }
 
+INSTANTIATE_TEST_SUITE_P(AllColumns, BlockJacobianTest, ::testing::Range(0, 7));
+
 template <int kNumResiduals, int kNumParameterBlocks>
 class NumParameterBlocksCostFunction : public CostFunction {
  public:
@@ -325,12 +331,11 @@
     }
   }
 
-  virtual ~NumParameterBlocksCostFunction() {
-  }
+  virtual ~NumParameterBlocksCostFunction() {}
 
-  virtual bool Evaluate(double const* const* parameters,
-                        double* residuals,
-                        double** jacobians) const {
+  bool Evaluate(double const* const* parameters,
+                double* residuals,
+                double** jacobians) const final {
     return true;
   }
 };
@@ -391,8 +396,8 @@
   problem.AddResidualBlock(new MockCostFunctionBase<1, 2>(), nullptr, x);
   string error;
   EXPECT_FALSE(problem.program().ParameterBlocksAreFinite(&error));
-  EXPECT_NE(error.find("has at least one invalid value"),
-            string::npos) << error;
+  EXPECT_NE(error.find("has at least one invalid value"), string::npos)
+      << error;
 }
 
 TEST(Program, InfeasibleParameterBlock) {