Add a "fuzz_test" property to FuzzTest tests.

PiperOrigin-RevId: 894156773

Author: fniksic

e2e_tests/functional_test.cc

@@ -62,6 +62,7 @@ using ::fuzztest::domain_implementor::PrintMode;
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::AnyOf;
+using ::testing::Contains;
 using ::testing::ContainsRegex;
 using ::testing::Eq;
 using ::testing::FieldsAre;
@@ -116,16 +117,11 @@ int CountTargetRuns(absl::string_view std_err) {
 
 class UnitTestModeTest : public ::testing::Test {
  protected:
-  RunResults Run(
+  RunResults RunWithExactFuzzerFlags(
       absl::string_view test_filter,
       absl::string_view target_binary = kDefaultTargetBinary,
       const absl::flat_hash_map<std::string, std::string>& env = {},
       absl::flat_hash_map<std::string, std::string> fuzzer_flags = {}) {
-    fuzzer_flags["print_subprocess_log"] = "true";
-    fuzzer_flags["unguided"] = "true";
-    if (!fuzzer_flags.contains("fuzz_for")) {
-      fuzzer_flags["fuzz_for"] = "10s";
-    }
     RunOptions run_options;
     run_options.flags = {
         {GTEST_FLAG_PREFIX_ "filter", std::string(test_filter)},
@@ -134,6 +130,20 @@ class UnitTestModeTest : public ::testing::Test {
     run_options.env = WithTestSanitizerOptions(env);
     return RunBinary(BinaryPath(target_binary), run_options);
   }
+
+  RunResults Run(
+      absl::string_view test_filter,
+      absl::string_view target_binary = kDefaultTargetBinary,
+      const absl::flat_hash_map<std::string, std::string>& env = {},
+      absl::flat_hash_map<std::string, std::string> fuzzer_flags = {}) {
+    fuzzer_flags["print_subprocess_log"] = "true";
+    fuzzer_flags["unguided"] = "true";
+    if (!fuzzer_flags.contains("fuzz_for")) {
+      fuzzer_flags["fuzz_for"] = "10s";
+    }
+    return RunWithExactFuzzerFlags(test_filter, target_binary, env,
+                                   std::move(fuzzer_flags));
+  }
 };
 
 TEST_F(UnitTestModeTest, PassingTestPassesInUnitTestingMode) {
@@ -668,6 +678,52 @@ TEST_F(UnitTestModeTest, InputsAreSkippedWhenRequestedInTests) {
   EXPECT_THAT_LOG(std_err, HasSubstr("Skipped input"));
 }
 
+// Identifies fuzz tests as those with test suite name "FuzzTest".
+MATCHER(IsXmlWithExactlyFuzzTestsHavingFuzzTestProperty, "") {
+  absl::string_view xml = arg;
+  absl::string_view attrs;
+  while (RE2::FindAndConsume(&xml, R"re((?s)<testcase\s(.*?)>)re", &attrs)) {
+    const bool is_fuzz_test =
+        RE2::PartialMatch(attrs, R"re(classname="FuzzTest")re");
+    if (!attrs.empty() && attrs.back() == '/') {
+      // Self-closing tag; no properties.
+      if (is_fuzz_test) {
+        *result_listener << "found a fuzz test without fuzz_test property";
+        return false;
+      }
+      continue;
+    }
+    bool has_fuzz_test_property = false;
+    absl::string_view body;
+    if (RE2::Consume(&xml, R"re((?s)(.*?)</testcase>)re", &body)) {
+      has_fuzz_test_property =
+          RE2::PartialMatch(body, R"re(<property name="fuzz_test")re");
+    }
+    if (is_fuzz_test != has_fuzz_test_property) {
+      *result_listener << "found a "
+                       << (is_fuzz_test ? "fuzz test " : "unit test ")
+                       << (has_fuzz_test_property ? "with " : "without ")
+                       << "fuzz_test property";
+      return false;
+    }
+  }
+  return true;
+}
+
+TEST_F(UnitTestModeTest, FuzzTestsRecordFuzzTestProperty) {
+  TempDir out_dir;
+  const std::string xml_output_file = out_dir.path() / "output.xml";
+  auto [status, std_out, std_err] =
+      RunWithExactFuzzerFlags("*", "testdata/unit_test_and_fuzz_tests",
+                              {{"XML_OUTPUT_FILE", xml_output_file}});
+
+  // Ensure that we've executed at least one unit test and one fuzz test.
+  EXPECT_THAT_LOG(std_out, AllOf(HasSubstr("UnitTest.AlwaysPasses"),
+                                 HasSubstr("FuzzTest.AlwaysPasses")));
+  EXPECT_THAT(ReadFile(xml_output_file),
+              Optional(IsXmlWithExactlyFuzzTestsHavingFuzzTestProperty()));
+}
+
 // Tests for the FuzzTest command line interface.
 class GenericCommandLineInterfaceTest : public ::testing::Test {
  protected:
@@ -1247,6 +1303,28 @@ TEST_F(FuzzingModeCommandLineInterfaceTest,
   EXPECT_THAT(status, Eq(ExitCode(0)));
 }
 
+TEST_F(FuzzingModeCommandLineInterfaceTest,
+       FuzzTestsRecordFuzzTestPropertyWhenRunningWithCentipede) {
+#ifndef FUZZTEST_USE_CENTIPEDE
+  GTEST_SKIP() << "Skipping Centipede-specific test";
+#endif
+  TempDir temp_dir;
+  const std::string xml_output_file = temp_dir.path() / "output.xml";
+  auto [status, std_out, std_err] = RunWith(
+      {
+          {"fuzz_for", "1s"},
+          {"corpus_database", temp_dir.path() / "corpus_database"},
+          {"internal_centipede_command", ShellEscape(CentipedePath())},
+      },
+      {{"XML_OUTPUT_FILE", xml_output_file}},
+      /*timeout=*/absl::Minutes(1), "testdata/unit_test_and_fuzz_tests");
+
+  // Ensure that we've executed at least one fuzz test.
+  EXPECT_THAT_LOG(std_out, HasSubstr("FuzzTest.AlwaysPasses"));
+  EXPECT_THAT(ReadFile(xml_output_file),
+              Optional(IsXmlWithExactlyFuzzTestsHavingFuzzTestProperty()));
+}
+
 TEST_F(FuzzingModeCommandLineInterfaceTest,
        FailsTestForSetupFailureWithoutCorpusDatabase) {
 #ifndef FUZZTEST_USE_CENTIPEDE

fuzztest/internal/googletest_adaptor.h

@@ -38,6 +38,7 @@ class GTest_TestAdaptor : public ::testing::Test {
         configuration_(std::move(configuration)) {}
 
   void TestBody() override {
+    RecordProperty("fuzz_test", "true");
     auto test = test_.make();
     configuration_.fuzz_tests_in_current_shard = GetFuzzTestsInCurrentShard();
     // We replay a reproducer in the same process to help debugging when