Migrate to standard parameterized test framework

PiperOrigin-RevId: 656497777

src/google/protobuf/io/BUILD.bazel

@@ -209,6 +209,7 @@ cc_test(
         "//src/google/protobuf/testing",
         "//src/google/protobuf/testing:file",
         "@com_google_absl//absl/base",
+        "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/base:log_severity",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/log:absl_check",

src/google/protobuf/io/coded_stream.cc

@@ -20,9 +20,13 @@
 #include <limits.h>
 
 #include <algorithm>
+#include <atomic>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <limits>
+#include <memory>
+#include <string>
 #include <utility>
 
 #include "absl/log/absl_check.h"
@@ -33,7 +37,6 @@
 #include "google/protobuf/arena.h"
 #include "google/protobuf/io/zero_copy_stream.h"
 #include "google/protobuf/io/zero_copy_stream_impl_lite.h"
-#include "google/protobuf/port.h"
 
 
 // Must be included last.

src/google/protobuf/io/coded_stream_unittest.cc

@@ -16,20 +16,29 @@
 #include <limits.h>
 
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <ios>
 #include <memory>
+#include <ostream>
 #include <string>
+#include <tuple>
+#include <utility>
 #include <vector>
 
-#include "google/protobuf/stubs/common.h"
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include "absl/base/casts.h"
 #include "absl/base/log_severity.h"
-#include "absl/log/absl_check.h"
+#include "absl/base/macros.h"
 #include "absl/log/absl_log.h"
 #include "absl/log/scoped_mock_log.h"
 #include "absl/strings/cord.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "google/protobuf/io/zero_copy_stream_impl.h"
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
 
 #include "google/protobuf/testing/googletest.h"
 
@@ -42,72 +51,6 @@ namespace protobuf {
 namespace io {
 namespace {
 
-// ===================================================================
-// Data-Driven Test Infrastructure
-
-// TEST_1D and TEST_2D are macros I'd eventually like to see added to
-// gTest.  These macros can be used to declare tests which should be
-// run multiple times, once for each item in some input array.  TEST_1D
-// tests all cases in a single input array.  TEST_2D tests all
-// combinations of cases from two arrays.  The arrays must be statically
-// defined such that the ABSL_ARRAYSIZE() macro works on them.  Example:
-//
-// int kCases[] = {1, 2, 3, 4}
-// TEST_1D(MyFixture, MyTest, kCases) {
-//   EXPECT_GT(kCases_case, 0);
-// }
-//
-// This test iterates through the numbers 1, 2, 3, and 4 and tests that
-// they are all grater than zero.  In case of failure, the exact case
-// which failed will be printed.  The case type must be printable using
-// ostream::operator<<.
-
-// TODO:  gTest now supports "parameterized tests" which would be
-//   a better way to accomplish this.  Rewrite when time permits.
-
-#define TEST_1D(FIXTURE, NAME, CASES)                             \
-  class FIXTURE##_##NAME##_DD : public FIXTURE {                  \
-   protected:                                                     \
-    template <typename CaseType>                                  \
-    void DoSingleCase(const CaseType& CASES##_case);              \
-  };                                                              \
-                                                                  \
-  TEST_F(FIXTURE##_##NAME##_DD, NAME) {                           \
-    for (size_t i = 0; i < ABSL_ARRAYSIZE(CASES); i++) {          \
-      SCOPED_TRACE(testing::Message()                             \
-                   << #CASES " case #" << i << ": " << CASES[i]); \
-      DoSingleCase(CASES[i]);                                     \
-    }                                                             \
-  }                                                               \
-                                                                  \
-  template <typename CaseType>                                    \
-  void FIXTURE##_##NAME##_DD::DoSingleCase(const CaseType& CASES##_case)
-
-#define TEST_2D(FIXTURE, NAME, CASES1, CASES2)                              \
-  class FIXTURE##_##NAME##_DD : public FIXTURE {                            \
-   protected:                                                               \
-    template <typename CaseType1, typename CaseType2>                       \
-    void DoSingleCase(const CaseType1& CASES1##_case,                       \
-                      const CaseType2& CASES2##_case);                      \
-  };                                                                        \
-                                                                            \
-  TEST_F(FIXTURE##_##NAME##_DD, NAME) {                                     \
-    for (size_t i = 0; i < ABSL_ARRAYSIZE(CASES1); i++) {                   \
-      for (size_t j = 0; j < ABSL_ARRAYSIZE(CASES2); j++) {                 \
-        SCOPED_TRACE(testing::Message()                                     \
-                     << #CASES1 " case #" << i << ": " << CASES1[i] << ", " \
-                     << #CASES2 " case #" << j << ": " << CASES2[j]);       \
-        DoSingleCase(CASES1[i], CASES2[j]);                                 \
-      }                                                                     \
-    }                                                                       \
-  }                                                                         \
-                                                                            \
-  template <typename CaseType1, typename CaseType2>                         \
-  void FIXTURE##_##NAME##_DD::DoSingleCase(const CaseType1& CASES1##_case,  \
-                                           const CaseType2& CASES2##_case)
-
-// ===================================================================
-
 class CodedStreamTest : public testing::Test {
  protected:
   // Buffer used during most of the tests. This assumes tests run sequentially.
@@ -171,7 +114,13 @@ VarintCase kVarintCases[] = {
          (uint64_t{0x26u} << 56) | (uint64_t{0x01u} << 63)},
 };
 
-TEST_2D(CodedStreamTest, ReadVarint32, kVarintCases, kBlockSizes) {
+class VarintCasesWithSizes
+    : public CodedStreamTest,
+      public testing::WithParamInterface<std::tuple<VarintCase, int>> {};
+
+TEST_P(VarintCasesWithSizes, ReadVarint32) {
+  const VarintCase& kVarintCases_case = std::get<0>(GetParam());
+  const int& kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kVarintCases_case.bytes, kVarintCases_case.size);
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -186,7 +135,9 @@ TEST_2D(CodedStreamTest, ReadVarint32, kVarintCases, kBlockSizes) {
   EXPECT_EQ(kVarintCases_case.size, input.ByteCount());
 }
 
-TEST_2D(CodedStreamTest, ReadTag, kVarintCases, kBlockSizes) {
+TEST_P(VarintCasesWithSizes, ReadTag) {
+  const VarintCase& kVarintCases_case = std::get<0>(GetParam());
+  const int& kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kVarintCases_case.bytes, kVarintCases_case.size);
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -231,7 +182,11 @@ TEST_F(CodedStreamTest, EmptyInputBeforeEos) {
   EXPECT_TRUE(input.ConsumedEntireMessage());
 }
 
-TEST_1D(CodedStreamTest, ExpectTag, kVarintCases) {
+class VarintCases : public CodedStreamTest,
+                    public testing::WithParamInterface<VarintCase> {};
+
+TEST_P(VarintCases, ExpectTag) {
+  const VarintCase& kVarintCases_case = GetParam();
   // Leave one byte at the beginning of the buffer so we can read it
   // to force the first buffer to be loaded.
   buffer_[0] = '\0';
@@ -265,7 +220,8 @@ TEST_1D(CodedStreamTest, ExpectTag, kVarintCases) {
   }
 }
 
-TEST_1D(CodedStreamTest, ExpectTagFromArray, kVarintCases) {
+TEST_P(VarintCases, ExpectTagFromArray) {
+  const VarintCase& kVarintCases_case = GetParam();
   memcpy(buffer_, kVarintCases_case.bytes, kVarintCases_case.size);
 
   const uint32_t expected_value =
@@ -283,7 +239,9 @@ TEST_1D(CodedStreamTest, ExpectTagFromArray, kVarintCases) {
   }
 }
 
-TEST_2D(CodedStreamTest, ReadVarint64, kVarintCases, kBlockSizes) {
+TEST_P(VarintCasesWithSizes, ReadVarint64) {
+  const VarintCase& kVarintCases_case = std::get<0>(GetParam());
+  const int& kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kVarintCases_case.bytes, kVarintCases_case.size);
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -298,7 +256,9 @@ TEST_2D(CodedStreamTest, ReadVarint64, kVarintCases, kBlockSizes) {
   EXPECT_EQ(kVarintCases_case.size, input.ByteCount());
 }
 
-TEST_2D(CodedStreamTest, WriteVarint32, kVarintCases, kBlockSizes) {
+TEST_P(VarintCasesWithSizes, WriteVarint32) {
+  const VarintCase& kVarintCases_case = std::get<0>(GetParam());
+  const int& kBlockSizes_case = std::get<1>(GetParam());
   if (kVarintCases_case.value > uint64_t{0x00000000FFFFFFFFu}) {
     // Skip this test for the 64-bit values.
     return;
@@ -320,7 +280,9 @@ TEST_2D(CodedStreamTest, WriteVarint32, kVarintCases, kBlockSizes) {
             memcmp(buffer_, kVarintCases_case.bytes, kVarintCases_case.size));
 }
 
-TEST_2D(CodedStreamTest, WriteVarint64, kVarintCases, kBlockSizes) {
+TEST_P(VarintCasesWithSizes, WriteVarint64) {
+  const VarintCase& kVarintCases_case = std::get<0>(GetParam());
+  const int& kBlockSizes_case = std::get<1>(GetParam());
   ArrayOutputStream output(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -337,11 +299,15 @@ TEST_2D(CodedStreamTest, WriteVarint64, kVarintCases, kBlockSizes) {
             memcmp(buffer_, kVarintCases_case.bytes, kVarintCases_case.size));
 }
 
+class SignedVarintCasesWithSizes
+    : public CodedStreamTest,
+      public testing::WithParamInterface<std::tuple<int32_t, int>> {};
 
 int32_t kSignExtendedVarintCases[] = {0, 1, -1, 1237894, -37895138};
 
-TEST_2D(CodedStreamTest, WriteVarint32SignExtended, kSignExtendedVarintCases,
+TEST_P(SignedVarintCasesWithSizes, WriteVarint32SignExtended) {
-        kBlockSizes) {
+  const int32_t& kSignExtendedVarintCases_case = std::get<0>(GetParam());
+  const int& kBlockSizes_case = std::get<1>(GetParam());
   ArrayOutputStream output(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -386,6 +352,7 @@ struct VarintErrorCase {
   uint8_t bytes[12];
   size_t size;
   bool can_parse;
+  const char* name;
 };
 
 inline std::ostream& operator<<(std::ostream& os, const VarintErrorCase& c) {
@@ -395,24 +362,34 @@ inline std::ostream& operator<<(std::ostream& os, const VarintErrorCase& c) {
 const VarintErrorCase kVarintErrorCases[] = {
     // Control case.  (Insures that there isn't something else wrong that
     // makes parsing always fail.)
-    {{0x00}, 1, true},
+    {{0x00}, 1, true, "Control"},
 
     // No input data.
-    {{}, 0, false},
+    {{}, 0, false, "No_Input"},
 
     // Input ends unexpectedly.
-    {{0xf0, 0xab}, 2, false},
+    {{0xf0, 0xab}, 2, false, "Input_Ends_Unexpectedly"},
 
     // Input ends unexpectedly after 32 bits.
-    {{0xf0, 0xab, 0xc9, 0x9a, 0xf8, 0xb2}, 6, false},
+    {{0xf0, 0xab, 0xc9, 0x9a, 0xf8, 0xb2},
+     6,
+     false,
+     "Input_Ends_Unexpectedly_After_32_Bits"},
 
     // Longer than 10 bytes.
     {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01},
      11,
-     false},
+     false,
+     "Longer_Than_10_Bytes"},
 };
 
-TEST_2D(CodedStreamTest, ReadVarint32Error, kVarintErrorCases, kBlockSizes) {
+class VarintErrorCasesWithSizes
+    : public CodedStreamTest,
+      public testing::WithParamInterface<std::tuple<VarintErrorCase, int>> {};
+
+TEST_P(VarintErrorCasesWithSizes, ReadVarint32Error) {
+  VarintErrorCase kVarintErrorCases_case = std::get<0>(GetParam());
+  int kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kVarintErrorCases_case.bytes, kVarintErrorCases_case.size);
   ArrayInputStream input(buffer_, static_cast<int>(kVarintErrorCases_case.size),
                          kBlockSizes_case);
@@ -422,8 +399,10 @@ TEST_2D(CodedStreamTest, ReadVarint32Error, kVarintErrorCases, kBlockSizes) {
   EXPECT_EQ(kVarintErrorCases_case.can_parse, coded_input.ReadVarint32(&value));
 }
 
-TEST_2D(CodedStreamTest, ReadVarint32Error_LeavesValueInInitializedState,
+TEST_P(VarintErrorCasesWithSizes,
-        kVarintErrorCases, kBlockSizes) {
+       ReadVarint32Error_LeavesValueInInitializedState) {
+  VarintErrorCase kVarintErrorCases_case = std::get<0>(GetParam());
+  int kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kVarintErrorCases_case.bytes, kVarintErrorCases_case.size);
   ArrayInputStream input(buffer_, static_cast<int>(kVarintErrorCases_case.size),
                          kBlockSizes_case);
@@ -437,7 +416,9 @@ TEST_2D(CodedStreamTest, ReadVarint32Error_LeavesValueInInitializedState,
   EXPECT_EQ(value, value);
 }
 
-TEST_2D(CodedStreamTest, ReadVarint64Error, kVarintErrorCases, kBlockSizes) {
+TEST_P(VarintErrorCasesWithSizes, ReadVarint64Error) {
+  VarintErrorCase kVarintErrorCases_case = std::get<0>(GetParam());
+  int kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kVarintErrorCases_case.bytes, kVarintErrorCases_case.size);
   ArrayInputStream input(buffer_, static_cast<int>(kVarintErrorCases_case.size),
                          kBlockSizes_case);
@@ -447,8 +428,10 @@ TEST_2D(CodedStreamTest, ReadVarint64Error, kVarintErrorCases, kBlockSizes) {
   EXPECT_EQ(kVarintErrorCases_case.can_parse, coded_input.ReadVarint64(&value));
 }
 
-TEST_2D(CodedStreamTest, ReadVarint64Error_LeavesValueInInitializedState,
+TEST_P(VarintErrorCasesWithSizes,
-        kVarintErrorCases, kBlockSizes) {
+       ReadVarint64Error_LeavesValueInInitializedState) {
+  VarintErrorCase kVarintErrorCases_case = std::get<0>(GetParam());
+  int kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kVarintErrorCases_case.bytes, kVarintErrorCases_case.size);
   ArrayInputStream input(buffer_, static_cast<int>(kVarintErrorCases_case.size),
                          kBlockSizes_case);
@@ -485,7 +468,11 @@ VarintSizeCase kVarintSizeCases[] = {
     {uint64_t{11964378330978735131u}, 10},
 };
 
-TEST_1D(CodedStreamTest, VarintSize32, kVarintSizeCases) {
+class VarintSizeCases : public CodedStreamTest,
+                        public testing::WithParamInterface<VarintSizeCase> {};
+
+TEST_P(VarintSizeCases, VarintSize32) {
+  VarintSizeCase kVarintSizeCases_case = GetParam();
   if (kVarintSizeCases_case.value > 0xffffffffu) {
     // Skip 64-bit values.
     return;
@@ -496,7 +483,8 @@ TEST_1D(CodedStreamTest, VarintSize32, kVarintSizeCases) {
                 static_cast<uint32_t>(kVarintSizeCases_case.value)));
 }
 
-TEST_1D(CodedStreamTest, VarintSize64, kVarintSizeCases) {
+TEST_P(VarintSizeCases, VarintSize64) {
+  VarintSizeCase kVarintSizeCases_case = GetParam();
   EXPECT_EQ(kVarintSizeCases_case.size,
             CodedOutputStream::VarintSize64(kVarintSizeCases_case.value));
 }
@@ -535,6 +523,20 @@ struct Fixed64Case {
   uint64_t value;                   // Parsed value.
 };
 
+class Fixed32Cases : public CodedStreamTest,
+                     public testing::WithParamInterface<Fixed32Case> {};
+
+class Fixed32CasesWithSizes
+    : public CodedStreamTest,
+      public testing::WithParamInterface<std::tuple<Fixed32Case, int>> {};
+
+class Fixed64Cases : public CodedStreamTest,
+                     public testing::WithParamInterface<Fixed64Case> {};
+
+class Fixed64CasesWithSizes
+    : public CodedStreamTest,
+      public testing::WithParamInterface<std::tuple<Fixed64Case, int>> {};
+
 inline std::ostream& operator<<(std::ostream& os, const Fixed32Case& c) {
   return os << "0x" << std::hex << c.value << std::dec;
 }
@@ -555,7 +557,9 @@ Fixed64Case kFixed64Cases[] = {
      uint64_t{0x8877665544332211u}},
 };
 
-TEST_2D(CodedStreamTest, ReadLittleEndian32, kFixed32Cases, kBlockSizes) {
+TEST_P(Fixed32CasesWithSizes, ReadLittleEndian32) {
+  Fixed32Case kFixed32Cases_case = std::get<0>(GetParam());
+  int kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kFixed32Cases_case.bytes, sizeof(kFixed32Cases_case.bytes));
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -570,7 +574,9 @@ TEST_2D(CodedStreamTest, ReadLittleEndian32, kFixed32Cases, kBlockSizes) {
   EXPECT_EQ(sizeof(uint32_t), input.ByteCount());
 }
 
-TEST_2D(CodedStreamTest, ReadLittleEndian64, kFixed64Cases, kBlockSizes) {
+TEST_P(Fixed64CasesWithSizes, ReadLittleEndian64) {
+  Fixed64Case kFixed64Cases_case = std::get<0>(GetParam());
+  int kBlockSizes_case = std::get<1>(GetParam());
   memcpy(buffer_, kFixed64Cases_case.bytes, sizeof(kFixed64Cases_case.bytes));
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -585,7 +591,9 @@ TEST_2D(CodedStreamTest, ReadLittleEndian64, kFixed64Cases, kBlockSizes) {
   EXPECT_EQ(sizeof(uint64_t), input.ByteCount());
 }
 
-TEST_2D(CodedStreamTest, WriteLittleEndian32, kFixed32Cases, kBlockSizes) {
+TEST_P(Fixed32CasesWithSizes, WriteLittleEndian32) {
+  Fixed32Case kFixed32Cases_case = std::get<0>(GetParam());
+  int kBlockSizes_case = std::get<1>(GetParam());
   ArrayOutputStream output(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -601,7 +609,9 @@ TEST_2D(CodedStreamTest, WriteLittleEndian32, kFixed32Cases, kBlockSizes) {
   EXPECT_EQ(0, memcmp(buffer_, kFixed32Cases_case.bytes, sizeof(uint32_t)));
 }
 
-TEST_2D(CodedStreamTest, WriteLittleEndian64, kFixed64Cases, kBlockSizes) {
+TEST_P(Fixed64CasesWithSizes, WriteLittleEndian64) {
+  Fixed64Case kFixed64Cases_case = std::get<0>(GetParam());
+  int kBlockSizes_case = std::get<1>(GetParam());
   ArrayOutputStream output(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -619,7 +629,8 @@ TEST_2D(CodedStreamTest, WriteLittleEndian64, kFixed64Cases, kBlockSizes) {
 
 // Tests using the static methods to read fixed-size values from raw arrays.
 
-TEST_1D(CodedStreamTest, ReadLittleEndian32FromArray, kFixed32Cases) {
+TEST_P(Fixed32Cases, ReadLittleEndian32FromArray) {
+  Fixed32Case kFixed32Cases_case = GetParam();
   memcpy(buffer_, kFixed32Cases_case.bytes, sizeof(kFixed32Cases_case.bytes));
 
   uint32_t value;
@@ -629,7 +640,8 @@ TEST_1D(CodedStreamTest, ReadLittleEndian32FromArray, kFixed32Cases) {
   EXPECT_TRUE(end == buffer_ + sizeof(value));
 }
 
-TEST_1D(CodedStreamTest, ReadLittleEndian64FromArray, kFixed64Cases) {
+TEST_P(Fixed64Cases, ReadLittleEndian64FromArray) {
+  Fixed64Case kFixed64Cases_case = GetParam();
   memcpy(buffer_, kFixed64Cases_case.bytes, sizeof(kFixed64Cases_case.bytes));
 
   uint64_t value;
@@ -644,7 +656,11 @@ TEST_1D(CodedStreamTest, ReadLittleEndian64FromArray, kFixed64Cases) {
 
 const char kRawBytes[] = "Some bytes which will be written and read raw.";
 
-TEST_1D(CodedStreamTest, ReadRaw, kBlockSizes) {
+class BlockSizes : public CodedStreamTest,
+                   public testing::WithParamInterface<int> {};
+
+TEST_P(BlockSizes, ReadRaw) {
+  int kBlockSizes_case = GetParam();
   memcpy(buffer_, kRawBytes, sizeof(kRawBytes));
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
   char read_buffer[sizeof(kRawBytes)];
@@ -659,7 +675,8 @@ TEST_1D(CodedStreamTest, ReadRaw, kBlockSizes) {
   EXPECT_EQ(sizeof(kRawBytes), input.ByteCount());
 }
 
-TEST_1D(CodedStreamTest, WriteRaw, kBlockSizes) {
+TEST_P(BlockSizes, WriteRaw) {
+  int kBlockSizes_case = GetParam();
   ArrayOutputStream output(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -675,7 +692,8 @@ TEST_1D(CodedStreamTest, WriteRaw, kBlockSizes) {
   EXPECT_EQ(0, memcmp(buffer_, kRawBytes, sizeof(kRawBytes)));
 }
 
-TEST_1D(CodedStreamTest, ReadString, kBlockSizes) {
+TEST_P(BlockSizes, ReadString) {
+  int kBlockSizes_case = GetParam();
   memcpy(buffer_, kRawBytes, sizeof(kRawBytes));
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -691,7 +709,8 @@ TEST_1D(CodedStreamTest, ReadString, kBlockSizes) {
 }
 
 // Check to make sure ReadString doesn't crash on impossibly large strings.
-TEST_1D(CodedStreamTest, ReadStringImpossiblyLarge, kBlockSizes) {
+TEST_P(BlockSizes, ReadStringImpossiblyLarge) {
+  int kBlockSizes_case = GetParam();
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -719,7 +738,8 @@ TEST_F(CodedStreamTest, ReadStringImpossiblyLargeFromStringOnHeap) {
   EXPECT_FALSE(coded_input.ReadString(&str, 1 << 30));
 }
 
-TEST_1D(CodedStreamTest, ReadStringReservesMemoryOnTotalLimit, kBlockSizes) {
+TEST_P(BlockSizes, ReadStringReservesMemoryOnTotalLimit) {
+  int kBlockSizes_case = GetParam();
   memcpy(buffer_, kRawBytes, sizeof(kRawBytes));
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -740,7 +760,8 @@ TEST_1D(CodedStreamTest, ReadStringReservesMemoryOnTotalLimit, kBlockSizes) {
   EXPECT_EQ(strlen(kRawBytes), input.ByteCount());
 }
 
-TEST_1D(CodedStreamTest, ReadStringReservesMemoryOnPushedLimit, kBlockSizes) {
+TEST_P(BlockSizes, ReadStringReservesMemoryOnPushedLimit) {
+  int kBlockSizes_case = GetParam();
   memcpy(buffer_, kRawBytes, sizeof(kRawBytes));
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -908,7 +929,15 @@ TEST_F(CodedStreamTest,
 // -------------------------------------------------------------------
 // Cord reads and writes
 
-TEST_1D(CodedStreamTest, ReadCord, kBlockSizes) {
+class BlockSizesWithResetCords
+    : public CodedStreamTest,
+      public testing::WithParamInterface<std::tuple<int, bool>> {};
+
+class ResetCords : public CodedStreamTest,
+                   public testing::WithParamInterface<bool> {};
+
+TEST_P(BlockSizes, ReadCord) {
+  int kBlockSizes_case = GetParam();
   memcpy(buffer_, kRawBytes, sizeof(kRawBytes));
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -923,8 +952,9 @@ TEST_1D(CodedStreamTest, ReadCord, kBlockSizes) {
   EXPECT_EQ(strlen(kRawBytes), input.ByteCount());
 }
 
-TEST_1D(CodedStreamTest, ReadCordReuseCord, kBlockSizes) {
+TEST_P(BlockSizes, ReadCordReuseCord) {
   ASSERT_GT(sizeof(buffer_), 1362 * sizeof(kRawBytes));
+  int kBlockSizes_case = GetParam();
   for (size_t i = 0; i < 1362; i++) {
     memcpy(buffer_ + i * sizeof(kRawBytes), kRawBytes, sizeof(kRawBytes));
   }
@@ -962,7 +992,9 @@ TEST_1D(CodedStreamTest, ReadCordReuseCord, kBlockSizes) {
   EXPECT_EQ(total_read, input.ByteCount());
 }
 
-TEST_2D(CodedStreamTest, ReadCordWithLimit, kBlockSizes, kResetCords) {
+TEST_P(BlockSizesWithResetCords, ReadCordWithLimit) {
+  int kBlockSizes_case = std::get<0>(GetParam());
+  bool kResetCords_case = std::get<1>(GetParam());
   memcpy(buffer_, kRawBytes, strlen(kRawBytes));
   ArrayInputStream input(buffer_, strlen(kRawBytes), kBlockSizes_case);
   CodedInputStream coded_input(&input);
@@ -986,7 +1018,8 @@ TEST_2D(CodedStreamTest, ReadCordWithLimit, kBlockSizes, kResetCords) {
   EXPECT_EQ(std::string(kRawBytes + 10), std::string(cord));
 }
 
-TEST_1D(CodedStreamTest, ReadLargeCord, kResetCords) {
+TEST_P(ResetCords, ReadLargeCord) {
+  bool kResetCords_case = GetParam();
   absl::Cord large_cord;
   for (int i = 0; i < 1024; i++) {
     large_cord.Append(kRawBytes);
@@ -1007,7 +1040,9 @@ TEST_1D(CodedStreamTest, ReadLargeCord, kResetCords) {
 }
 
 // Check to make sure ReadString doesn't crash on impossibly large strings.
-TEST_2D(CodedStreamTest, ReadCordImpossiblyLarge, kBlockSizes, kResetCords) {
+TEST_P(BlockSizesWithResetCords, ReadCordImpossiblyLarge) {
+  int kBlockSizes_case = std::get<0>(GetParam());
+  bool kResetCords_case = std::get<1>(GetParam());
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -1021,7 +1056,8 @@ TEST_2D(CodedStreamTest, ReadCordImpossiblyLarge, kBlockSizes, kResetCords) {
   }
 }
 
-TEST_1D(CodedStreamTest, WriteCord, kBlockSizes) {
+TEST_P(BlockSizes, WriteCord) {
+  int kBlockSizes_case = GetParam();
   ArrayOutputStream output(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -1091,7 +1127,8 @@ TEST_F(CodedStreamTest, Trim) {
 const char kSkipTestBytes[] =
     "<Before skipping><To be skipped><After skipping>";
 
-TEST_1D(CodedStreamTest, SkipInput, kBlockSizes) {
+TEST_P(BlockSizes, SkipInput) {
+  int kBlockSizes_case = GetParam();
   memcpy(buffer_, kSkipTestBytes, sizeof(kSkipTestBytes));
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
@@ -1174,7 +1211,8 @@ TEST_F(CodedStreamTest, GetDirectBufferPointerInlineInput) {
 // -------------------------------------------------------------------
 // Limits
 
-TEST_1D(CodedStreamTest, BasicLimit, kBlockSizes) {
+TEST_P(BlockSizes, BasicLimit) {
+  int kBlockSizes_case = GetParam();
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -1204,7 +1242,8 @@ TEST_1D(CodedStreamTest, BasicLimit, kBlockSizes) {
 
 // Test what happens when we push two limits where the second (top) one is
 // shorter.
-TEST_1D(CodedStreamTest, SmallLimitOnTopOfBigLimit, kBlockSizes) {
+TEST_P(BlockSizes, SmallLimitOnTopOfBigLimit) {
+  int kBlockSizes_case = GetParam();
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -1246,7 +1285,8 @@ TEST_1D(CodedStreamTest, SmallLimitOnTopOfBigLimit, kBlockSizes) {
 // Test what happens when we push two limits where the second (top) one is
 // longer.  In this case, the top limit is shortened to match the previous
 // limit.
-TEST_1D(CodedStreamTest, BigLimitOnTopOfSmallLimit, kBlockSizes) {
+TEST_P(BlockSizes, BigLimitOnTopOfSmallLimit) {
+  int kBlockSizes_case = GetParam();
   ArrayInputStream input(buffer_, sizeof(buffer_), kBlockSizes_case);
 
   {
@@ -1498,6 +1538,98 @@ TEST_F(CodedStreamTest, InputOver2G) {
   EXPECT_EQ(INT_MAX - 512, input.backup_amount_);
 }
 
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, ResetCords, testing::ValuesIn(kResetCords),
+    [](const testing::TestParamInfo<ResetCords::ParamType>& param_info) {
+      return absl::StrCat("ResetCords_", param_info.param ? "true" : "false");
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, BlockSizesWithResetCords,
+    testing::Combine(testing::ValuesIn(kBlockSizes),
+                     testing::ValuesIn(kResetCords)),
+    [](const testing::TestParamInfo<BlockSizesWithResetCords::ParamType>&
+           param_info) {
+      return absl::StrCat("BlockSize_", std::get<0>(param_info.param),
+                          "_ResetCords_",
+                          std::get<1>(param_info.param) ? "true" : "false");
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, VarintErrorCasesWithSizes,
+    testing::Combine(testing::ValuesIn(kVarintErrorCases),
+                     testing::ValuesIn(kBlockSizes)),
+    [](const testing::TestParamInfo<VarintErrorCasesWithSizes::ParamType>&
+           param_info) {
+      return absl::StrCat("VarintErrorCase_",
+                          std::get<0>(param_info.param).name, "_BlockSize_",
+                          std::get<1>(param_info.param));
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, VarintSizeCases, testing::ValuesIn(kVarintSizeCases),
+    [](const testing::TestParamInfo<VarintSizeCases::ParamType>& param_info) {
+      return absl::StrCat("VarintSizeCase_Value_", param_info.param.value);
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, VarintCases, testing::ValuesIn(kVarintCases),
+    [](const testing::TestParamInfo<VarintCases::ParamType>& param_info) {
+      return absl::StrCat("VarintCase_Value_", param_info.param.value);
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, VarintCasesWithSizes,
+    testing::Combine(testing::ValuesIn(kVarintCases),
+                     testing::ValuesIn(kBlockSizes)),
+    [](const testing::TestParamInfo<VarintCasesWithSizes::ParamType>&
+           param_info) {
+      return absl::StrCat("VarintCase_Value_",
+                          std::get<0>(param_info.param).value, "_BlockSize_",
+                          std::get<1>(param_info.param));
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, BlockSizes, testing::ValuesIn(kBlockSizes),
+    [](const testing::TestParamInfo<BlockSizes::ParamType>& param_info) {
+      return absl::StrCat("BlockSize_", param_info.param);
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, SignedVarintCasesWithSizes,
+    testing::Combine(testing::ValuesIn(kSignExtendedVarintCases),
+                     testing::ValuesIn(kBlockSizes)),
+    [](const testing::TestParamInfo<SignedVarintCasesWithSizes::ParamType>&
+           param_info) {
+      return absl::StrCat("SignedVarintCase_Value_",
+                          std::get<0>(param_info.param) < 0 ? "_Negative_" : "",
+                          std::abs(std::get<0>(param_info.param)),
+                          "_BlockSize_", std::get<1>(param_info.param));
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, Fixed32Cases, testing::ValuesIn(kFixed32Cases),
+    [](const testing::TestParamInfo<Fixed32Cases::ParamType>& param_info) {
+      return absl::StrCat("Fixed32Case_Value_", param_info.param.value);
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, Fixed64Cases, testing::ValuesIn(kFixed64Cases),
+    [](const testing::TestParamInfo<Fixed64Cases::ParamType>& param_info) {
+      return absl::StrCat("Fixed64Case_Value_", param_info.param.value);
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, Fixed32CasesWithSizes,
+    testing::Combine(testing::ValuesIn(kFixed32Cases),
+                     testing::ValuesIn(kBlockSizes)),
+    [](const testing::TestParamInfo<Fixed32CasesWithSizes::ParamType>&
+           param_info) {
+      return absl::StrCat("Fixed32Case_Value_",
+                          std::get<0>(param_info.param).value, "_BlockSize_",
+                          std::get<1>(param_info.param));
+    });
+INSTANTIATE_TEST_SUITE_P(
+    CodedStreamUnitTest, Fixed64CasesWithSizes,
+    testing::Combine(testing::ValuesIn(kFixed64Cases),
+                     testing::ValuesIn(kBlockSizes)),
+    [](const testing::TestParamInfo<Fixed64CasesWithSizes::ParamType>&
+           param_info) {
+      return absl::StrCat("Fixed64Case_Value_",
+                          std::get<0>(param_info.param).value, "_BlockSize_",
+                          std::get<1>(param_info.param));
+    });
+
 }  // namespace
 }  // namespace io
 }  // namespace protobuf