ARROW-8036: [C++] Avoid gtest 1.10 deprecation warnings

Closes #6563 from pitrou/ARROW-8036-gtest-deprecations

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>

cpp/src/arrow/array/concatenate_test.cc

@@ -138,7 +138,7 @@ class PrimitiveConcatenateTest : public ConcatenateTest {
 using PrimitiveTypes =
     ::testing::Types<BooleanType, Int8Type, UInt8Type, Int16Type, UInt16Type, Int32Type,
                      UInt32Type, Int64Type, UInt64Type, FloatType, DoubleType>;
-TYPED_TEST_CASE(PrimitiveConcatenateTest, PrimitiveTypes);
+TYPED_TEST_SUITE(PrimitiveConcatenateTest, PrimitiveTypes);
 
 TYPED_TEST(PrimitiveConcatenateTest, Primitives) {
   this->Check([this](int64_t size, double null_probability, std::shared_ptr<Array>* out) {

cpp/src/arrow/array/diff_test.cc

@@ -163,7 +163,7 @@ class DiffTestWithNumeric : public DiffTest {
   }
 };
 
-TYPED_TEST_CASE(DiffTestWithNumeric, NumericArrowTypes);
+TYPED_TEST_SUITE(DiffTestWithNumeric, NumericArrowTypes);
 
 TYPED_TEST(DiffTestWithNumeric, Basics) {
   // insert one

cpp/src/arrow/array_binary_test.cc

@@ -271,7 +271,7 @@ class TestStringArray : public ::testing::Test {
   std::shared_ptr<ArrayType> strings_;
 };
 
-TYPED_TEST_CASE(TestStringArray, StringTypes);
+TYPED_TEST_SUITE(TestStringArray, StringTypes);
 
 TYPED_TEST(TestStringArray, TestArrayBasics) { this->TestArrayBasics(); }
 
@@ -485,7 +485,7 @@ class TestStringBuilder : public TestBuilder {
   std::shared_ptr<ArrayType> result_;
 };
 
-TYPED_TEST_CASE(TestStringBuilder, StringTypes);
+TYPED_TEST_SUITE(TestStringBuilder, StringTypes);
 
 TYPED_TEST(TestStringBuilder, TestScalarAppend) { this->TestScalarAppend(); }
 
@@ -707,7 +707,7 @@ class TestBinaryDataVisitor : public ::testing::Test {
   std::shared_ptr<DataType> type_;
 };
 
-TYPED_TEST_CASE(TestBinaryDataVisitor, StringTypes);
+TYPED_TEST_SUITE(TestBinaryDataVisitor, StringTypes);
 
 TYPED_TEST(TestBinaryDataVisitor, Basics) { this->TestBasics(); }
 

cpp/src/arrow/array_dict_test.cc

@@ -50,7 +50,7 @@ typedef ::testing::Types<Int8Type, UInt8Type, Int16Type, UInt16Type, Int32Type,
                          UInt32Type, Int64Type, UInt64Type, FloatType, DoubleType>
     PrimitiveDictionaries;
 
-TYPED_TEST_CASE(TestDictionaryBuilder, PrimitiveDictionaries);
+TYPED_TEST_SUITE(TestDictionaryBuilder, PrimitiveDictionaries);
 
 TYPED_TEST(TestDictionaryBuilder, Basic) {
   using c_type = typename TypeParam::c_type;

cpp/src/arrow/array_list_test.cc

@@ -442,7 +442,7 @@ class TestListArray : public TestBuilder {
   std::shared_ptr<ArrayType> result_;
 };
 
-TYPED_TEST_CASE(TestListArray, ListTypes);
+TYPED_TEST_SUITE(TestListArray, ListTypes);
 
 TYPED_TEST(TestListArray, Basics) { this->TestBasics(); }
 

cpp/src/arrow/array_test.cc

@@ -638,7 +638,7 @@ typedef ::testing::Types<PBoolean, PUInt8, PUInt16, PUInt32, PUInt64, PInt8, PIn
                          PInt32, PInt64, PFloat, PDouble>
     Primitives;
 
-TYPED_TEST_CASE(TestPrimitiveBuilder, Primitives);
+TYPED_TEST_SUITE(TestPrimitiveBuilder, Primitives);
 
 TYPED_TEST(TestPrimitiveBuilder, TestInit) {
   ASSERT_OK(this->builder_->Reserve(1000));
@@ -2099,7 +2099,7 @@ TEST_P(DecimalTest, WithNulls) {
   this->TestCreate(precision, draw, valid_bytes, 2);
 }
 
-INSTANTIATE_TEST_CASE_P(DecimalTest, DecimalTest, ::testing::Range(1, 38));
+INSTANTIATE_TEST_SUITE_P(DecimalTest, DecimalTest, ::testing::Range(1, 38));
 
 // ----------------------------------------------------------------------
 // Test rechunking

cpp/src/arrow/buffer_test.cc

@@ -633,7 +633,7 @@ class TypedTestBufferBuilder : public ::testing::Test {};
 
 using BufferBuilderElements = ::testing::Types<int16_t, uint32_t, double>;
 
-TYPED_TEST_CASE(TypedTestBufferBuilder, BufferBuilderElements);
+TYPED_TEST_SUITE(TypedTestBufferBuilder, BufferBuilderElements);
 
 TYPED_TEST(TypedTestBufferBuilder, BasicTypedBufferBuilderUsage) {
   TypedBufferBuilder<TypeParam> builder;
@@ -733,7 +733,7 @@ class TypedTestBuffer : public ::testing::Test {};
 using BufferPtrs =
     ::testing::Types<std::shared_ptr<ResizableBuffer>, std::unique_ptr<ResizableBuffer>>;
 
-TYPED_TEST_CASE(TypedTestBuffer, BufferPtrs);
+TYPED_TEST_SUITE(TypedTestBuffer, BufferPtrs);
 
 TYPED_TEST(TypedTestBuffer, IsMutableFlag) {
   Buffer buf(nullptr, 0);

cpp/src/arrow/compute/kernels/add-test.cc

@@ -60,11 +60,11 @@ class TestArithmeticKernel : public ComputeFixture, public TestBase {
 
 template <typename ArrowType>
 class TestArithmeticKernelForReal : public TestArithmeticKernel<ArrowType> {};
-TYPED_TEST_CASE(TestArithmeticKernelForReal, RealArrowTypes);
+TYPED_TEST_SUITE(TestArithmeticKernelForReal, RealArrowTypes);
 
 template <typename ArrowType>
 class TestArithmeticKernelForIntegral : public TestArithmeticKernel<ArrowType> {};
-TYPED_TEST_CASE(TestArithmeticKernelForIntegral, IntegralArrowTypes);
+TYPED_TEST_SUITE(TestArithmeticKernelForIntegral, IntegralArrowTypes);
 
 TYPED_TEST(TestArithmeticKernelForReal, SortReal) {
   this->AssertAdd("[]", "[]", "[]");

cpp/src/arrow/compute/kernels/aggregate_test.cc

@@ -136,7 +136,7 @@ void ValidateSum(FunctionContext* ctx, const Array& array) {
 template <typename ArrowType>
 class TestNumericSumKernel : public ComputeFixture, public TestBase {};
 
-TYPED_TEST_CASE(TestNumericSumKernel, NumericArrowTypes);
+TYPED_TEST_SUITE(TestNumericSumKernel, NumericArrowTypes);
 TYPED_TEST(TestNumericSumKernel, SimpleSum) {
   using SumType = typename FindAccumulatorType<TypeParam>::Type;
   using ScalarType = typename TypeTraits<SumType>::ScalarType;
@@ -173,7 +173,7 @@ TYPED_TEST(TestNumericSumKernel, SimpleSum) {
 template <typename ArrowType>
 class TestRandomNumericSumKernel : public ComputeFixture, public TestBase {};
 
-TYPED_TEST_CASE(TestRandomNumericSumKernel, NumericArrowTypes);
+TYPED_TEST_SUITE(TestRandomNumericSumKernel, NumericArrowTypes);
 TYPED_TEST(TestRandomNumericSumKernel, RandomArraySum) {
   auto rand = random::RandomArrayGenerator(0x5487655);
   for (size_t i = 3; i < 14; i += 2) {
@@ -248,7 +248,7 @@ void ValidateMean(FunctionContext* ctx, const Array& array) {
 template <typename ArrowType>
 class TestMeanKernelNumeric : public ComputeFixture, public TestBase {};
 
-TYPED_TEST_CASE(TestMeanKernelNumeric, NumericArrowTypes);
+TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
 TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
   using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
 
@@ -272,7 +272,7 @@ TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
 template <typename ArrowType>
 class TestRandomNumericMeanKernel : public ComputeFixture, public TestBase {};
 
-TYPED_TEST_CASE(TestRandomNumericMeanKernel, NumericArrowTypes);
+TYPED_TEST_SUITE(TestRandomNumericMeanKernel, NumericArrowTypes);
 TYPED_TEST(TestRandomNumericMeanKernel, RandomArrayMean) {
   auto rand = random::RandomArrayGenerator(0x8afc055);
   for (size_t i = 3; i < 14; i += 2) {
@@ -326,7 +326,7 @@ void ValidateCount(FunctionContext* ctx, const Array& input) {
 template <typename ArrowType>
 class TestCountKernel : public ComputeFixture, public TestBase {};
 
-TYPED_TEST_CASE(TestCountKernel, NumericArrowTypes);
+TYPED_TEST_SUITE(TestCountKernel, NumericArrowTypes);
 TYPED_TEST(TestCountKernel, SimpleCount) {
   ValidateCount<TypeParam>(&this->ctx_, "[]", {0, 0});
   ValidateCount<TypeParam>(&this->ctx_, "[null]", {0, 1});
@@ -338,7 +338,7 @@ TYPED_TEST(TestCountKernel, SimpleCount) {
 template <typename ArrowType>
 class TestRandomNumericCountKernel : public ComputeFixture, public TestBase {};
 
-TYPED_TEST_CASE(TestRandomNumericCountKernel, NumericArrowTypes);
+TYPED_TEST_SUITE(TestRandomNumericCountKernel, NumericArrowTypes);
 TYPED_TEST(TestRandomNumericCountKernel, RandomArrayCount) {
   auto rand = random::RandomArrayGenerator(0x1205643);
   for (size_t i = 3; i < 14; i++) {
@@ -389,14 +389,14 @@ class TestNumericMinMaxKernel : public ComputeFixture, public TestBase {
 template <typename ArrowType>
 class TestFloatingMinMaxKernel : public TestNumericMinMaxKernel<ArrowType> {};
 
-TYPED_TEST_CASE(TestNumericMinMaxKernel, IntegralArrowTypes);
+TYPED_TEST_SUITE(TestNumericMinMaxKernel, IntegralArrowTypes);
 TYPED_TEST(TestNumericMinMaxKernel, Basics) {
   MinMaxOptions options;
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   this->AssertMinMaxIs("[5, null, 2, 3, 4]", 2, 5, options);
 }
 
-TYPED_TEST_CASE(TestFloatingMinMaxKernel, RealArrowTypes);
+TYPED_TEST_SUITE(TestFloatingMinMaxKernel, RealArrowTypes);
 TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
   MinMaxOptions options;
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);

cpp/src/arrow/compute/kernels/cast_test.cc

@@ -1380,7 +1380,7 @@ typedef ::testing::Types<NullType, UInt8Type, Int8Type, UInt16Type, Int16Type, I
                          Date32Type, Date64Type, FixedSizeBinaryType, BinaryType>
     TestTypes;
 
-TYPED_TEST_CASE(TestNullCast, TestTypes);
+TYPED_TEST_SUITE(TestNullCast, TestTypes);
 
 TYPED_TEST(TestNullCast, FromNull) {
   // Null casts to everything
@@ -1412,7 +1412,7 @@ typedef ::testing::Types<NullType, UInt8Type, Int8Type, UInt16Type, Int16Type, I
                          Date32Type, Date64Type, FixedSizeBinaryType, BinaryType>
     TestTypes;
 
-TYPED_TEST_CASE(TestDictionaryCast, TestTypes);
+TYPED_TEST_SUITE(TestDictionaryCast, TestTypes);
 
 TYPED_TEST(TestDictionaryCast, Basic) {
   CastOptions options;

cpp/src/arrow/compute/kernels/compare_test.cc

@@ -247,7 +247,7 @@ void ValidateCompare(FunctionContext* ctx, CompareOptions options, const Datum&
 template <typename ArrowType>
 class TestNumericCompareKernel : public ComputeFixture, public TestBase {};
 
-TYPED_TEST_CASE(TestNumericCompareKernel, NumericArrowTypes);
+TYPED_TEST_SUITE(TestNumericCompareKernel, NumericArrowTypes);
 TYPED_TEST(TestNumericCompareKernel, SimpleCompareArrayScalar) {
   using ScalarType = typename TypeTraits<TypeParam>::ScalarType;
   using CType = typename TypeTraits<TypeParam>::CType;
@@ -373,7 +373,7 @@ TYPED_TEST(TestNumericCompareKernel, TestNullScalar) {
   ValidateCompare<TypeParam>(&this->ctx_, eq, null, "[1,2,3]", "[null, null, null]");
 }
 
-TYPED_TEST_CASE(TestNumericCompareKernel, NumericArrowTypes);
+TYPED_TEST_SUITE(TestNumericCompareKernel, NumericArrowTypes);
 TYPED_TEST(TestNumericCompareKernel, RandomCompareArrayScalar) {
   using ScalarType = typename TypeTraits<TypeParam>::ScalarType;
   using CType = typename TypeTraits<TypeParam>::CType;

cpp/src/arrow/compute/kernels/filter_test.cc

@@ -134,7 +134,7 @@ class TestFilterKernelWithNumeric : public TestFilterKernel<ArrowType> {
   }
 };
 
-TYPED_TEST_CASE(TestFilterKernelWithNumeric, NumericArrowTypes);
+TYPED_TEST_SUITE(TestFilterKernelWithNumeric, NumericArrowTypes);
 TYPED_TEST(TestFilterKernelWithNumeric, FilterNumeric) {
   this->AssertFilter("[]", "[]", "[]");
 
@@ -332,7 +332,7 @@ class TestFilterKernelWithString : public TestFilterKernel<TypeClass> {
   }
 };
 
-TYPED_TEST_CASE(TestFilterKernelWithString, StringTypes);
+TYPED_TEST_SUITE(TestFilterKernelWithString, StringTypes);
 
 TYPED_TEST(TestFilterKernelWithString, FilterString) {
   this->AssertFilter(R"(["a", "b", "c"])", "[0, 1, 0]", R"(["b"])");

cpp/src/arrow/compute/kernels/hash_test.cc

@@ -163,7 +163,7 @@ typedef ::testing::Types<Int8Type, UInt8Type, Int16Type, UInt16Type, Int32Type,
                          Date32Type, Date64Type>
     PrimitiveDictionaries;
 
-TYPED_TEST_CASE(TestHashKernelPrimitive, PrimitiveDictionaries);
+TYPED_TEST_SUITE(TestHashKernelPrimitive, PrimitiveDictionaries);
 
 TYPED_TEST(TestHashKernelPrimitive, Unique) {
   using T = typename TypeParam::c_type;
@@ -360,7 +360,7 @@ class TestHashKernelBinaryTypes : public TestHashKernel {
   }
 };
 
-TYPED_TEST_CASE(TestHashKernelBinaryTypes, StringTypes);
+TYPED_TEST_SUITE(TestHashKernelBinaryTypes, StringTypes);
 
 TYPED_TEST(TestHashKernelBinaryTypes, Unique) {
   this->CheckUniqueP({"test", "", "test2", "test"}, {true, false, true, true},

cpp/src/arrow/compute/kernels/isin_test.cc

@@ -79,7 +79,7 @@ typedef ::testing::Types<Int8Type, UInt8Type, Int16Type, UInt16Type, Int32Type,
                          Date32Type, Date64Type>
     PrimitiveDictionaries;
 
-TYPED_TEST_CASE(TestIsInKernelPrimitive, PrimitiveDictionaries);
+TYPED_TEST_SUITE(TestIsInKernelPrimitive, PrimitiveDictionaries);
 
 TYPED_TEST(TestIsInKernelPrimitive, IsIn) {
   using T = typename TypeParam::c_type;
@@ -247,7 +247,7 @@ template <typename Type>
 class TestIsInKernelBinary : public ComputeFixture, public TestBase {};
 
 using BinaryTypes = ::testing::Types<BinaryType, StringType>;
-TYPED_TEST_CASE(TestIsInKernelBinary, BinaryTypes);
+TYPED_TEST_SUITE(TestIsInKernelBinary, BinaryTypes);
 
 TYPED_TEST(TestIsInKernelBinary, IsInBinary) {
   auto type = TypeTraits<TypeParam>::type_singleton();

cpp/src/arrow/compute/kernels/nth_to_indices_test.cc

@@ -98,15 +98,15 @@ class TestNthToIndicesKernel : public ComputeFixture, public TestBase {
 
 template <typename ArrowType>
 class TestNthToIndicesKernelForReal : public TestNthToIndicesKernel<ArrowType> {};
-TYPED_TEST_CASE(TestNthToIndicesKernelForReal, RealArrowTypes);
+TYPED_TEST_SUITE(TestNthToIndicesKernelForReal, RealArrowTypes);
 
 template <typename ArrowType>
 class TestNthToIndicesKernelForIntegral : public TestNthToIndicesKernel<ArrowType> {};
-TYPED_TEST_CASE(TestNthToIndicesKernelForIntegral, IntegralArrowTypes);
+TYPED_TEST_SUITE(TestNthToIndicesKernelForIntegral, IntegralArrowTypes);
 
 template <typename ArrowType>
 class TestNthToIndicesKernelForStrings : public TestNthToIndicesKernel<ArrowType> {};
-TYPED_TEST_CASE(TestNthToIndicesKernelForStrings, testing::Types<StringType>);
+TYPED_TEST_SUITE(TestNthToIndicesKernelForStrings, testing::Types<StringType>);
 
 TYPED_TEST(TestNthToIndicesKernelForReal, NthReal) {
   this->AssertNthToIndicesJson("[null, 1, 3.3, null, 2, 5.3]", 0);
@@ -167,7 +167,7 @@ class Random<StringType> : public RandomImpl {
   }
 };
 
-TYPED_TEST_CASE(TestNthToIndicesKernelRandom, NthToIndicesableTypes);
+TYPED_TEST_SUITE(TestNthToIndicesKernelRandom, NthToIndicesableTypes);
 
 TYPED_TEST(TestNthToIndicesKernelRandom, NthRandomValues) {
   Random<TypeParam> rand(0x61549225);

cpp/src/arrow/compute/kernels/sort_to_indices_test.cc

@@ -54,15 +54,15 @@ class TestSortToIndicesKernel : public ComputeFixture, public TestBase {
 
 template <typename ArrowType>
 class TestSortToIndicesKernelForReal : public TestSortToIndicesKernel<ArrowType> {};
-TYPED_TEST_CASE(TestSortToIndicesKernelForReal, RealArrowTypes);
+TYPED_TEST_SUITE(TestSortToIndicesKernelForReal, RealArrowTypes);
 
 template <typename ArrowType>
 class TestSortToIndicesKernelForIntegral : public TestSortToIndicesKernel<ArrowType> {};
-TYPED_TEST_CASE(TestSortToIndicesKernelForIntegral, IntegralArrowTypes);
+TYPED_TEST_SUITE(TestSortToIndicesKernelForIntegral, IntegralArrowTypes);
 
 template <typename ArrowType>
 class TestSortToIndicesKernelForStrings : public TestSortToIndicesKernel<ArrowType> {};
-TYPED_TEST_CASE(TestSortToIndicesKernelForStrings, testing::Types<StringType>);
+TYPED_TEST_SUITE(TestSortToIndicesKernelForStrings, testing::Types<StringType>);
 
 TYPED_TEST(TestSortToIndicesKernelForReal, SortReal) {
   this->AssertSortToIndices("[]", "[]");
@@ -104,11 +104,11 @@ TYPED_TEST(TestSortToIndicesKernelForStrings, SortStrings) {
 
 template <typename ArrowType>
 class TestSortToIndicesKernelForUInt8 : public TestSortToIndicesKernel<ArrowType> {};
-TYPED_TEST_CASE(TestSortToIndicesKernelForUInt8, UInt8Type);
+TYPED_TEST_SUITE(TestSortToIndicesKernelForUInt8, UInt8Type);
 
 template <typename ArrowType>
 class TestSortToIndicesKernelForInt8 : public TestSortToIndicesKernel<ArrowType> {};
-TYPED_TEST_CASE(TestSortToIndicesKernelForInt8, Int8Type);
+TYPED_TEST_SUITE(TestSortToIndicesKernelForInt8, Int8Type);
 
 TYPED_TEST(TestSortToIndicesKernelForUInt8, SortUInt8) {
   this->AssertSortToIndices("[255, null, 0, 255, 10, null, 128, 0]", "[2,7,4,6,0,3,1,5]");
@@ -217,7 +217,7 @@ class RandomRange : public RandomImpl {
   }
 };
 
-TYPED_TEST_CASE(TestSortToIndicesKernelRandom, SortToIndicesableTypes);
+TYPED_TEST_SUITE(TestSortToIndicesKernelRandom, SortToIndicesableTypes);
 
 TYPED_TEST(TestSortToIndicesKernelRandom, SortRandomValues) {
   using ArrayType = typename TypeTraits<TypeParam>::ArrayType;
@@ -239,7 +239,7 @@ TYPED_TEST(TestSortToIndicesKernelRandom, SortRandomValues) {
 // Long array with small value range: counting sort
 // - length >= 1024(CountCompareSorter::countsort_min_len_)
 // - range  <= 4096(CountCompareSorter::countsort_max_range_)
-TYPED_TEST_CASE(TestSortToIndicesKernelRandomCount, SortToIndicesIntegerTypes);
+TYPED_TEST_SUITE(TestSortToIndicesKernelRandomCount, SortToIndicesIntegerTypes);
 
 TYPED_TEST(TestSortToIndicesKernelRandomCount, SortRandomValuesCount) {
   using ArrayType = typename TypeTraits<TypeParam>::ArrayType;
@@ -260,7 +260,7 @@ TYPED_TEST(TestSortToIndicesKernelRandomCount, SortRandomValuesCount) {
 }
 
 // Long array with big value range: std::stable_sort
-TYPED_TEST_CASE(TestSortToIndicesKernelRandomCompare, SortToIndicesIntegerTypes);
+TYPED_TEST_SUITE(TestSortToIndicesKernelRandomCompare, SortToIndicesIntegerTypes);
 
 TYPED_TEST(TestSortToIndicesKernelRandomCompare, SortRandomValuesCompare) {
   using ArrayType = typename TypeTraits<TypeParam>::ArrayType;

cpp/src/arrow/compute/kernels/take_test.cc

@@ -150,7 +150,7 @@ class TestTakeKernelWithNumeric : public TestTakeKernel<ArrowType> {
   }
 };
 
-TYPED_TEST_CASE(TestTakeKernelWithNumeric, NumericArrowTypes);
+TYPED_TEST_SUITE(TestTakeKernelWithNumeric, NumericArrowTypes);
 TYPED_TEST(TestTakeKernelWithNumeric, TakeNumeric) {
   this->AssertTake("[7, 8, 9]", "[]", "[]");
   this->AssertTake("[7, 8, 9]", "[0, 1, 0]", "[7, 8, 7]");
@@ -212,7 +212,7 @@ class TestTakeKernelWithString : public TestTakeKernel<TypeClass> {
   }
 };
 
-TYPED_TEST_CASE(TestTakeKernelWithString, StringTypes);
+TYPED_TEST_SUITE(TestTakeKernelWithString, StringTypes);
 
 TYPED_TEST(TestTakeKernelWithString, TakeString) {
   this->AssertTake(R"(["a", "b", "c"])", "[0, 1, 0]", R"(["a", "b", "a"])");

cpp/src/arrow/csv/chunker_test.cc

@@ -75,9 +75,9 @@ class BaseChunkerTest : public ::testing::TestWithParam<bool> {
   std::unique_ptr<Chunker> chunker_;
 };
 
-INSTANTIATE_TEST_CASE_P(ChunkerTest, BaseChunkerTest, ::testing::Values(true));
+INSTANTIATE_TEST_SUITE_P(ChunkerTest, BaseChunkerTest, ::testing::Values(true));
 
-INSTANTIATE_TEST_CASE_P(NoNewlineChunkerTest, BaseChunkerTest, ::testing::Values(false));
+INSTANTIATE_TEST_SUITE_P(NoNewlineChunkerTest, BaseChunkerTest, ::testing::Values(false));
 
 TEST_P(BaseChunkerTest, Basics) {
   auto csv = MakeCSVData({"ab,c,\n", "def,,gh\n", ",ij,kl\n"});