Update DEPS: update googletest (#581)

Pulls in googletest with INSTANTIATE_TEST_SUITE_P

10 files changed, 90 insertions, 95 deletions

diff --git a/src/amberscript/parser_attach_test.cc b/src/amberscript/parser_attach_test.cc
index 166be22..277366f 100644
--- a/src/amberscript/parser_attach_test.cc
+++ b/src/amberscript/parser_attach_test.cc
@@ -126,7 +126,7 @@ END)";
   ASSERT_FALSE(r.IsSuccess()) << r.Error();
   EXPECT_EQ("9: only compute shaders allowed in a compute pipeline", r.Error());
 }
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AmberScriptParserPipelineAttachTests,
     AmberScriptParserPipelineAttachTest,
     testing::Values(
@@ -137,7 +137,7 @@ INSTANTIATE_TEST_CASE_P(
                        kShaderTypeTessellationEvaluation},
         ShaderTypeData{
             "tessellation_control",
-            kShaderTypeTessellationControl}), );  // NOLINT(whitespace/parens)
+            kShaderTypeTessellationControl}));  // NOLINT(whitespace/parens)
 
 TEST_F(AmberScriptParserTest, PipelineEntryPoint) {
   std::string in = R"(
diff --git a/src/amberscript/parser_bind_test.cc b/src/amberscript/parser_bind_test.cc
index 5207c8d..7672294 100644
--- a/src/amberscript/parser_bind_test.cc
+++ b/src/amberscript/parser_bind_test.cc
@@ -1089,13 +1089,13 @@ PIPELINE graphics my_pipeline
   ASSERT_EQ(1U, bufs.size());
   EXPECT_EQ(test_data.type, bufs[0].buffer->GetBufferType());
 }
-INSTANTIATE_TEST_CASE_P(
-    AmberScriptParserBufferTypeTest,
+INSTANTIATE_TEST_SUITE_P(
+    AmberScriptParserBufferTypeTestSamples,
     AmberScriptParserBufferTypeTest,
     testing::Values(BufferTypeData{"uniform", BufferType::kUniform},
                     BufferTypeData{
                         "storage",
-                        BufferType::kStorage}), );  // NOLINT(whitespace/parens)
+                        BufferType::kStorage}));  // NOLINT(whitespace/parens)
 
 TEST_F(AmberScriptParserTest, BindPushConstants) {
   std::string in = R"(
diff --git a/src/amberscript/parser_buffer_test.cc b/src/amberscript/parser_buffer_test.cc
index cbc6abc..b74fe7f 100644
--- a/src/amberscript/parser_buffer_test.cc
+++ b/src/amberscript/parser_buffer_test.cc
@@ -417,7 +417,7 @@ TEST_P(AmberScriptParserBufferParseErrorTest, Test) {
   EXPECT_EQ(std::string(test_data.err), r.Error()) << test_data.in;
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AmberScriptParserBufferParseErrorTest,
     AmberScriptParserBufferParseErrorTest,
     testing::Values(
@@ -489,7 +489,7 @@ INSTANTIATE_TEST_CASE_P(
         BufferParseError{"BUFFER my_buf DATA_TYPE int32 SIZE 5 FILL 5\nBUFFER "
                          "my_buf DATA_TYPE int16 SIZE 5 FILL 2",
                          // NOLINTNEXTLINE(whitespace/parens)
-                         "2: duplicate buffer name provided"}), );
+                         "2: duplicate buffer name provided"}));
 
 struct BufferData {
   const char* name;
@@ -523,7 +523,7 @@ TEST_P(AmberScriptParserBufferDataTypeTest, BufferTypes) {
   EXPECT_EQ(test_data.type, fmt->GetComponents()[0].mode);
   EXPECT_EQ(test_data.num_bits, fmt->GetComponents()[0].num_bits);
 }
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AmberScriptParserTestsDataType,
     AmberScriptParserBufferDataTypeTest,
     testing::Values(BufferData{"int8", FormatMode::kSInt, 8, 1, 1},
@@ -543,7 +543,7 @@ INSTANTIATE_TEST_CASE_P(
                     BufferData{"mat3x3<float>", FormatMode::kSFloat, 32, 3, 3},
                     BufferData{"mat4x2<uint16>", FormatMode::kUInt, 16, 4, 2},
                     BufferData{"B8G8R8_UNORM", FormatMode::kUNorm, 8, 3,
-                               1}), );  // NOLINT(whitespace/parens)
+                               1}));  // NOLINT(whitespace/parens)
 
 struct NameData {
   const char* name;
@@ -562,8 +562,8 @@ TEST_P(AmberScriptParserBufferDataTypeInvalidTest, BufferTypes) {
   ASSERT_FALSE(r.IsSuccess()) << test_data.name;
   EXPECT_EQ("1: invalid data_type provided", r.Error()) << test_data.name;
 }
-INSTANTIATE_TEST_CASE_P(
-    AmberScriptParserBufferDataTypeInvalidTest,
+INSTANTIATE_TEST_SUITE_P(
+    AmberScriptParserBufferDataTypeInvalidTestSamples,
     AmberScriptParserBufferDataTypeInvalidTest,
     testing::Values(NameData{"int17"},
                     NameData{"uintt0"},
@@ -587,7 +587,7 @@ INSTANTIATE_TEST_CASE_P(
                     NameData{"mat2x2<mat3x3<double>>"},
                     NameData{"mat2x2<unit7>"},
                     NameData{"mat2x2"},
-                    NameData{"mat2x2<>"}), );  // NOLINT(whitespace/parens)
+                    NameData{"mat2x2<>"}));  // NOLINT(whitespace/parens)
 
 }  // namespace amberscript
 }  // namespace amber
diff --git a/src/amberscript/parser_clear_color_test.cc b/src/amberscript/parser_clear_color_test.cc
index 8798a3e..95d6e46 100644
--- a/src/amberscript/parser_clear_color_test.cc
+++ b/src/amberscript/parser_clear_color_test.cc
@@ -121,7 +121,7 @@ CLEAR_COLOR my_pipeline )" +
   EXPECT_EQ(std::string("13: ") + test_data.error, r.Error()) << test_data.data;
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AmberScriptParserClearColorTests,
     AmberScriptParserClearColorTest,
     testing::Values(
@@ -165,7 +165,7 @@ INSTANTIATE_TEST_CASE_P(
                            "invalid A value for CLEAR_COLOR command: 5.2"},
         ClearColorTestData{"255 255 255 256",
                            "invalid A value for CLEAR_COLOR "
-                           "command: 256"}), );  // NOLINT(whitespace/parens)
+                           "command: 256"}));  // NOLINT(whitespace/parens)
 
 }  // namespace amberscript
 }  // namespace amber
diff --git a/src/amberscript/parser_shader_test.cc b/src/amberscript/parser_shader_test.cc
index f9fd957..4858568 100644
--- a/src/amberscript/parser_shader_test.cc
+++ b/src/amberscript/parser_shader_test.cc
@@ -85,7 +85,7 @@ TEST_P(AmberScriptParserShaderPassThroughTest, ShaderPassThroughWithoutVertex) {
       "allowed",
       r.Error());
 }
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AmberScriptParserShaderPassThroughTests,
     AmberScriptParserShaderPassThroughTest,
     testing::Values(NameData{"fragment"},
@@ -93,7 +93,7 @@ INSTANTIATE_TEST_CASE_P(
                     NameData{"tessellation_evaluation"},
                     NameData{"tessellation_control"},
                     NameData{"compute"},
-                    NameData{"multi"}), );  // NOLINT(whitespace/parens)
+                    NameData{"multi"}));  // NOLINT(whitespace/parens)
 
 TEST_F(AmberScriptParserTest, ShaderPassThroughUnknownShaderType) {
   std::string in = "SHADER UNKNOWN my_shader PASSTHROUGH";
@@ -269,7 +269,7 @@ void main() {
   EXPECT_EQ(kShaderFormatGlsl, shader->GetFormat());
   EXPECT_EQ(shader_result, shader->GetData());
 }
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AmberScriptParserTestsShaderType,
     AmberScriptParserShaderTypeTest,
     testing::Values(
@@ -281,7 +281,7 @@ INSTANTIATE_TEST_CASE_P(
         ShaderTypeData{"tessellation_control", kShaderTypeTessellationControl},
         ShaderTypeData{"compute", kShaderTypeCompute},
         ShaderTypeData{"multi",
-                       kShaderTypeMulti}), );  // NOLINT(whitespace/parens)
+                       kShaderTypeMulti}));  // NOLINT(whitespace/parens)
 
 struct ShaderFormatData {
   const char* name;
@@ -315,15 +315,14 @@ TEST_P(AmberScriptParserShaderFormatTest, ShaderFormats) {
   EXPECT_EQ(test_data.format, shader->GetFormat());
   EXPECT_EQ(shader_result, shader->GetData());
 }
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AmberScriptParserTestsShaderFormat,
     AmberScriptParserShaderFormatTest,
-    testing::Values(
-        ShaderFormatData{"GLSL", kShaderFormatGlsl},
-        ShaderFormatData{"SPIRV-ASM", kShaderFormatSpirvAsm},
-        ShaderFormatData{
-            "SPIRV-HEX",
-            kShaderFormatSpirvHex}), );  // NOLINT(whitespace/parens)
+    testing::Values(ShaderFormatData{"GLSL", kShaderFormatGlsl},
+                    ShaderFormatData{"SPIRV-ASM", kShaderFormatSpirvAsm},
+                    ShaderFormatData{
+                        "SPIRV-HEX",
+                        kShaderFormatSpirvHex}));  // NOLINT(whitespace/parens)
 
 TEST_F(AmberScriptParserTest, DuplicateShaderName) {
   std::string in = R"(
diff --git a/src/datum_type_test.cc b/src/datum_type_test.cc
index bf1924e..03d411c 100644
--- a/src/datum_type_test.cc
+++ b/src/datum_type_test.cc
@@ -36,8 +36,8 @@ TEST_P(DatumTypeTestFormat, ToFormat) {
   auto fmt = dt.AsFormat();
   EXPECT_EQ(test_data.format_type, fmt->GetFormatType());
 }
-INSTANTIATE_TEST_CASE_P(
-    DatumTypeTestFormat,
+INSTANTIATE_TEST_SUITE_P(
+    DatumTypeTestFormatSamples,
     DatumTypeTestFormat,
     testing::Values(
         Data{DataType::kInt8, 1, FormatType::kR8_SINT},
@@ -82,8 +82,7 @@ INSTANTIATE_TEST_CASE_P(
         Data{DataType::kDouble, 1, FormatType::kR64_SFLOAT},
         Data{DataType::kDouble, 2, FormatType::kR64G64_SFLOAT},
         Data{DataType::kDouble, 3, FormatType::kR64G64B64_SFLOAT},
-        Data{
-            DataType::kDouble, 4,
-            FormatType::kR64G64B64A64_SFLOAT}), );  // NOLINT(whitespace/parens)
+        Data{DataType::kDouble, 4,
+             FormatType::kR64G64B64A64_SFLOAT}));  // NOLINT(whitespace/parens)
 
 }  // namespace amber
diff --git a/src/format_test.cc b/src/format_test.cc
index ccebf0b..655f3c3 100644
--- a/src/format_test.cc
+++ b/src/format_test.cc
@@ -121,8 +121,8 @@ TEST_P(FormatStdTest, Test) {
       << test_data.name;
 }
 
-INSTANTIATE_TEST_CASE_P(
-    FormatStdTest,
+INSTANTIATE_TEST_SUITE_P(
+    FormatStdTestSamples,
     FormatStdTest,
     testing::Values(
         StdData{"mat2x2-std140", "R32G32_SFLOAT", 2, true, 8U, 16U, 32U},
@@ -147,6 +147,6 @@ INSTANTIATE_TEST_CASE_P(
                 64U},
         StdData{"float-std140", "R32_SFLOAT", 1, true, 1U, 4U, 4U},
         StdData{"float-std430", "R32_SFLOAT", 1, false, 1U, 4U,
-                4U}), );  // NOLINT(whitespace/parens)
+                4U}));  // NOLINT(whitespace/parens)
 
 }  // namespace amber
diff --git a/src/pipeline_test.cc b/src/pipeline_test.cc
index e7459e2..8c61a0b 100644
--- a/src/pipeline_test.cc
+++ b/src/pipeline_test.cc
@@ -106,7 +106,7 @@ TEST_P(AmberScriptPipelineComputePipelineTest,
   ASSERT_FALSE(r.IsSuccess());
   EXPECT_EQ("only compute shaders allowed in a compute pipeline", r.Error());
 }
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AmberScriptPipelineComputePipelineTests,
     AmberScriptPipelineComputePipelineTest,
     testing::Values(
@@ -115,7 +115,7 @@ INSTANTIATE_TEST_CASE_P(
         ShaderTypeData{kShaderTypeGeometry},
         ShaderTypeData{kShaderTypeTessellationEvaluation},
         ShaderTypeData{
-            kShaderTypeTessellationControl}), );  // NOLINT(whitespace/parens)
+            kShaderTypeTessellationControl}));  // NOLINT(whitespace/parens)
 
 TEST_F(PipelineTest, SettingComputeShaderToGraphicsPipeline) {
   Shader c(kShaderTypeCompute);
diff --git a/src/vkscript/command_parser_test.cc b/src/vkscript/command_parser_test.cc
index 560d98a..1efba07 100644
--- a/src/vkscript/command_parser_test.cc
+++ b/src/vkscript/command_parser_test.cc
@@ -980,10 +980,10 @@ TEST_P(CommandParserProbeTest, ProbeNotRect) {
   EXPECT_FLOAT_EQ(4.0f, cmd->GetA());
 }
 
-INSTANTIATE_TEST_CASE_P(ProbeTests,
-                        CommandParserProbeTest,
-                        testing::Values(false,
-                                        true), );  // NOLINT(whitespace/parens)
+INSTANTIATE_TEST_SUITE_P(ProbeTests,
+                         CommandParserProbeTest,
+                         testing::Values(false,
+                                         true));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, ProbeAllRGB) {
   std::string data = "probe all rgb 0.2 0.3 0.4";
@@ -1386,7 +1386,7 @@ TEST_P(CommandDataPipelineTopologyParser, Topology) {
   EXPECT_EQ(test_data.value, cp.PipelineDataForTesting()->GetTopology());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     TopologyTests,
     CommandDataPipelineTopologyParser,
     testing::Values(
@@ -1413,7 +1413,7 @@ INSTANTIATE_TEST_CASE_P(
         TopologyTestData{
             "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY",
             Topology::
-                kTriangleStripWithAdjacency}), );  // NOLINT(whitespace/parens)
+                kTriangleStripWithAdjacency}));  // NOLINT(whitespace/parens)
 
 struct PipelineDataInvalidTest {
   const char* name;
@@ -1486,7 +1486,7 @@ TEST_P(CommandDataPipelineDataInvalidParser, ExtraPipelineParamValue) {
             r.Error());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PipelineDataInvalidTests,
     CommandDataPipelineDataInvalidParser,
     testing::Values(
@@ -1495,7 +1495,7 @@ INSTANTIATE_TEST_CASE_P(
         PipelineDataInvalidTest{"cullMode", "VK_CULL_MODE_BACK_BIT"},
         PipelineDataInvalidTest{"frontFace", "VK_FRONT_FACE_COUNTER_CLOCKWISE"},
         PipelineDataInvalidTest{
-            "logicOp", "VK_LOGIC_OP_NO_OP"}), );  // NOLINT(whitespace/parens)
+            "logicOp", "VK_LOGIC_OP_NO_OP"}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, BooleanTrue) {
   struct {
@@ -1819,7 +1819,7 @@ TEST_P(CommandParserBooleanTests, ExtraParam) {
             r.Error());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     BooleanTests,
     CommandParserBooleanTests,
     testing::Values(BooleanTest{"primitiveRestartEnable"},
@@ -1832,7 +1832,7 @@ INSTANTIATE_TEST_CASE_P(
                     BooleanTest{"depthWriteEnable"},
                     BooleanTest{"depthBoundsTestEnable"},
                     BooleanTest{
-                        "stencilTestEnable"}), );  // NOLINT(whitespace/parens)
+                        "stencilTestEnable"}));  // NOLINT(whitespace/parens)
 
 struct PolygonModeTestData {
   const char* name;
@@ -1854,7 +1854,7 @@ TEST_P(CommandDataPipelinePolygonModeParser, PolygonMode) {
   EXPECT_EQ(test_data.value, cp.PipelineDataForTesting()->GetPolygonMode());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PolygonModeTests,
     CommandDataPipelinePolygonModeParser,
     testing::Values(
@@ -1862,7 +1862,7 @@ INSTANTIATE_TEST_CASE_P(
         PolygonModeTestData{"VK_POLYGON_MODE_LINE", PolygonMode::kLine},
         PolygonModeTestData{
             "VK_POLYGON_MODE_POINT",
-            PolygonMode::kPoint}), );  // NOLINT(whitespace/parens)
+            PolygonMode::kPoint}));  // NOLINT(whitespace/parens)
 
 struct CullModeTestData {
   const char* name;
@@ -1884,7 +1884,7 @@ TEST_P(CommandDataPipelineCullModeParser, CullMode) {
   EXPECT_EQ(test_data.value, cp.PipelineDataForTesting()->GetCullMode());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     CullModeTests,
     CommandDataPipelineCullModeParser,
     testing::Values(
@@ -1897,7 +1897,7 @@ INSTANTIATE_TEST_CASE_P(
                          CullMode::kFrontAndBack},
         CullModeTestData{
             "VK_CULL_MODE_FRONT_AND_BACK",
-            CullMode::kFrontAndBack}), );  // NOLINT(whitespace/parens)
+            CullMode::kFrontAndBack}));  // NOLINT(whitespace/parens)
 
 struct FrontFaceTestData {
   const char* name;
@@ -1919,15 +1919,14 @@ TEST_P(CommandDataPipelineFrontFaceParser, FrontFace) {
   EXPECT_EQ(test_data.value, cp.PipelineDataForTesting()->GetFrontFace());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     FrontFaceTests,
     CommandDataPipelineFrontFaceParser,
-    testing::Values(
-        FrontFaceTestData{"VK_FRONT_FACE_COUNTER_CLOCKWISE",
-                          FrontFace::kCounterClockwise},
-        FrontFaceTestData{
-            "VK_FRONT_FACE_CLOCKWISE",
-            FrontFace::kClockwise}), );  // NOLINT(whitespace/parens)
+    testing::Values(FrontFaceTestData{"VK_FRONT_FACE_COUNTER_CLOCKWISE",
+                                      FrontFace::kCounterClockwise},
+                    FrontFaceTestData{
+                        "VK_FRONT_FACE_CLOCKWISE",
+                        FrontFace::kClockwise}));  // NOLINT(whitespace/parens)
 
 struct LogicOpTestData {
   const char* name;
@@ -1949,7 +1948,7 @@ TEST_P(CommandDataPipelineLogicOpParser, LogicOp) {
   EXPECT_EQ(test_data.value, cp.PipelineDataForTesting()->GetLogicOp());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     LogicOpTests,
     CommandDataPipelineLogicOpParser,
     testing::Values(
@@ -1969,7 +1968,7 @@ INSTANTIATE_TEST_CASE_P(
         LogicOpTestData{"VK_LOGIC_OP_OR_INVERTED", LogicOp::kOrInverted},
         LogicOpTestData{"VK_LOGIC_OP_NAND", LogicOp::kNand},
         LogicOpTestData{"VK_LOGIC_OP_SET",
-                        LogicOp::kSet}), );  // NOLINT(whitespace/parens)
+                        LogicOp::kSet}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, DepthBiasConstantFactor) {
   std::string data = "depthBiasConstantFactor 3.4";
@@ -2085,7 +2084,7 @@ TEST_P(CommandParserFloatTests, ExtraParam) {
             r.Error());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     FloatTests,
     CommandParserFloatTests,
     testing::Values(FloatTest{"depthBiasConstantFactor"},
@@ -2093,8 +2092,7 @@ INSTANTIATE_TEST_CASE_P(
                     FloatTest{"depthBiasClamp"},
                     FloatTest{"depthBiasSlopeFactor"},
                     FloatTest{"minDepthBounds"},
-                    FloatTest{
-                        "maxDepthBounds"}), );  // NOLINT(whitespace/parens)
+                    FloatTest{"maxDepthBounds"}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, SrcColorBlendFactor) {
   std::string data = "srcColorBlendFactor VK_BLEND_FACTOR_DST_COLOR";
@@ -2162,7 +2160,7 @@ TEST_P(CommandParserBlendFactorParsing, Parse) {
   EXPECT_EQ(test_data.type, factor);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     BlendFactorParsingTests,
     CommandParserBlendFactorParsing,
     testing::Values(
@@ -2196,7 +2194,7 @@ INSTANTIATE_TEST_CASE_P(
         BlendFactorData{"VK_BLEND_FACTOR_SRC1_ALPHA", BlendFactor::kSrc1Alpha},
         BlendFactorData{
             "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA",
-            BlendFactor::kOneMinusSrc1Alpha}), );  // NOLINT(whitespace/parens)
+            BlendFactor::kOneMinusSrc1Alpha}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, BlendFactorParsingInvalid) {
   Pipeline pipeline(PipelineType::kGraphics);
@@ -2258,15 +2256,14 @@ TEST_P(CommandParserBlendFactorTests, ExtraParam) {
             r.Error());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     BlendFactorTests,
     CommandParserBlendFactorTests,
-    testing::Values(
-        BlendFactorTest{"srcColorBlendFactor"},
-        BlendFactorTest{"dstColorBlendFactor"},
-        BlendFactorTest{"srcAlphaBlendFactor"},
-        BlendFactorTest{
-            "dstAlphaBlendFactor"}), );  // NOLINT(whitespace/parens)
+    testing::Values(BlendFactorTest{"srcColorBlendFactor"},
+                    BlendFactorTest{"dstColorBlendFactor"},
+                    BlendFactorTest{"srcAlphaBlendFactor"},
+                    BlendFactorTest{
+                        "dstAlphaBlendFactor"}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, ColorBlendOp) {
   std::string data = "colorBlendOp VK_BLEND_OP_XOR_EXT";
@@ -2308,7 +2305,7 @@ TEST_P(CommandParserBlendOpParsing, Parse) {
   EXPECT_EQ(test_data.type, op);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     BlendOpParsingTests1,
     CommandParserBlendOpParsing,
     testing::Values(
@@ -2341,9 +2338,9 @@ INSTANTIATE_TEST_CASE_P(
         BlendOpData{"VK_BLEND_OP_DIFFERENCE_EXT", BlendOp::kDifference},
         BlendOpData{"VK_BLEND_OP_EXCLUSION_EXT", BlendOp::kExclusion},
         BlendOpData{"VK_BLEND_OP_INVERT_EXT",
-                    BlendOp::kInvert}), );  // NOLINT(whitespace/parens)
+                    BlendOp::kInvert}));  // NOLINT(whitespace/parens)
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     BlendOpParsingTests2,
     CommandParserBlendOpParsing,
     testing::Values(
@@ -2370,7 +2367,7 @@ INSTANTIATE_TEST_CASE_P(
         BlendOpData{"VK_BLEND_OP_RED_EXT", BlendOp::kRed},
         BlendOpData{"VK_BLEND_OP_GREEN_EXT", BlendOp::kGreen},
         BlendOpData{"VK_BLEND_OP_BLUE_EXT",
-                    BlendOp::kBlue}), );  // NOLINT(whitespace/parens)
+                    BlendOp::kBlue}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, BlendOpParsingInvalid) {
   Pipeline pipeline(PipelineType::kGraphics);
@@ -2432,12 +2429,11 @@ TEST_P(CommandParserBlendOpTests, ExtraParam) {
             r.Error());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     BlendOpTests,
     CommandParserBlendOpTests,
     testing::Values(BlendOpTest{"colorBlendOp"},
-                    BlendOpTest{
-                        "alphaBlendOp"}), );  // NOLINT(whitespace/parens)
+                    BlendOpTest{"alphaBlendOp"}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, DepthCompareOp) {
   std::string data = "depthCompareOp VK_COMPARE_OP_EQUAL";
@@ -2492,7 +2488,7 @@ TEST_P(CommandParserCompareOpParsing, Parse) {
   EXPECT_EQ(test_data.type, op);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     CompareOpParsingTests,
     CommandParserCompareOpParsing,
     testing::Values(
@@ -2505,7 +2501,7 @@ INSTANTIATE_TEST_CASE_P(
         CompareOpData{"VK_COMPARE_OP_GREATER_OR_EQUAL",
                       CompareOp::kGreaterOrEqual},
         CompareOpData{"VK_COMPARE_OP_ALWAYS",
-                      CompareOp::kAlways}), );  // NOLINT(whitespace/parens)
+                      CompareOp::kAlways}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, CompareOpParsingInvalid) {
   Pipeline pipeline(PipelineType::kGraphics);
@@ -2568,13 +2564,13 @@ TEST_P(CommandParserCompareOpTests, ExtraParam) {
             r.Error());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     CompareOpTests,
     CommandParserCompareOpTests,
     testing::Values(CompareOpTest{"depthCompareOp"},
                     CompareOpTest{"front.compareOp"},
                     CompareOpTest{
-                        "back.compareOp"}), );  // NOLINT(whitespace/parens)
+                        "back.compareOp"}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, FrontFailOp) {
   std::string data = "front.failOp VK_STENCIL_OP_REPLACE";
@@ -2662,7 +2658,7 @@ TEST_P(CommandParserStencilOpParsing, Parse) {
   EXPECT_EQ(test_data.type, op);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     CompareOpParsingTests,
     CommandParserStencilOpParsing,
     testing::Values(
@@ -2678,7 +2674,7 @@ INSTANTIATE_TEST_CASE_P(
                       StencilOp::kIncrementAndWrap},
         StencilOpData{
             "VK_STENCIL_OP_DECREMENT_AND_WRAP",
-            StencilOp::kDecrementAndWrap}), );  // NOLINT(whitespace/parens)
+            StencilOp::kDecrementAndWrap}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, StencilOpParsingInvalid) {
   Pipeline pipeline(PipelineType::kGraphics);
@@ -2741,7 +2737,7 @@ TEST_P(CommandParserStencilOpTests, ExtraParam) {
             r.Error());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     StencilOpTests,
     CommandParserStencilOpTests,
     testing::Values(StencilOpTest{"front.passOp"},
@@ -2750,7 +2746,7 @@ INSTANTIATE_TEST_CASE_P(
                     StencilOpTest{"back.passOp"},
                     StencilOpTest{"back.failOp"},
                     StencilOpTest{
-                        "back.depthFailOp"}), );  // NOLINT(whitespace/parens)
+                        "back.depthFailOp"}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, FrontCompareMask) {
   std::string data = "front.compareMask 123";
@@ -2866,12 +2862,12 @@ TEST_P(CommandParserReferenceTests, FrontReferenceInvalidParameters) {
             r.Error());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     ReferenceTest,
     CommandParserReferenceTests,
     testing::Values(ReferenceData{"front.reference"},
                     ReferenceData{
-                        "back.reference"}), );  // NOLINT(whitespace/parens)
+                        "back.reference"}));  // NOLINT(whitespace/parens)
 
 struct ColorMaskData {
   const char* input;
@@ -2891,7 +2887,7 @@ TEST_P(CommandParserColorMaskTests, ColorWriteMask) {
   EXPECT_EQ(test_data.result, cp.PipelineDataForTesting()->GetColorWriteMask());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     ColorMaskTests,
     CommandParserColorMaskTests,
     testing::Values(
@@ -2905,7 +2901,7 @@ INSTANTIATE_TEST_CASE_P(
         ColorMaskData{"VK_COLOR_COMPONENT_A_BIT | VK_COLOR_COMPONENT_B_BIT | "
                       "VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT",
                       kColorMaskR | kColorMaskG | kColorMaskB |
-                          kColorMaskA}), );  // NOLINT(whitespace/parens)
+                          kColorMaskA}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, ColorWriteMaskInvalid) {
   std::string data = "colorWriteMask INVALID";
@@ -4196,7 +4192,7 @@ TEST_P(CommandParserComparatorTests, Comparator) {
   EXPECT_EQ(test_data.op, result);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     ComparatorTests,
     CommandParserComparatorTests,
     testing::Values(
@@ -4208,7 +4204,7 @@ INSTANTIATE_TEST_CASE_P(
         ComparatorTest{">", ProbeSSBOCommand::Comparator::kGreater},
         ComparatorTest{">=",
                        ProbeSSBOCommand::Comparator::
-                           kGreaterOrEqual}), );  // NOLINT(whitespace/parens)
+                           kGreaterOrEqual}));  // NOLINT(whitespace/parens)
 
 TEST_F(CommandParserTest, ComparatorInvalid) {
   Pipeline pipeline(PipelineType::kGraphics);
diff --git a/src/vkscript/datum_type_parser_test.cc b/src/vkscript/datum_type_parser_test.cc
index 66a98c6..8a5c052 100644
--- a/src/vkscript/datum_type_parser_test.cc
+++ b/src/vkscript/datum_type_parser_test.cc
@@ -41,6 +41,7 @@ struct DatumTypeData {
   uint32_t column_count;
   uint32_t row_count;
 };
+
 using DatumTypeDataTest = testing::TestWithParam<DatumTypeData>;
 
 TEST_P(DatumTypeDataTest, Parser) {
@@ -55,7 +56,7 @@ TEST_P(DatumTypeDataTest, Parser) {
   EXPECT_EQ(test_data.row_count, t.RowCount());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     DatumTypeParserTest1,
     DatumTypeDataTest,
     testing::Values(DatumTypeData{"int", DataType::kInt32, 1, 1},
@@ -87,9 +88,9 @@ INSTANTIATE_TEST_CASE_P(
                     DatumTypeData{"u8vec3", DataType::kUint8, 1, 3},
                     DatumTypeData{"u8vec4", DataType::kUint8, 1, 4},
                     DatumTypeData{"i16vec2", DataType::kInt16, 1,
-                                  2}), );  // NOLINT(whitespace/parens)
+                                  2}));  // NOLINT(whitespace/parens)
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     DatumTypeParserTest2,
     DatumTypeDataTest,
     testing::Values(DatumTypeData{"i16vec3", DataType::kInt16, 1, 3},
@@ -127,7 +128,7 @@ INSTANTIATE_TEST_CASE_P(
                     DatumTypeData{"dmat4x2", DataType::kDouble, 4, 2},
                     DatumTypeData{"dmat4x3", DataType::kDouble, 4, 3},
                     DatumTypeData{"dmat4x4", DataType::kDouble, 4,
-                                  4}), );  // NOLINT(whitespace/parens)
+                                  4}));  // NOLINT(whitespace/parens)
 
 }  // namespace vkscript
 }  // namespace amber