Reimplement ReadFilesFromDirectory(std::string_view) using an overload.

Note: This implementation check-fails in case of errors like non-existent path
or files that cannot be read. This may break existing tests that were silently
ignoring such errors.

I included a number of smaller clean-ups (improving includes and dependencies).

PiperOrigin-RevId: 748298417

Author: fniksic

fuzztest/BUILD

@@ -76,15 +76,13 @@ cc_library(
         "fuzztest_macros.h",
     ],
     deps = [
-        ":io",
         ":logging",
         ":registration",
         ":registry",
-        "@abseil-cpp//absl/log:absl_check",
+        ":runtime",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
-        "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/strings:string_view",
     ],
 )

fuzztest/CMakeLists.txt

@@ -64,15 +64,13 @@ fuzztest_cc_library(
   SRCS
     "fuzztest_macros.cc"
   DEPS
-    fuzztest::io
     fuzztest::logging
     fuzztest::registration
     fuzztest::registry
-    absl::absl_check
+    fuzztest::runtime
     absl::status
     absl::statusor
     absl::strings
-    absl::str_format
     absl::string_view
 )
 

fuzztest/fuzztest_macros.cc

@@ -1,3 +1,17 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #include "./fuzztest/fuzztest_macros.h"
 
 #include <cerrno>
@@ -12,14 +26,14 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/absl_check.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
-#include "./fuzztest/internal/io.h"
 #include "./fuzztest/internal/logging.h"
+#include "./fuzztest/internal/runtime.h"
 
 namespace fuzztest {
 
@@ -67,26 +81,7 @@ absl::StatusOr<std::string> ParseDictionaryEntry(absl::string_view entry) {
 
 std::vector<std::tuple<std::string>> ReadFilesFromDirectory(
     std::string_view dir) {
-  std::vector<std::tuple<std::string>> out;
-  const std::filesystem::path fs_dir(dir);
-  if (!std::filesystem::is_directory(fs_dir)) return out;
-  for (const auto& entry :
-       std::filesystem::recursive_directory_iterator(fs_dir)) {
-    if (std::filesystem::is_directory(entry)) continue;
-    std::ifstream stream(entry.path());
-    if (!stream.good()) {
-      // Using stderr instead of GetStderr() to avoid
-      // initialization-order-fiasco when reading files at static init time with
-      // `.WithSeeds(fuzztest::ReadFilesFromDirectory(...))`.
-      absl::FPrintF(stderr, "[!] %s:%d: Error reading %s: (%d) %s\n", __FILE__,
-                    __LINE__, entry.path().string(), errno, strerror(errno));
-      continue;
-    }
-    std::stringstream buffer;
-    buffer << stream.rdbuf();
-    out.emplace_back(std::move(buffer).str());
-  }
-  return out;
+  return ReadFilesFromDirectory(dir, [](std::string_view) { return true; });
 }
 
 std::vector<std::tuple<std::string>> ReadFilesFromDirectory(
@@ -113,10 +108,11 @@ std::vector<std::tuple<std::string>> ReadFilesFromDirectory(
 }
 
 absl::StatusOr<std::vector<std::string>> ParseDictionary(
-    absl::string_view text) {
+    std::string_view text) {
   std::vector<std::string> parsed_entries;
   int line_number = 0;
-  for (absl::string_view line : absl::StrSplit(text, '\n')) {
+  for (absl::string_view line :
+       absl::StrSplit(absl::string_view{text.data(), text.size()}, '\n')) {
     ++line_number;
 
     if (line.empty() || line[0] == '#') continue;
@@ -154,17 +150,20 @@ std::vector<std::string> ReadDictionaryFromFile(
       "Not a file: ", dictionary_file);
   const std::filesystem::path fs_path(dictionary_file);
   std::ifstream stream(fs_path);
-  ABSL_CHECK(stream.good()) << "Error reading " << fs_path.string() << ": ("
-                            << errno << ") " << strerror(errno);
+  FUZZTEST_INTERNAL_CHECK_PRECONDITION(stream.good(), "Error reading ",
+                                       fs_path.string(), ": ", strerror(errno));
   std::stringstream buffer;
   buffer << stream.rdbuf();
-  // https://llvm.org/docs/LibFuzzer.html#dictionaries
   absl::StatusOr<std::vector<std::string>> parsed_entries =
       ParseDictionary(buffer.str());
-  ABSL_CHECK(parsed_entries.status().ok())
-      << "Could not parse dictionary file " << fs_path << ": "
-      << parsed_entries.status();
+  FUZZTEST_INTERNAL_CHECK_PRECONDITION(
+      parsed_entries.status().ok(), "Could not parse dictionary file ",
+      fs_path.string(), ": ", parsed_entries.status());
   return *parsed_entries;
 }
 
+void SkipTestsOrCurrentInput() {
+  internal::Runtime::instance().SetSkippingRequested(true);
+}
+
 }  // namespace fuzztest

fuzztest/fuzztest_macros.h

@@ -22,10 +22,8 @@
 #include <tuple>
 #include <vector>
 
-// IWYU pragma: begin_exports
 #include "absl/status/statusor.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
+// IWYU pragma: begin_exports
 #include "./fuzztest/internal/registration.h"
 #include "./fuzztest/internal/registry.h"
 // IWYU pragma: end_exports
@@ -126,8 +124,6 @@ namespace fuzztest {
 //   FUZZ_TEST(MySuite, MyThingNeverCrashes)
 //     .WithSeeds(ReadFilesFromDirectory(kCorpusPath));
 //
-// TODO(b/380934093): Rewrite this function as ReadFilesFromDirectory(dir,
-// [](std::string_view name) { return true; });
 std::vector<std::tuple<std::string>> ReadFilesFromDirectory(
     std::string_view dir);
 
@@ -150,12 +146,14 @@ std::vector<std::tuple<std::string>> ReadFilesFromDirectory(
 // Returns parsed dictionary entries from fuzzer dictionary definition in the
 // format specified at https://llvm.org/docs/LibFuzzer.html#dictionaries.
 // If dictionary is in wrong format, return error status.
-absl::StatusOr<std::vector<std::string>> ParseDictionary(
-    absl::string_view text);
+absl::StatusOr<std::vector<std::string>> ParseDictionary(std::string_view text);
 
 // Reads entries from `dictionary_file` and returns a vector usable by
 // .WithDictionary().
 //
+// The dictionary file should be in the format specified at
+// https://llvm.org/docs/LibFuzzer.html#dictionaries.
+//
 // Example:
 //
 //   void MyThingNeverCrashes(const std::string& s) {
@@ -181,9 +179,7 @@ inline std::vector<uint8_t> ToByteArray(std::string_view str) {
 // Note that this function should not be called frequently due to engine
 // limitation and efficiency reasons. Consider refining the domain definitions
 // to restrict input generation if possible.
-inline void SkipTestsOrCurrentInput() {
-  internal::Runtime::instance().SetSkippingRequested(true);
-}
+void SkipTestsOrCurrentInput();
 
 }  // namespace fuzztest