diff --git a/centipede/BUILD b/centipede/BUILD index 636603635..ef5c27043 100644 --- a/centipede/BUILD +++ b/centipede/BUILD @@ -63,8 +63,7 @@ cc_binary( ":util", "@abseil-cpp//absl/base:nullability", "@abseil-cpp//absl/flags:flag", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", ], ) @@ -77,8 +76,6 @@ cc_binary( ":rusage_profiler", "@abseil-cpp//absl/base:nullability", "@abseil-cpp//absl/flags:flag", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/time", @@ -132,8 +129,6 @@ cc_library( ":thread_pool", ":util", "@abseil-cpp//absl/container:node_hash_set", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/types:span", "@com_google_fuzztest//common:logging", @@ -168,9 +163,9 @@ cc_library( hdrs = ["pc_info.h"], visibility = PUBLIC_API_VISIBILITY, deps = [ - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/types:span", "@com_google_fuzztest//common:defs", + "@com_google_fuzztest//common:logging", ], ) @@ -211,7 +206,6 @@ cc_library( ":feature", "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/base:nullability", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/synchronization", @@ -264,8 +258,6 @@ cc_library( "@abseil-cpp//absl/flags:flag", "@abseil-cpp//absl/flags:parse", "@abseil-cpp//absl/flags:reflection", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", @@ -290,10 +282,10 @@ cc_library( visibility = ["//visibility:public"], deps = [ "@abseil-cpp//absl/base:nullability", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", ], ) @@ -307,12 +299,11 @@ cc_library( ":rusage_stats", "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/base:nullability", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/synchronization", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", ], ) @@ -323,12 +314,11 @@ cc_library( deps = [ ":rusage_stats", "@abseil-cpp//absl/base:core_headers", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/synchronization", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", ], ) @@ -360,8 +350,6 @@ cc_library( "@abseil-cpp//absl/base:nullability", "@abseil-cpp//absl/container:btree", "@abseil-cpp//absl/container:flat_hash_map", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/time", @@ -385,8 +373,6 @@ cc_library( ":util", ":workdir", "@abseil-cpp//absl/base:core_headers", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/synchronization", "@com_google_fuzztest//common:defs", "@com_google_fuzztest//common:hash", @@ -410,8 +396,6 @@ cc_library( ":workdir", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@com_google_fuzztest//common:defs", "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", @@ -519,9 +503,9 @@ cc_library( ":symbol_table", "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/synchronization", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", "@com_google_fuzztest//common:status_macros", ], @@ -544,8 +528,6 @@ cc_library( ":util", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@com_google_fuzztest//common:defs", "@com_google_fuzztest//common:logging", @@ -569,7 +551,6 @@ cc_library( ":pc_info", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log:check", "@com_google_fuzztest//common:logging", ], ) @@ -582,8 +563,6 @@ cc_library( ":control_flow", ":feature", ":util", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@com_google_fuzztest//common:logging", ], @@ -602,8 +581,6 @@ cc_library( ":feature", ":feature_set", ":util", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@com_google_fuzztest//common:defs", "@com_google_fuzztest//common:logging", @@ -621,8 +598,6 @@ cc_library( ":stop", ":util", "@abseil-cpp//absl/base:core_headers", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", @@ -647,9 +622,8 @@ cc_library( ":pc_info", ":symbol_table", ":util", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", ], ) @@ -677,8 +651,6 @@ cc_library( ":util", ":workdir", "@abseil-cpp//absl/base:nullability", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", @@ -697,8 +669,6 @@ cc_library( ":feature", ":rusage_profiler", ":util", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/time", "@abseil-cpp//absl/types:span", @@ -737,8 +707,6 @@ cc_library( ":centipede_flags", ":environment", "@abseil-cpp//absl/flags:flag", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", "@com_google_fuzztest//common:logging", @@ -783,8 +751,6 @@ cc_library( "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/base:nullability", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", @@ -830,8 +796,6 @@ cc_library( "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/cleanup", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", @@ -870,8 +834,6 @@ cc_library( "@abseil-cpp//absl/base:no_destructor", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/flags:marshalling", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", "@com_google_fuzztest//common:defs", @@ -900,8 +862,6 @@ cc_library( ":workdir", "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/synchronization", "@abseil-cpp//absl/time", @@ -925,8 +885,6 @@ cc_library( ":mutation_input", ":runner_result", ":stop", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@com_google_fuzztest//common:defs", @@ -1151,8 +1109,6 @@ cc_library( ":util", ":workdir", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/random", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", @@ -1176,7 +1132,6 @@ cc_library( ":seed_corpus_config_cc_proto", ":seed_corpus_maker_lib", ":workdir", - "@abseil-cpp//absl/log", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", @@ -1206,8 +1161,6 @@ cc_library( visibility = PUBLIC_API_VISIBILITY, deps = [ ":environment", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@com_google_fuzztest//common:logging", @@ -1227,7 +1180,6 @@ cc_library( ":mutation_input", ":runner_result", ":util", - "@abseil-cpp//absl/log:check", "@com_google_fuzztest//common:defs", ], ) @@ -1264,8 +1216,8 @@ cc_test( srcs = ["environment_test.cc"], deps = [ ":environment", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:configuration", "@googletest//:gtest_main", ], @@ -1318,9 +1270,9 @@ cc_test( ":thread_pool", ":util", "@abseil-cpp//absl/container:flat_hash_map", - "@abseil-cpp//absl/log", "@com_google_fuzztest//common:defs", "@com_google_fuzztest//common:hash", + "@com_google_fuzztest//common:logging", "@googletest//:gtest_main", ], ) @@ -1360,7 +1312,6 @@ cc_test( ":thread_pool", "@abseil-cpp//absl/base:nullability", "@abseil-cpp//absl/flags:flag", - "@abseil-cpp//absl/log", "@abseil-cpp//absl/synchronization", "@abseil-cpp//absl/time", "@com_google_fuzztest//common:logging", @@ -1379,9 +1330,9 @@ cc_test( ":util", ":workdir", "@abseil-cpp//absl/flags:reflection", - "@abseil-cpp//absl/log:check", "@com_google_fuzztest//common:blob_file", "@com_google_fuzztest//common:defs", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:test_util", "@googletest//:gtest_main", ], @@ -1397,8 +1348,8 @@ cc_test( ":rusage_profiler", ":rusage_stats", "@abseil-cpp//absl/flags:flag", - "@abseil-cpp//absl/log", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", "@googletest//:gtest_main", ], ) @@ -1410,7 +1361,6 @@ cc_test( ":environment", ":stats", ":util", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/log:log_entry", "@abseil-cpp//absl/log:log_sink", "@abseil-cpp//absl/log:log_sink_registry", @@ -1453,8 +1403,7 @@ cc_test( ":environment", ":symbol_table", ":test_coverage_util", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", "@com_google_fuzztest//common:test_util", "@googletest//:gtest_main", @@ -1606,10 +1555,10 @@ cc_test( ":feature", ":util", ":workdir", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/types:span", "@com_google_fuzztest//common:blob_file", "@com_google_fuzztest//common:defs", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:test_util", "@googletest//:gtest_main", ], @@ -1650,9 +1599,9 @@ cc_test( ":command", ":stop", ":util", - "@abseil-cpp//absl/log", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:test_util", "@googletest//:gtest_main", ], @@ -1683,8 +1632,6 @@ cc_test( ":symbol_table", ":thread_pool", "@abseil-cpp//absl/container:flat_hash_map", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:test_util", "@googletest//:gtest_main", @@ -1720,7 +1667,6 @@ cc_test( ":feature", ":seed_corpus_maker_lib", ":workdir", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@com_google_fuzztest//common:defs", "@com_google_fuzztest//common:logging", @@ -1778,7 +1724,6 @@ cc_test( ":resource_pool", ":rusage_stats", ":thread_pool", - "@abseil-cpp//absl/log", "@abseil-cpp//absl/status", "@abseil-cpp//absl/time", "@com_google_fuzztest//common:logging", @@ -1871,8 +1816,6 @@ cc_test( ":workdir", "@abseil-cpp//absl/base:nullability", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", "@com_google_fuzztest//common:defs", diff --git a/centipede/analyze_corpora.cc b/centipede/analyze_corpora.cc index 56e75c7ab..0216d8339 100644 --- a/centipede/analyze_corpora.cc +++ b/centipede/analyze_corpora.cc @@ -24,8 +24,6 @@ #include "absl/container/flat_hash_map.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "./centipede/binary_info.h" #include "./centipede/control_flow.h" #include "./centipede/corpus.h" @@ -48,17 +46,17 @@ std::vector ReadCorpora(std::string_view binary_name, WorkDir workdir(std::string(workdir_path), std::string(binary_name), std::string(binary_hash), /*my_shard_index=*/0); std::vector corpus_paths; - CHECK_OK( + FUZZTEST_CHECK_OK( RemoteGlobMatch(workdir.CorpusFilePaths().AllShardsGlob(), corpus_paths)); std::vector features_paths; - CHECK_OK(RemoteGlobMatch(workdir.FeaturesFilePaths().AllShardsGlob(), - features_paths)); + FUZZTEST_CHECK_OK(RemoteGlobMatch(workdir.FeaturesFilePaths().AllShardsGlob(), + features_paths)); - CHECK_EQ(corpus_paths.size(), features_paths.size()); + FUZZTEST_CHECK_EQ(corpus_paths.size(), features_paths.size()); std::vector corpus; for (int i = 0; i < corpus_paths.size(); ++i) { - LOG(INFO) << "Reading corpus at: " << corpus_paths[i]; - LOG(INFO) << "Reading features at: " << features_paths[i]; + FUZZTEST_LOG(INFO) << "Reading corpus at: " << corpus_paths[i]; + FUZZTEST_LOG(INFO) << "Reading features at: " << features_paths[i]; ReadShard(corpus_paths[i], features_paths[i], [&corpus](ByteArray input, FeatureVec features) { corpus.push_back({std::move(input), std::move(features)}); @@ -126,9 +124,10 @@ AnalyzeCorporaResults AnalyzeCorpora(const BinaryInfo &binary_info, a_only_pcs.insert(pc); } } - LOG(INFO) << VV(a.size()) << VV(b.size()) << VV(a_pcs.size()) - << VV(a_only_pcs.size()) << VV(b_only_pcs.size()) - << VV(b_shared_indices.size()) << VV(b_unique_indices.size()); + FUZZTEST_LOG(INFO) << VV(a.size()) << VV(b.size()) << VV(a_pcs.size()) + << VV(a_only_pcs.size()) << VV(b_only_pcs.size()) + << VV(b_shared_indices.size()) + << VV(b_unique_indices.size()); // Sort PCs to put them in the canonical order, as in pc_table. AnalyzeCorporaResults ret; @@ -178,7 +177,7 @@ CoverageResults GetCoverage(std::string_view binary_name, void DumpCoverageReport(const CoverageResults &coverage_results, std::string_view coverage_report_path) { - LOG(INFO) << "Dump coverage to file: " << coverage_report_path; + FUZZTEST_LOG(INFO) << "Dump coverage to file: " << coverage_report_path; const fuzztest::internal::PCTable &pc_table = coverage_results.binary_info.pc_table; @@ -187,7 +186,7 @@ void DumpCoverageReport(const CoverageResults &coverage_results, fuzztest::internal::SymbolTable coverage_symbol_table; for (const PCIndex pc : coverage_results.pcs) { - CHECK_LE(pc, symbols.size()); + FUZZTEST_CHECK_LE(pc, symbols.size()); if (!pc_table[pc].has_flag(fuzztest::internal::PCInfo::kFuncEntry)) continue; const SymbolTable::Entry entry = symbols.entry(pc); @@ -197,7 +196,7 @@ void DumpCoverageReport(const CoverageResults &coverage_results, std::ostringstream symbol_table_stream; coverage_symbol_table.WriteToLLVMSymbolizer(symbol_table_stream); - CHECK_OK( + FUZZTEST_CHECK_OK( RemoteFileSetContents(coverage_report_path, symbol_table_stream.str())); } @@ -210,8 +209,9 @@ AnalyzeCorporaResults AnalyzeCorpora(std::string_view binary_name, BinaryInfo binary_info_b = ReadBinaryInfo(binary_name, binary_hash, workdir_b); - CHECK_EQ(binary_info_a.pc_table.size(), binary_info_b.pc_table.size()); - CHECK_EQ(binary_info_a.symbols.size(), binary_info_b.symbols.size()); + FUZZTEST_CHECK_EQ(binary_info_a.pc_table.size(), + binary_info_b.pc_table.size()); + FUZZTEST_CHECK_EQ(binary_info_a.symbols.size(), binary_info_b.symbols.size()); const std::vector a = ReadCorpora(binary_name, binary_hash, workdir_a); @@ -235,26 +235,26 @@ void AnalyzeCorporaToLog(std::string_view binary_name, CoverageLogger coverage_logger(pc_table, symbols); // TODO(kcc): use frontier_a to show the most interesting b-only PCs. - // TODO(kcc): these cause a CHECK-fail + // TODO(kcc): these cause a FUZZTEST_CHECK-fail // CoverageFrontier frontier_a(results.binary_info); // frontier_a.Compute(a); // First, print the newly covered functions (including partially covered). - LOG(INFO) << "B-only new functions:"; + FUZZTEST_LOG(INFO) << "B-only new functions:"; absl::flat_hash_set b_only_new_functions; for (const auto pc : results.b_only_pcs) { if (!pc_table[pc].has_flag(PCInfo::kFuncEntry)) continue; auto str = coverage_logger.ObserveAndDescribeIfNew(pc); - if (!str.empty()) LOG(INFO).NoPrefix() << str; + if (!str.empty()) FUZZTEST_LOG(INFO).NoPrefix() << str; b_only_new_functions.insert(symbols.func(pc)); } // Now, print newly covered edges in functions that were covered in `a`. - LOG(INFO) << "B-only new edges:"; + FUZZTEST_LOG(INFO) << "B-only new edges:"; for (const auto pc : results.b_only_pcs) { if (b_only_new_functions.contains(symbols.func(pc))) continue; auto str = coverage_logger.ObserveAndDescribeIfNew(pc); - if (!str.empty()) LOG(INFO).NoPrefix() << str; + if (!str.empty()) FUZZTEST_LOG(INFO).NoPrefix() << str; } } diff --git a/centipede/analyze_corpora.h b/centipede/analyze_corpora.h index 3343e05d4..d1731b83a 100644 --- a/centipede/analyze_corpora.h +++ b/centipede/analyze_corpora.h @@ -62,7 +62,7 @@ AnalyzeCorporaResults AnalyzeCorpora(std::string_view binary_name, std::string_view workdir_a, std::string_view workdir_b); -// Same as above but `LOG`s the results for human consumption. +// Same as above but `FUZZTEST_LOG`s the results for human consumption. void AnalyzeCorporaToLog(std::string_view binary_name, std::string_view binary_hash, std::string_view workdir_a, diff --git a/centipede/analyze_corpora_test.cc b/centipede/analyze_corpora_test.cc index f65106db3..cf00c5478 100644 --- a/centipede/analyze_corpora_test.cc +++ b/centipede/analyze_corpora_test.cc @@ -24,12 +24,11 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "./centipede/binary_info.h" #include "./centipede/environment.h" #include "./centipede/symbol_table.h" #include "./centipede/test_coverage_util.h" +#include "./common/logging.h" #include "./common/remote_file.h" #include "./common/test_util.h" @@ -47,7 +46,7 @@ static std::string GetTargetPath() { } // TODO(ussuri): Implement. -TEST(AnalyzeCorpora, AnalyzeCorpora) { LOG(INFO) << "Unimplemented"; } +TEST(AnalyzeCorpora, AnalyzeCorpora) { FUZZTEST_LOG(INFO) << "Unimplemented"; } TEST(GetCoverage, SimpleCoverageResults) { Environment env; diff --git a/centipede/binary_info.cc b/centipede/binary_info.cc index d604be32d..227bb8808 100644 --- a/centipede/binary_info.cc +++ b/centipede/binary_info.cc @@ -22,14 +22,13 @@ #include #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_split.h" #include "./centipede/command.h" #include "./centipede/control_flow.h" #include "./centipede/pc_info.h" #include "./centipede/util.h" +#include "./common/logging.h" #include "./common/remote_file.h" namespace fuzztest::internal { @@ -45,18 +44,18 @@ void BinaryInfo::InitializeFromSanCovBinary( std::string_view symbolizer_path, std::string_view tmp_dir_path) { if (binary_path_with_args.empty()) { // This usually happens in tests. - LOG(INFO) << __func__ << ": binary_path_with_args is empty"; + FUZZTEST_LOG(INFO) << __func__ << ": binary_path_with_args is empty"; return; } // Compute names for temp files. const std::filesystem::path tmp_dir = tmp_dir_path; - CHECK(std::filesystem::exists(tmp_dir) && - std::filesystem::is_directory(tmp_dir)); + FUZZTEST_CHECK(std::filesystem::exists(tmp_dir) && + std::filesystem::is_directory(tmp_dir)); ScopedFile pc_table_path(tmp_dir_path, "pc_table_tmp"); ScopedFile cf_table_path(tmp_dir_path, "cf_table_tmp"); ScopedFile dso_table_path(tmp_dir_path, "dso_table_tmp"); ScopedFile log_path(tmp_dir_path, "binary_info_log_tmp"); - LOG(INFO) << __func__ << ": tmp_dir: " << tmp_dir; + FUZZTEST_LOG(INFO) << __func__ << ": tmp_dir: " << tmp_dir; Command::Options cmd_options; cmd_options.env_add = {absl::StrCat( @@ -66,7 +65,7 @@ void BinaryInfo::InitializeFromSanCovBinary( Command cmd{binary_path_with_args, std::move(cmd_options)}; int exit_code = cmd.Execute(); if (exit_code != EXIT_SUCCESS) { - LOG(INFO) << __func__ << ": exit_code: " << exit_code; + FUZZTEST_LOG(INFO) << __func__ << ": exit_code: " << exit_code; } // Load PC Table. @@ -80,24 +79,25 @@ void BinaryInfo::InitializeFromSanCovBinary( dso_table = ReadDsoTableFromFile(dso_table_path.path()); if (pc_table.empty()) { - CHECK(dso_table.empty()); + FUZZTEST_CHECK(dso_table.empty()); // Fallback to GetPcTableFromBinaryWithTracePC(). - LOG(WARNING) + FUZZTEST_LOG(WARNING) << "Failed to dump PC table directly from binary using linked-in " "runner; see target execution logs above; falling back to legacy PC " "table extraction using trace-pc and objdump"; pc_table = GetPcTableFromBinaryWithTracePC( binary_path_with_args, objdump_path, pc_table_path.path()); if (pc_table.empty()) { - LOG(ERROR) << "Failed to extract PC table from binary using objdump; see " - "objdump execution logs above"; + FUZZTEST_LOG(ERROR) + << "Failed to extract PC table from binary using objdump; see " + "objdump execution logs above"; } // For the legacy trace-pc instrumentation, set the dso_table // to 1-element array consisting of the binary name const std::vector args = absl::StrSplit(binary_path_with_args, absl::ByAnyChar{" \t\n"}, absl::SkipWhitespace{}); - CHECK(!args.empty()); + FUZZTEST_CHECK(!args.empty()); dso_table.push_back({args[0], pc_table.size()}); uses_legacy_trace_pc_instrumentation = true; } else { @@ -110,7 +110,7 @@ void BinaryInfo::InitializeFromSanCovBinary( for (const auto& dso : dso_table) { num_instrumened_pcs_in_all_dsos += dso.num_instrumented_pcs; } - CHECK_EQ(num_instrumened_pcs_in_all_dsos, pc_table.size()); + FUZZTEST_CHECK_EQ(num_instrumened_pcs_in_all_dsos, pc_table.size()); } // Load symbols, if there is a PC table. @@ -125,14 +125,14 @@ void BinaryInfo::InitializeFromSanCovBinary( void BinaryInfo::Read(std::string_view dir) { std::string symbol_table_contents; // TODO(b/295978603): move calculation of paths into WorkDir class. - CHECK_OK(RemoteFileGetContents( + FUZZTEST_CHECK_OK(RemoteFileGetContents( (std::filesystem::path(dir) / kSymbolTableFileName).c_str(), symbol_table_contents)); std::istringstream symbol_table_stream(symbol_table_contents); symbols.ReadFromLLVMSymbolizer(symbol_table_stream); std::string pc_table_contents; - CHECK_OK(RemoteFileGetContents( + FUZZTEST_CHECK_OK(RemoteFileGetContents( (std::filesystem::path(dir) / kPCTableFileName).c_str(), pc_table_contents)); std::istringstream pc_table_stream(pc_table_contents); @@ -146,19 +146,19 @@ void BinaryInfo::Write(std::string_view dir) { std::ostringstream symbol_table_stream; symbols.WriteToLLVMSymbolizer(symbol_table_stream); // TODO(b/295978603): move calculation of paths into WorkDir class. - CHECK_OK(RemoteFileSetContents( + FUZZTEST_CHECK_OK(RemoteFileSetContents( (std::filesystem::path(dir) / kSymbolTableFileName).c_str(), symbol_table_stream.str())); std::ostringstream pc_table_stream; WritePcTable(pc_table, pc_table_stream); - CHECK_OK(RemoteFileSetContents( + FUZZTEST_CHECK_OK(RemoteFileSetContents( (std::filesystem::path(dir) / kPCTableFileName).c_str(), pc_table_stream.str())); std::ostringstream cf_table_stream; WriteCfTable(cf_table, cf_table_stream); - CHECK_OK(RemoteFileSetContents( + FUZZTEST_CHECK_OK(RemoteFileSetContents( (std::filesystem::path(dir) / kCfTableFileName).c_str(), cf_table_stream.str())); } diff --git a/centipede/blob_file_converter.cc b/centipede/blob_file_converter.cc index de2142176..e9cb69b46 100644 --- a/centipede/blob_file_converter.cc +++ b/centipede/blob_file_converter.cc @@ -19,8 +19,6 @@ #include "absl/base/nullability.h" #include "absl/flags/flag.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/strings/str_format.h" #include "absl/time/clock.h" @@ -59,11 +57,11 @@ class StatsLogger { const std::string stats = absl::StrFormat( "blobs: %9lld | blobs/s: %5.0f | bytes: %12lld | bytes/s: %8.0f", num_blobs_, num_blobs_ / secs, num_bytes_, num_bytes_ / secs); - if (ABSL_VLOG_IS_ON(3)) { + if (FUZZTEST_VLOG_IS_ON(3)) { const RUsageProfiler::Snapshot& snapshot = RPROF_SNAPSHOT(stats); - LOG(INFO) << stats << " | " << snapshot.memory.ShortStr(); + FUZZTEST_LOG(INFO) << stats << " | " << snapshot.memory.ShortStr(); } else { - LOG(INFO) << stats; + FUZZTEST_LOG(INFO) << stats; } } @@ -90,45 +88,49 @@ class StatsLogger { void Convert( // const std::string& in, // const std::string& out, const std::string& out_format) { - RPROF_THIS_FUNCTION_WITH_REPORT(/*enable=*/ABSL_VLOG_IS_ON(1)); + RPROF_THIS_FUNCTION_WITH_REPORT(/*enable=*/FUZZTEST_VLOG_IS_ON(1)); - LOG(INFO) << "Converting:\n" << VV(in) << "\n" << VV(out) << VV(out_format); + FUZZTEST_LOG(INFO) << "Converting:\n" + << VV(in) << "\n" + << VV(out) << VV(out_format); const bool out_is_riegeli = out_format == "riegeli"; // Verify and prepare source and destination. - CHECK(RemotePathExists(in)) << VV(in); - CHECK_OK(RemoteMkdir(std::filesystem::path{out}.parent_path().c_str())); + FUZZTEST_CHECK(RemotePathExists(in)) << VV(in); + FUZZTEST_CHECK_OK( + RemoteMkdir(std::filesystem::path{out}.parent_path().c_str())); // Open blob file reader and writer. RPROF_START_TIMELAPSE( // - absl::Seconds(20), /*also_log=*/ABSL_VLOG_IS_ON(3), "Opening --in"); + absl::Seconds(20), /*also_log=*/FUZZTEST_VLOG_IS_ON(3), "Opening --in"); const auto in_reader = DefaultBlobFileReaderFactory(); - CHECK_OK(in_reader->Open(in)) << VV(in); + FUZZTEST_CHECK_OK(in_reader->Open(in)) << VV(in); RPROF_STOP_TIMELAPSE(); - RPROF_SNAPSHOT_AND_LOG("Opened --in; opening --out"); + RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Opened --in; opening --out"); const auto out_writer = DefaultBlobFileWriterFactory(out_is_riegeli); - CHECK_OK(out_writer->Open(out, "w")) << VV(out); - RPROF_SNAPSHOT_AND_LOG("Opened --out"); + FUZZTEST_CHECK_OK(out_writer->Open(out, "w")) << VV(out); + RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Opened --out"); // Read and write blobs one-by-one. ByteSpan blob; absl::Status read_status = absl::OkStatus(); StatsLogger stats_logger{ - absl::Seconds(ABSL_VLOG_IS_ON(1) ? 20 : 60), + absl::Seconds(FUZZTEST_VLOG_IS_ON(1) ? 20 : 60), FUNCTION_LEVEL_RPROF_NAME, }; while ((read_status = in_reader->Read(blob)).ok()) { - CHECK_OK(out_writer->Write(blob)); + FUZZTEST_CHECK_OK(out_writer->Write(blob)); stats_logger.UpdateStats(blob); stats_logger.MaybeLogIfTime(); } stats_logger.Log(); - CHECK(read_status.ok() || absl::IsOutOfRange(read_status)) << VV(read_status); - CHECK_OK(out_writer->Close()) << VV(out); + FUZZTEST_CHECK(read_status.ok() || absl::IsOutOfRange(read_status)) + << VV(read_status); + FUZZTEST_CHECK_OK(out_writer->Close()) << VV(out); } } // namespace @@ -138,11 +140,12 @@ int main(int argc, char** absl_nonnull argv) { (void)fuzztest::internal::InitRuntime(argc, argv); const std::string in = absl::GetFlag(FLAGS_in); - QCHECK(!in.empty()); + FUZZTEST_QCHECK(!in.empty()); const std::string out = absl::GetFlag(FLAGS_out); - QCHECK(!out.empty()); + FUZZTEST_QCHECK(!out.empty()); const std::string out_format = absl::GetFlag(FLAGS_out_format); - QCHECK(out_format == "legacy" || out_format == "riegeli") << VV(out_format); + FUZZTEST_QCHECK(out_format == "legacy" || out_format == "riegeli") + << VV(out_format); fuzztest::internal::Convert(in, out, out_format); diff --git a/centipede/call_graph.cc b/centipede/call_graph.cc index 912155791..b78c37f9d 100644 --- a/centipede/call_graph.cc +++ b/centipede/call_graph.cc @@ -18,9 +18,9 @@ #include #include -#include "absl/log/check.h" #include "./centipede/control_flow.h" #include "./centipede/pc_info.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -54,7 +54,7 @@ void CallGraph::InitializeCallGraph(const CFTable &cf_table, ++j; } ++j; // Step over the delimeter. - CHECK_LE(j, cf_table.size()); + FUZZTEST_CHECK_LE(j, cf_table.size()); if (current_callees.empty()) continue; basic_block_callees_[current_pc] = current_callees; @@ -64,7 +64,7 @@ void CallGraph::InitializeCallGraph(const CFTable &cf_table, current_callees.end()); } // This should stay empty. - CHECK(empty_.empty()); + FUZZTEST_CHECK(empty_.empty()); } } // namespace fuzztest::internal diff --git a/centipede/call_graph.h b/centipede/call_graph.h index 3e3c03b96..2377e36bf 100644 --- a/centipede/call_graph.h +++ b/centipede/call_graph.h @@ -20,7 +20,6 @@ #include "absl/container/flat_hash_map.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" #include "./centipede/control_flow.h" #include "./centipede/pc_info.h" #include "./common/logging.h" @@ -34,13 +33,15 @@ class CallGraph { void InitializeCallGraph(const CFTable& cf_table, const PCTable& pc_table); const std::vector& GetFunctionCallees(uintptr_t pc) const { - CHECK(IsFunctionEntry(pc)) << VV(pc) << " is not a function entry."; + FUZZTEST_CHECK(IsFunctionEntry(pc)) + << VV(pc) << " is not a function entry."; const auto it = call_graph_.find(pc); if (it == call_graph_.cend()) return empty_; return it->second; } const std::vector& GetBasicBlockCallees(uintptr_t pc) const { - CHECK(basic_blocks_.contains(pc)) << VV(pc) << " is not a basic block."; + FUZZTEST_CHECK(basic_blocks_.contains(pc)) + << VV(pc) << " is not a basic block."; const auto it = basic_block_callees_.find(pc); if (it == basic_block_callees_.cend()) return empty_; return it->second; diff --git a/centipede/centipede.cc b/centipede/centipede.cc index 84490e435..d366c7516 100644 --- a/centipede/centipede.cc +++ b/centipede/centipede.cc @@ -64,8 +64,6 @@ #include "absl/base/const_init.h" // NOLINT #include "absl/base/nullability.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/strings/ascii.h" #include "absl/strings/str_cat.h" @@ -132,15 +130,15 @@ Centipede::Centipede(const Environment &env, CentipedeCallbacks &user_callbacks, /*raii_actions=*/RUsageProfiler::kRaiiOff, /*location=*/{__FILE__, __LINE__}, /*description=*/"Engine") { - CHECK(env_.seed) << "env_.seed must not be zero"; + FUZZTEST_CHECK(env_.seed) << "env_.seed must not be zero"; if (!env_.input_filter.empty() && env_.fork_server) input_filter_cmd_.StartForkServer(TemporaryLocalDirPath(), "input_filter"); } void Centipede::CorpusToFiles(const Environment &env, std::string_view dir) { std::vector sharded_corpus_files; - CHECK_OK(RemoteGlobMatch(WorkDir{env}.CorpusFilePaths().AllShardsGlob(), - sharded_corpus_files)); + FUZZTEST_CHECK_OK(RemoteGlobMatch( + WorkDir{env}.CorpusFilePaths().AllShardsGlob(), sharded_corpus_files)); ExportCorpus(sharded_corpus_files, dir); } @@ -161,7 +159,7 @@ void Centipede::CorpusFromFiles(const Environment &env, std::string_view dir) { // If the destination `workdir` is specified (note that empty means "use the // current directory"), we might need to create it. if (!env.workdir.empty()) { - CHECK_OK(RemoteMkdir(env.workdir)); + FUZZTEST_CHECK_OK(RemoteMkdir(env.workdir)); } // Iterate over all shards, adding inputs to the current shard. @@ -184,23 +182,23 @@ void Centipede::CorpusFromFiles(const Environment &env, std::string_view dir) { } // Add inputs to the current shard, if the shard doesn't have them already. auto appender = DefaultBlobFileWriterFactory(env.riegeli); - CHECK_OK(appender->Open(corpus_file_path, "a")) + FUZZTEST_CHECK_OK(appender->Open(corpus_file_path, "a")) << "Failed to open corpus file: " << corpus_file_path; ByteArray shard_data; for (const auto &path : sharded_paths[shard]) { std::string input; - CHECK_OK(RemoteFileGetContents(path, input)); + FUZZTEST_CHECK_OK(RemoteFileGetContents(path, input)); if (input.empty() || existing_hashes.contains(Hash(input))) { ++inputs_ignored; continue; } - CHECK_OK(appender->Write(ByteArray{input.begin(), input.end()})); + FUZZTEST_CHECK_OK(appender->Write(ByteArray{input.begin(), input.end()})); ++inputs_added; } - LOG(INFO) << VV(shard) << VV(inputs_added) << VV(inputs_ignored) - << VV(num_shard_bytes) << VV(shard_data.size()); + FUZZTEST_LOG(INFO) << VV(shard) << VV(inputs_added) << VV(inputs_ignored) + << VV(num_shard_bytes) << VV(shard_data.size()); } - CHECK_EQ(total_paths, inputs_added + inputs_ignored); + FUZZTEST_CHECK_EQ(total_paths, inputs_added + inputs_ignored); } absl::Status Centipede::CrashesToFiles(const Environment &env, @@ -228,7 +226,7 @@ absl::Status Centipede::CrashesToFiles(const Environment &env, (std::filesystem::path{dir} / absl::StrCat(id, ".data")).string())); const auto shard_index = wd.CrashReproducerDirPaths().GetShardIndex( std::filesystem::path{reproducer_path}.parent_path().string()); - CHECK(shard_index.has_value()); + FUZZTEST_CHECK(shard_index.has_value()); const auto metadata_dir = wd.CrashMetadataDirPaths().Shard(*shard_index); const auto description_filename = absl::StrCat(id, ".desc"); const auto signature_filename = absl::StrCat(id, ".sig"); @@ -339,7 +337,7 @@ void Centipede::UpdateAndMaybeLogStats(std::string_view log_type, os << " exec/s: " << (execs_per_sec < 1.0 ? execs_per_sec : std::round(execs_per_sec)); os << " mb: " << (rusage_memory.mem_rss >> 20); - LOG(INFO) << os.str(); + FUZZTEST_LOG(INFO) << os.str(); } void Centipede::LogFeaturesAsSymbols(const FeatureVec &fv) { @@ -349,7 +347,7 @@ void Centipede::LogFeaturesAsSymbols(const FeatureVec &fv) { PCIndex pc_index = ConvertPCFeatureToPcIndex(feature); auto description = coverage_logger_.ObserveAndDescribeIfNew(pc_index); if (description.empty()) continue; - LOG(INFO) << description; + FUZZTEST_LOG(INFO) << description; } } @@ -417,7 +415,7 @@ bool Centipede::RunBatch( BlobFileWriter *absl_nullable unconditional_features_file) { BatchResult batch_result; bool success = ExecuteAndReportCrash(env_.binary, input_vec, batch_result); - CHECK_EQ(input_vec.size(), batch_result.results().size()); + FUZZTEST_CHECK_EQ(input_vec.size(), batch_result.results().size()); for (const auto &extra_binary : env_.extra_binaries) { if (ShouldStop()) break; @@ -428,11 +426,11 @@ bool Centipede::RunBatch( } if (EarlyStopRequested()) return false; if (!success && env_.exit_on_crash) { - LOG(INFO) << "--exit_on_crash is enabled; exiting soon"; + FUZZTEST_LOG(INFO) << "--exit_on_crash is enabled; exiting soon"; RequestEarlyStop(EXIT_FAILURE); return false; } - CHECK_EQ(batch_result.results().size(), input_vec.size()); + FUZZTEST_CHECK_EQ(batch_result.results().size(), input_vec.size()); num_runs_ += input_vec.size(); bool batch_gained_new_coverage = false; for (size_t i = 0; i < input_vec.size(); i++) { @@ -443,7 +441,7 @@ bool Centipede::RunBatch( if (env_.use_pcpair_features && AddPcPairFeatures(fv) != 0) input_gained_new_coverage = true; if (unconditional_features_file != nullptr) { - CHECK_OK(unconditional_features_file->Write( + FUZZTEST_CHECK_OK(unconditional_features_file->Write( PackFeaturesAndHash(input_vec[i], fv))); } if (input_gained_new_coverage) { @@ -452,19 +450,20 @@ bool Centipede::RunBatch( fs_.IncrementFrequencies(fv); LogFeaturesAsSymbols(fv); batch_gained_new_coverage = true; - CHECK_GT(fv.size(), 0UL); + FUZZTEST_CHECK_GT(fv.size(), 0UL); if (function_filter_passed) { corpus_.Add(input_vec[i], fv, batch_result.results()[i].metadata(), fs_, coverage_frontier_); } if (corpus_file != nullptr) { - CHECK_OK(corpus_file->Write(input_vec[i])); + FUZZTEST_CHECK_OK(corpus_file->Write(input_vec[i])); } if (!env_.corpus_dir.empty() && !env_.corpus_dir[0].empty()) { WriteToLocalHashedFileInDir(env_.corpus_dir[0], input_vec[i]); } if (features_file != nullptr) { - CHECK_OK(features_file->Write(PackFeaturesAndHash(input_vec[i], fv))); + FUZZTEST_CHECK_OK( + features_file->Write(PackFeaturesAndHash(input_vec[i], fv))); } } } @@ -474,8 +473,8 @@ bool Centipede::RunBatch( // TODO(kcc): [impl] don't reread the same corpus twice. void Centipede::LoadShard(const Environment &load_env, size_t shard_index, bool rerun) { - VLOG(1) << "Loading shard " << shard_index - << (rerun ? " with rerunning" : " without rerunning"); + FUZZTEST_VLOG(1) << "Loading shard " << shard_index + << (rerun ? " with rerunning" : " without rerunning"); size_t num_added_inputs = 0; size_t num_skipped_inputs = 0; std::vector inputs_to_rerun; @@ -491,14 +490,14 @@ void Centipede::LoadShard(const Environment &load_env, size_t shard_index, const auto num_new_features = fs_.PruneFeaturesAndCountUnseen(input_features); if (num_new_features != 0) { - VLOG(10) << "Adding input " << Hash(input) - << "; new features: " << num_new_features; + FUZZTEST_VLOG(10) << "Adding input " << Hash(input) + << "; new features: " << num_new_features; fs_.IncrementFrequencies(input_features); // TODO(kcc): cmp_args are currently not saved to disk and not reloaded. corpus_.Add(input, input_features, {}, fs_, coverage_frontier_); ++num_added_inputs; } else { - VLOG(10) << "Skipping input: " << Hash(input); + FUZZTEST_VLOG(10) << "Skipping input: " << Hash(input); ++num_skipped_inputs; } } @@ -517,8 +516,9 @@ void Centipede::LoadShard(const Environment &load_env, size_t shard_index, ReadShard(corpus_path, features_path, input_features_callback); } - VLOG(1) << "Loaded shard " << shard_index << ": added " << num_added_inputs - << " / skipped " << num_skipped_inputs << " inputs"; + FUZZTEST_VLOG(1) << "Loaded shard " << shard_index << ": added " + << num_added_inputs << " / skipped " << num_skipped_inputs + << " inputs"; if (num_added_inputs > 0) UpdateAndMaybeLogStats("load-shard", 1); if (!inputs_to_rerun.empty()) Rerun(inputs_to_rerun); @@ -536,7 +536,8 @@ void Centipede::LoadAllShardsInRandomOrder(const Environment &load_env, for (size_t shard_idx : shard_idxs) { const bool rerun = rerun_my_shard && shard_idx == env_.my_shard_index; LoadShard(load_env, shard_idx, rerun); - LOG_IF(INFO, (++num_shards_loaded % 100) == 0) << VV(num_shards_loaded); + FUZZTEST_LOG_IF(INFO, (++num_shards_loaded % 100) == 0) + << VV(num_shards_loaded); } } @@ -544,9 +545,9 @@ void Centipede::Rerun(std::vector &to_rerun) { if (to_rerun.empty()) return; auto features_file_path = wd_.FeaturesFilePaths().Shard(env_.my_shard_index); auto features_file = DefaultBlobFileWriterFactory(env_.riegeli); - CHECK_OK(features_file->Open(features_file_path, "a")); + FUZZTEST_CHECK_OK(features_file->Open(features_file_path, "a")); - LOG(INFO) << to_rerun.size() << " inputs to rerun"; + FUZZTEST_LOG(INFO) << to_rerun.size() << " inputs to rerun"; // Re-run all inputs for which we don't know their features. // Run in batches of at most env_.batch_size inputs each. while (!to_rerun.empty()) { @@ -565,8 +566,8 @@ void Centipede::GenerateCoverageReport(std::string_view filename_annotation, if (pc_table_.empty()) return; auto coverage_path = wd_.CoverageReportPath(filename_annotation); - LOG(INFO) << "Generate coverage report [" << description << "]; " - << VV(coverage_path); + FUZZTEST_LOG(INFO) << "Generate coverage report [" << description << "]; " + << VV(coverage_path); auto pci_vec = fs_.ToCoveragePCs(); Coverage coverage(pc_table_, pci_vec); coverage.DumpReportToFile(symbols_, coverage_path, description); @@ -575,8 +576,8 @@ void Centipede::GenerateCoverageReport(std::string_view filename_annotation, void Centipede::GenerateCorpusStats(std::string_view filename_annotation, std::string_view description) { auto stats_path = wd_.CorpusStatsPath(filename_annotation); - LOG(INFO) << "Generate corpus stats [" << description << "]; " - << VV(stats_path); + FUZZTEST_LOG(INFO) << "Generate corpus stats [" << description << "]; " + << VV(stats_path); corpus_.DumpStatsToFile(fs_, stats_path, description); } @@ -586,14 +587,14 @@ void Centipede::GenerateSourceBasedCoverageReport( if (env_.clang_coverage_binary.empty()) return; auto report_path = wd_.SourceBasedCoverageReportPath(filename_annotation); - LOG(INFO) << "Generate source based coverage report [" << description << "]; " - << VV(report_path); - CHECK_OK(RemoteMkdir(report_path)); + FUZZTEST_LOG(INFO) << "Generate source based coverage report [" << description + << "]; " << VV(report_path); + FUZZTEST_CHECK_OK(RemoteMkdir(report_path)); std::vector raw_profiles = wd_.EnumerateRawCoverageProfiles(); if (raw_profiles.empty()) { - LOG(ERROR) << "No raw profiles found for coverage report"; + FUZZTEST_LOG(ERROR) << "No raw profiles found for coverage report"; return; } @@ -610,7 +611,7 @@ void Centipede::GenerateSourceBasedCoverageReport( merge_cmd_options.args = std::move(merge_arguments); Command merge_command{"llvm-profdata", std::move(merge_cmd_options)}; if (merge_command.Execute() != EXIT_SUCCESS) { - LOG(ERROR) << "Failed to run command " << merge_command.ToString(); + FUZZTEST_LOG(ERROR) << "Failed to run command " << merge_command.ToString(); return; } @@ -622,8 +623,8 @@ void Centipede::GenerateSourceBasedCoverageReport( Command generate_report_command{"llvm-cov", std::move(generate_report_cmd_options)}; if (generate_report_command.Execute() != EXIT_SUCCESS) { - LOG(ERROR) << "Failed to run command " - << generate_report_command.ToString(); + FUZZTEST_LOG(ERROR) << "Failed to run command " + << generate_report_command.ToString(); return; } } @@ -634,15 +635,16 @@ void Centipede::GenerateRUsageReport(std::string_view filename_annotation, public: explicit ReportDumper(std::string_view path) : file_{*RemoteFileOpen(path, "w")} { - CHECK(file_ != nullptr) << VV(path); - CHECK_OK(RemoteFileSetWriteBufferSize(file_, 10UL * 1024 * 1024)); + FUZZTEST_CHECK(file_ != nullptr) << VV(path); + FUZZTEST_CHECK_OK( + RemoteFileSetWriteBufferSize(file_, 10UL * 1024 * 1024)); } - ~ReportDumper() override { CHECK_OK(RemoteFileClose(file_)); } + ~ReportDumper() override { FUZZTEST_CHECK_OK(RemoteFileClose(file_)); } ReportDumper &operator<<(std::string_view fragment) override { - CHECK_OK(RemoteFileAppend(file_, - ByteArray{fragment.cbegin(), fragment.cend()})); + FUZZTEST_CHECK_OK(RemoteFileAppend( + file_, ByteArray{fragment.cbegin(), fragment.cend()})); return *this; } @@ -652,10 +654,11 @@ void Centipede::GenerateRUsageReport(std::string_view filename_annotation, const auto &snapshot = rusage_profiler_.TakeSnapshot( {__FILE__, __LINE__}, std::string{description}); - VLOG(1) << "Rusage @ " << description << ": " << snapshot.ShortMetricsStr(); + FUZZTEST_VLOG(1) << "Rusage @ " << description << ": " + << snapshot.ShortMetricsStr(); auto path = wd_.RUsageReportPath(filename_annotation); - LOG(INFO) << "Generate rusage report [" << description << "]; " - << VV(env_.my_shard_index) << VV(path); + FUZZTEST_LOG(INFO) << "Generate rusage report [" << description << "]; " + << VV(env_.my_shard_index) << VV(path); ReportDumper dumper{path}; rusage_profiler_.GenerateReport(&dumper); } @@ -682,22 +685,23 @@ void Centipede::MaybeGenerateTelemetryAfterBatch( void Centipede::MergeFromOtherCorpus(std::string_view merge_from_dir, size_t shard_index_to_merge) { - LOG(INFO) << __func__ << ": " << merge_from_dir; + FUZZTEST_LOG(INFO) << __func__ << ": " << merge_from_dir; Environment merge_from_env = env_; merge_from_env.workdir = merge_from_dir; size_t initial_corpus_size = corpus_.NumActive(); LoadShard(merge_from_env, shard_index_to_merge, /*rerun=*/true); size_t new_corpus_size = corpus_.NumActive(); - CHECK_GE(new_corpus_size, initial_corpus_size); // Corpus can't shrink here. + FUZZTEST_CHECK_GE(new_corpus_size, + initial_corpus_size); // Corpus can't shrink here. if (new_corpus_size > initial_corpus_size) { auto appender = DefaultBlobFileWriterFactory(env_.riegeli); - CHECK_OK( + FUZZTEST_CHECK_OK( appender->Open(wd_.CorpusFilePaths().Shard(env_.my_shard_index), "a")); for (size_t idx = initial_corpus_size; idx < new_corpus_size; ++idx) { - CHECK_OK(appender->Write(corpus_.Get(idx))); + FUZZTEST_CHECK_OK(appender->Write(corpus_.Get(idx))); } - LOG(INFO) << "Merge: " << (new_corpus_size - initial_corpus_size) - << " new inputs added"; + FUZZTEST_LOG(INFO) << "Merge: " << (new_corpus_size - initial_corpus_size) + << " new inputs added"; } } @@ -712,16 +716,16 @@ void Centipede::ReloadAllShardsAndWriteDistilledCorpus() { // Save the distilled corpus to a file in workdir and possibly to a hashed // file in the first corpus dir passed in `--corpus_dir`. const auto distill_to_path = wd_.DistilledCorpusFilePaths().MyShard(); - LOG(INFO) << "Distilling: shard: " << env_.my_shard_index - << " output: " << distill_to_path << " " - << " distilled size: " << corpus_.NumActive(); + FUZZTEST_LOG(INFO) << "Distilling: shard: " << env_.my_shard_index + << " output: " << distill_to_path << " " + << " distilled size: " << corpus_.NumActive(); const auto appender = DefaultBlobFileWriterFactory(env_.riegeli); // NOTE: Always overwrite distilled corpus files -- never append, unlike // "regular", per-shard corpus files. - CHECK_OK(appender->Open(distill_to_path, "w")); + FUZZTEST_CHECK_OK(appender->Open(distill_to_path, "w")); for (size_t i = 0; i < corpus_.NumActive(); ++i) { const ByteArray &input = corpus_.Get(i); - CHECK_OK(appender->Write(input)); + FUZZTEST_CHECK_OK(appender->Write(input)); if (!env_.corpus_dir.empty() && !env_.corpus_dir[0].empty()) { WriteToLocalHashedFileInDir(env_.corpus_dir[0], input); } @@ -734,21 +738,22 @@ void Centipede::LoadSeedInputs(BlobFileWriter *absl_nonnull corpus_file, const size_t num_seeds_available = user_callbacks_.GetSeeds(env_.batch_size, seed_inputs); if (num_seeds_available > env_.batch_size) { - LOG(WARNING) << "More seeds available than requested: " - << num_seeds_available << " > " << env_.batch_size; + FUZZTEST_LOG(WARNING) << "More seeds available than requested: " + << num_seeds_available << " > " << env_.batch_size; } if (seed_inputs.empty()) { - QCHECK(!env_.require_seeds) + FUZZTEST_QCHECK(!env_.require_seeds) << "No seeds returned and --require_seeds=true, exiting early."; - LOG(WARNING) + FUZZTEST_LOG(WARNING) << "No seeds returned - will use the default seed of single byte {0}"; seed_inputs.push_back({0}); } RunBatch(seed_inputs, corpus_file, features_file, /*unconditional_features_file=*/nullptr); - LOG(INFO) << "Number of input seeds available: " << num_seeds_available - << ", number included in corpus: " << corpus_.NumTotal(); + FUZZTEST_LOG(INFO) << "Number of input seeds available: " + << num_seeds_available + << ", number included in corpus: " << corpus_.NumTotal(); // Forcely add all seed inputs to avoid empty corpus if none of them increased // coverage and passed the filters. @@ -759,9 +764,10 @@ void Centipede::LoadSeedInputs(BlobFileWriter *absl_nonnull corpus_file, } void Centipede::FuzzingLoop() { - LOG(INFO) << "Shard: " << env_.my_shard_index << "/" << env_.total_shards - << " " << TemporaryLocalDirPath() << " " - << "seed: " << env_.seed << "\n\n\n"; + FUZZTEST_LOG(INFO) << "Shard: " << env_.my_shard_index << "/" + << env_.total_shards << " " << TemporaryLocalDirPath() + << " " + << "seed: " << env_.seed << "\n\n\n"; UpdateAndMaybeLogStats("begin-fuzz", 0); @@ -780,10 +786,10 @@ void Centipede::FuzzingLoop() { auto corpus_path = wd_.CorpusFilePaths().Shard(env_.my_shard_index); auto corpus_file = DefaultBlobFileWriterFactory(env_.riegeli); - CHECK_OK(corpus_file->Open(corpus_path, "a")); + FUZZTEST_CHECK_OK(corpus_file->Open(corpus_path, "a")); auto features_path = wd_.FeaturesFilePaths().Shard(env_.my_shard_index); auto features_file = DefaultBlobFileWriterFactory(env_.riegeli); - CHECK_OK(features_file->Open(features_path, "a")); + FUZZTEST_CHECK_OK(features_file->Open(features_path, "a")); LoadSeedInputs(corpus_file.get(), features_file.get()); @@ -809,7 +815,7 @@ void Centipede::FuzzingLoop() { size_t corpus_size_at_last_prune = corpus_.NumActive(); for (size_t batch_index = 0; batch_index < number_of_batches; batch_index++) { if (ShouldStop()) break; - CHECK_LT(new_runs, env_.num_runs); + FUZZTEST_CHECK_LT(new_runs, env_.num_runs); auto remaining_runs = env_.num_runs - new_runs; auto batch_size = std::min(env_.batch_size, remaining_runs); std::vector mutation_inputs; @@ -846,7 +852,7 @@ void Centipede::FuzzingLoop() { size_t rand = rng_() % (env_.total_shards - 1); size_t other_shard_index = (env_.my_shard_index + 1 + rand) % env_.total_shards; - CHECK_NE(other_shard_index, env_.my_shard_index); + FUZZTEST_CHECK_NE(other_shard_index, env_.my_shard_index); LoadShard(env_, other_shard_index, /*rerun=*/false); } @@ -870,49 +876,49 @@ void Centipede::FuzzingLoop() { void Centipede::ReportCrash(std::string_view binary, const std::vector &input_vec, const BatchResult &batch_result) { - CHECK_EQ(input_vec.size(), batch_result.results().size()); + FUZZTEST_CHECK_EQ(input_vec.size(), batch_result.results().size()); const size_t suspect_input_idx = std::clamp( batch_result.num_outputs_read(), 0, input_vec.size() - 1); auto log_execution_failure = [&](std::string_view log_prefix) { - LOG(INFO) << log_prefix << "Batch execution failed:" - << "\nBinary : " << binary - << "\nExit code : " << batch_result.exit_code() - << "\nFailure : " - << batch_result.failure_description() - << "\nSignature : " - << AsPrintableString(AsByteSpan(batch_result.failure_signature()), - /*max_len=*/32) - << "\nNumber of inputs : " << input_vec.size() - << "\nNumber of inputs read: " << batch_result.num_outputs_read() - << (batch_result.IsSetupFailure() - ? "" - : absl::StrCat("\nSuspect input index : ", - suspect_input_idx)) - << "\nCrash log :\n\n"; + FUZZTEST_LOG(INFO) + << log_prefix << "Batch execution failed:" + << "\nBinary : " << binary + << "\nExit code : " << batch_result.exit_code() + << "\nFailure : " << batch_result.failure_description() + << "\nSignature : " + << AsPrintableString(AsByteSpan(batch_result.failure_signature()), + /*max_len=*/32) + << "\nNumber of inputs : " << input_vec.size() + << "\nNumber of inputs read: " << batch_result.num_outputs_read() + << (batch_result.IsSetupFailure() + ? "" + : absl::StrCat("\nSuspect input index : ", suspect_input_idx)) + << "\nCrash log :\n\n"; for (const auto &log_line : absl::StrSplit(absl::StripAsciiWhitespace(batch_result.log()), '\n')) { - LOG(INFO).NoPrefix() << "CRASH LOG: " << log_line; + FUZZTEST_LOG(INFO).NoPrefix() << "CRASH LOG: " << log_line; } - LOG(INFO).NoPrefix() << "\n"; + FUZZTEST_LOG(INFO).NoPrefix() << "\n"; }; if (batch_result.IsIgnoredFailure()) { - LOG(INFO) << "Skip further processing of " - << batch_result.failure_description(); + FUZZTEST_LOG(INFO) << "Skip further processing of " + << batch_result.failure_description(); return; } if (batch_result.IsSkippedTest()) { log_execution_failure("Skipped Test: "); - LOG(INFO) << "Requesting early stop due to skipped test."; + FUZZTEST_LOG(INFO) << "Requesting early stop due to skipped test."; RequestEarlyStop(EXIT_SUCCESS); return; } if (batch_result.IsSetupFailure()) { log_execution_failure("Test Setup Failure: "); - LOG(INFO) << "Requesting early stop due to setup failure in the test."; + FUZZTEST_LOG(INFO) + << "Requesting early stop due to setup failure in the test."; RequestEarlyStop(EXIT_FAILURE); return; } @@ -927,14 +933,15 @@ void Centipede::ReportCrash(std::string_view binary, absl::StrCat("ReportCrash[", num_crashes_, "]: "); log_execution_failure(log_prefix); - LOG_IF(INFO, num_crashes_ == env_.max_num_crash_reports) + FUZZTEST_LOG_IF(INFO, num_crashes_ == env_.max_num_crash_reports) << log_prefix << "Reached --max_num_crash_reports: further reports will be suppressed"; if (batch_result.failure_description() == kExecutionFailurePerBatchTimeout) { - LOG(INFO) << log_prefix - << "Failure applies to entire batch: not executing inputs " - "one-by-one, trying to find the reproducer"; + FUZZTEST_LOG(INFO) + << log_prefix + << "Failure applies to entire batch: not executing inputs " + "one-by-one, trying to find the reproducer"; return; } @@ -952,14 +959,15 @@ void Centipede::ReportCrash(std::string_view binary, // primed for a crash by the sequence of inputs that preceded the crasher. std::iota(input_idxs_to_try.begin() + 1, input_idxs_to_try.end(), 0); } else { - LOG(INFO) + FUZZTEST_LOG(INFO) << log_prefix << "Skip finding the reproducer from the inputs other than the suspect"; } // Try inputs one-by-one in the determined order. - LOG(INFO) << log_prefix - << "Executing inputs one-by-one, trying to find the reproducer"; + FUZZTEST_LOG(INFO) + << log_prefix + << "Executing inputs one-by-one, trying to find the reproducer"; for (auto input_idx : input_idxs_to_try) { if (ShouldStop()) return; const auto &one_input = input_vec[input_idx]; @@ -967,38 +975,38 @@ void Centipede::ReportCrash(std::string_view binary, if (!user_callbacks_.Execute(binary, {one_input}, one_input_batch_result)) { auto hash = Hash(one_input); auto crash_dir = wd_.CrashReproducerDirPaths().MyShard(); - CHECK_OK(RemoteMkdir(crash_dir)); + FUZZTEST_CHECK_OK(RemoteMkdir(crash_dir)); std::string input_file_path = std::filesystem::path(crash_dir) / hash; auto crash_metadata_dir = wd_.CrashMetadataDirPaths().MyShard(); - CHECK_OK(RemoteMkdir(crash_metadata_dir)); + FUZZTEST_CHECK_OK(RemoteMkdir(crash_metadata_dir)); std::string crash_metadata_path_prefix = std::filesystem::path(crash_metadata_dir) / hash; - LOG(INFO) << log_prefix << "Detected crash-reproducing input:" - << "\nInput index : " << input_idx << "\nInput bytes : " - << AsPrintableString(one_input, /*max_len=*/32) - << "\nExit code : " << one_input_batch_result.exit_code() - << "\nFailure : " - << one_input_batch_result.failure_description() - << "\nSignature : " - << AsPrintableString( - AsByteSpan(one_input_batch_result.failure_signature()), - /*max_len=*/32) - << "\nSaving input to: " << input_file_path - << "\nSaving crash" // - << "\nmetadata to : " << crash_metadata_path_prefix << ".*"; - CHECK_OK(RemoteFileSetContents(input_file_path, one_input)); - CHECK_OK(RemoteFileSetContents( + FUZZTEST_LOG(INFO) + << log_prefix << "Detected crash-reproducing input:" + << "\nInput index : " << input_idx << "\nInput bytes : " + << AsPrintableString(one_input, /*max_len=*/32) + << "\nExit code : " << one_input_batch_result.exit_code() + << "\nFailure : " + << one_input_batch_result.failure_description() + << "\nSignature : " + << AsPrintableString( + AsByteSpan(one_input_batch_result.failure_signature()), + /*max_len=*/32) + << "\nSaving input to: " << input_file_path << "\nSaving crash" // + << "\nmetadata to : " << crash_metadata_path_prefix << ".*"; + FUZZTEST_CHECK_OK(RemoteFileSetContents(input_file_path, one_input)); + FUZZTEST_CHECK_OK(RemoteFileSetContents( absl::StrCat(crash_metadata_path_prefix, ".desc"), one_input_batch_result.failure_description())); - CHECK_OK(RemoteFileSetContents( + FUZZTEST_CHECK_OK(RemoteFileSetContents( absl::StrCat(crash_metadata_path_prefix, ".sig"), one_input_batch_result.failure_signature())); return; } } - LOG(INFO) << log_prefix - << "Crash was not observed when running inputs one-by-one"; + FUZZTEST_LOG(INFO) << log_prefix + << "Crash was not observed when running inputs one-by-one"; // There will be cases when several inputs collectively cause a crash, but no // single input does. Handle this by writing out the inputs from the batch @@ -1011,27 +1019,28 @@ void Centipede::ReportCrash(std::string_view binary, const auto &suspect_input = input_vec[suspect_input_idx]; auto suspect_hash = Hash(suspect_input); auto crash_dir = wd_.CrashReproducerDirPaths().MyShard(); - CHECK_OK(RemoteMkdir(crash_dir)); + FUZZTEST_CHECK_OK(RemoteMkdir(crash_dir)); std::string crashing_batch_name = absl::StrCat("crashing_batch-", suspect_hash); std::string save_dir = std::filesystem::path(crash_dir) / crashing_batch_name; - CHECK_OK(RemoteMkdir(save_dir)); - LOG(INFO) << log_prefix << "Saving used inputs from batch to: " << save_dir; + FUZZTEST_CHECK_OK(RemoteMkdir(save_dir)); + FUZZTEST_LOG(INFO) << log_prefix + << "Saving used inputs from batch to: " << save_dir; for (int i = 0; i <= suspect_input_idx; ++i) { const auto &one_input = input_vec[i]; auto hash = Hash(one_input); std::string file_path = std::filesystem::path(save_dir).append( absl::StrFormat("input-%010d-%s", i, hash)); - CHECK_OK(RemoteFileSetContents(file_path, one_input)); + FUZZTEST_CHECK_OK(RemoteFileSetContents(file_path, one_input)); } auto crash_metadata_dir = wd_.CrashMetadataDirPaths().MyShard(); - CHECK_OK(RemoteMkdir(crash_metadata_dir)); + FUZZTEST_CHECK_OK(RemoteMkdir(crash_metadata_dir)); std::string crash_metadata_file_path = std::filesystem::path(crash_metadata_dir) / crashing_batch_name; - LOG(INFO) << log_prefix - << "Saving crash metadata to: " << crash_metadata_file_path; - CHECK_OK(RemoteFileSetContents(crash_metadata_file_path, - batch_result.failure_description())); + FUZZTEST_LOG(INFO) << log_prefix << "Saving crash metadata to: " + << crash_metadata_file_path; + FUZZTEST_CHECK_OK(RemoteFileSetContents(crash_metadata_file_path, + batch_result.failure_description())); } } // namespace fuzztest::internal diff --git a/centipede/centipede_callbacks.cc b/centipede/centipede_callbacks.cc index 8a2ec0ca1..5b010b466 100644 --- a/centipede/centipede_callbacks.cc +++ b/centipede/centipede_callbacks.cc @@ -24,8 +24,6 @@ #include #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/ascii.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_join.h" @@ -81,17 +79,18 @@ void CentipedeCallbacks::PopulateBinaryInfo(BinaryInfo &binary_info) { // Check the PC table. if (binary_info.pc_table.empty()) { if (env_.require_pc_table) { - LOG(ERROR) << "Could not get PC table; exiting (override with " - "--require_pc_table=false)"; + FUZZTEST_LOG(ERROR) << "Could not get PC table; exiting (override with " + "--require_pc_table=false)"; exit(EXIT_FAILURE); } - LOG(WARNING) << "Could not get PC table; CF table and debug symbols will " - "not be used"; + FUZZTEST_LOG(WARNING) + << "Could not get PC table; CF table and debug symbols will " + "not be used"; return; } // Check CF table. if (binary_info.cf_table.empty()) { - LOG(WARNING) + FUZZTEST_LOG(WARNING) << "Could not get CF table; binary should be built with Clang 16 (or " "later) and with -fsanitize-coverage=control-flow flag"; } else { @@ -197,7 +196,7 @@ int CentipedeCallbacks::ExecuteCentipedeSancovBinaryWithShmem( size_t num_inputs_written = 0; if (env_.has_input_wildcards) { - CHECK_EQ(inputs.size(), 1); + FUZZTEST_CHECK_EQ(inputs.size(), 1); WriteToLocalFile(temp_input_file_path_, inputs[0]); num_inputs_written = 1; } else { @@ -206,9 +205,9 @@ int CentipedeCallbacks::ExecuteCentipedeSancovBinaryWithShmem( } if (num_inputs_written != inputs.size()) { - LOG(INFO) << "Wrote " << num_inputs_written << "/" << inputs.size() - << " inputs; shmem_size_mb might be too small: " - << env_.shmem_size_mb; + FUZZTEST_LOG(INFO) << "Wrote " << num_inputs_written << "/" << inputs.size() + << " inputs; shmem_size_mb might be too small: " + << env_.shmem_size_mb; } // Run. @@ -219,7 +218,7 @@ int CentipedeCallbacks::ExecuteCentipedeSancovBinaryWithShmem( // Get results. batch_result.exit_code() = retval; const bool read_success = batch_result.Read(outputs_blobseq_); - LOG_IF(ERROR, !read_success) << "Failed to read batch result!"; + FUZZTEST_LOG_IF(ERROR, !read_success) << "Failed to read batch result!"; outputs_blobseq_.ReleaseSharedMemory(); // Outputs are already consumed. // We may have fewer feature blobs than inputs if @@ -231,10 +230,10 @@ int CentipedeCallbacks::ExecuteCentipedeSancovBinaryWithShmem( // * Logged by the following code. if (retval == 0 && read_success && batch_result.num_outputs_read() != num_inputs_written) { - LOG(INFO) << "Read " << batch_result.num_outputs_read() << "/" - << num_inputs_written - << " outputs; shmem_size_mb might be too small: " - << env_.shmem_size_mb; + FUZZTEST_LOG(INFO) << "Read " << batch_result.num_outputs_read() << "/" + << num_inputs_written + << " outputs; shmem_size_mb might be too small: " + << env_.shmem_size_mb; } if (env_.print_runner_log) PrintExecutionLog(); @@ -256,7 +255,7 @@ int CentipedeCallbacks::ExecuteCentipedeSancovBinaryWithShmem( std::filesystem::remove(failure_description_path_); std::filesystem::remove(failure_signature_path_); } - VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time); + FUZZTEST_VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time); return retval; } @@ -266,8 +265,8 @@ bool CentipedeCallbacks::GetSeedsViaExternalBinary( std::vector &seeds) { const auto output_dir = std::filesystem::path{temp_dir_} / "seed_inputs"; std::error_code error; - CHECK(std::filesystem::create_directories(output_dir, error)); - CHECK(!error); + FUZZTEST_CHECK(std::filesystem::create_directories(output_dir, error)); + FUZZTEST_CHECK(!error); std::string centipede_runner_flags = absl::StrCat( "CENTIPEDE_RUNNER_FLAGS=:dump_seed_inputs:test=", env_.test_name, @@ -286,7 +285,8 @@ bool CentipedeCallbacks::GetSeedsViaExternalBinary( const int retval = cmd.Execute(); if (env_.print_runner_log) { - LOG(INFO) << "Getting seeds via external binary returns " << retval; + FUZZTEST_LOG(INFO) << "Getting seeds via external binary returns " + << retval; PrintExecutionLog(); } @@ -344,7 +344,7 @@ bool CentipedeCallbacks::GetSerializedTargetConfigViaExternalBinary( } std::error_code error; std::filesystem::remove(config_file_path, error); - CHECK(!error); + FUZZTEST_CHECK(!error); return is_success; } @@ -353,7 +353,7 @@ bool CentipedeCallbacks::GetSerializedTargetConfigViaExternalBinary( MutationResult CentipedeCallbacks::MutateViaExternalBinary( std::string_view binary, const std::vector &inputs, size_t num_mutants) { - CHECK(!env_.has_input_wildcards) + FUZZTEST_CHECK(!env_.has_input_wildcards) << "Standalone binary does not support custom mutator"; auto start_time = absl::Now(); @@ -362,7 +362,7 @@ MutationResult CentipedeCallbacks::MutateViaExternalBinary( size_t num_inputs_written = RequestMutation(num_mutants, inputs, inputs_blobseq_); - LOG_IF(INFO, num_inputs_written != inputs.size()) + FUZZTEST_LOG_IF(INFO, num_inputs_written != inputs.size()) << VV(num_inputs_written) << VV(inputs.size()); // Execute. @@ -371,7 +371,7 @@ MutationResult CentipedeCallbacks::MutateViaExternalBinary( inputs_blobseq_.ReleaseSharedMemory(); // Inputs are already consumed. if (retval != EXIT_SUCCESS) { - LOG(WARNING) << "Custom mutator failed with exit code: " << retval; + FUZZTEST_LOG(WARNING) << "Custom mutator failed with exit code: " << retval; } if (env_.print_runner_log || retval != EXIT_SUCCESS) { PrintExecutionLog(); @@ -382,7 +382,7 @@ MutationResult CentipedeCallbacks::MutateViaExternalBinary( result.Read(num_mutants, outputs_blobseq_); outputs_blobseq_.ReleaseSharedMemory(); // Outputs are already consumed. - VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time); + FUZZTEST_VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time); return result; } @@ -398,43 +398,44 @@ size_t CentipedeCallbacks::LoadDictionary(std::string_view dictionary_path) { env_.use_legacy_default_mutator ? byte_array_mutator_.AddToDictionary(entries) : fuzztest_mutator_.AddToDictionary(entries); - LOG(INFO) << "Loaded " << entries.size() - << " dictionary entries from AFL/libFuzzer dictionary " - << dictionary_path; + FUZZTEST_LOG(INFO) << "Loaded " << entries.size() + << " dictionary entries from AFL/libFuzzer dictionary " + << dictionary_path; return entries.size(); } // Didn't parse as plain text. Assume encoded corpus format. auto reader = DefaultBlobFileReaderFactory(); - CHECK_OK(reader->Open(dictionary_path)) + FUZZTEST_CHECK_OK(reader->Open(dictionary_path)) << "Error in opening dictionary file: " << dictionary_path; std::vector unpacked_dictionary; ByteSpan blob; while (reader->Read(blob).ok()) { unpacked_dictionary.emplace_back(blob.begin(), blob.end()); } - CHECK_OK(reader->Close()) + FUZZTEST_CHECK_OK(reader->Close()) << "Error in closing dictionary file: " << dictionary_path; - CHECK(!unpacked_dictionary.empty()) + FUZZTEST_CHECK(!unpacked_dictionary.empty()) << "Empty or corrupt dictionary file: " << dictionary_path; env_.use_legacy_default_mutator ? byte_array_mutator_.AddToDictionary(unpacked_dictionary) : fuzztest_mutator_.AddToDictionary(unpacked_dictionary); - LOG(INFO) << "Loaded " << unpacked_dictionary.size() - << " dictionary entries from " << dictionary_path; + FUZZTEST_LOG(INFO) << "Loaded " << unpacked_dictionary.size() + << " dictionary entries from " << dictionary_path; return unpacked_dictionary.size(); } void CentipedeCallbacks::PrintExecutionLog() const { if (!std::filesystem::exists(execute_log_path_)) { - LOG(WARNING) << "Log file for the last executed binary does not exist: " - << execute_log_path_; + FUZZTEST_LOG(WARNING) + << "Log file for the last executed binary does not exist: " + << execute_log_path_; return; } std::string log_text; ReadFromLocalFile(execute_log_path_, log_text); for (const auto &log_line : absl::StrSplit(absl::StripAsciiWhitespace(log_text), '\n')) { - LOG(INFO).NoPrefix() << "LOG: " << log_line; + FUZZTEST_LOG(INFO).NoPrefix() << "FUZZTEST_LOG: " << log_line; } } diff --git a/centipede/centipede_callbacks.h b/centipede/centipede_callbacks.h index 57b9aab4e..94d8ec543 100644 --- a/centipede/centipede_callbacks.h +++ b/centipede/centipede_callbacks.h @@ -22,7 +22,6 @@ #include #include "absl/base/nullability.h" -#include "absl/log/check.h" #include "absl/status/statusor.h" #include "./centipede/binary_info.h" #include "./centipede/byte_array_mutator.h" @@ -54,9 +53,9 @@ class CentipedeCallbacks { outputs_blobseq_(shmem_name2_.c_str(), env.shmem_size_mb << 20, env.use_posix_shmem) { if (env.use_legacy_default_mutator) - CHECK(byte_array_mutator_.set_max_len(env.max_len)); + FUZZTEST_CHECK(byte_array_mutator_.set_max_len(env.max_len)); else - CHECK(fuzztest_mutator_.set_max_len(env.max_len)); + FUZZTEST_CHECK(fuzztest_mutator_.set_max_len(env.max_len)); } virtual ~CentipedeCallbacks() {} diff --git a/centipede/centipede_default_callbacks.cc b/centipede/centipede_default_callbacks.cc index 20b2efa25..ee54c2aea 100644 --- a/centipede/centipede_default_callbacks.cc +++ b/centipede/centipede_default_callbacks.cc @@ -21,8 +21,6 @@ #include #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "./centipede/centipede_callbacks.h" @@ -42,7 +40,7 @@ CentipedeDefaultCallbacks::CentipedeDefaultCallbacks(const Environment &env) } if (env_.has_input_wildcards) { - LOG(INFO) << "Disabling custom mutator for standalone target"; + FUZZTEST_LOG(INFO) << "Disabling custom mutator for standalone target"; custom_mutator_is_usable_ = false; } } @@ -85,29 +83,33 @@ std::vector CentipedeDefaultCallbacks::Mutate( if (!custom_mutator_is_usable_.has_value()) { custom_mutator_is_usable_ = result.has_custom_mutator(); if (*custom_mutator_is_usable_) { - LOG(INFO) << "Custom mutator detected; will use it."; + FUZZTEST_LOG(INFO) << "Custom mutator detected; will use it."; } else { - LOG(INFO) << "Custom mutator not detected; falling back to the " - "built-in mutator."; + FUZZTEST_LOG(INFO) + << "Custom mutator not detected; falling back to the " + "built-in mutator."; } } if (*custom_mutator_is_usable_) { // TODO(b/398261908): Exit with failure instead of crashing. - CHECK(result.has_custom_mutator()) + FUZZTEST_CHECK(result.has_custom_mutator()) << "Test binary no longer has a custom mutator, even though it was " "previously detected."; if (!result.mutants().empty()) return std::move(result).mutants(); - LOG_FIRST_N(WARNING, 5) << "Custom mutator returned no mutants; will " - "generate some using the built-in mutator."; + FUZZTEST_LOG_FIRST_N(WARNING, 5) + << "Custom mutator returned no mutants; will " + "generate some using the built-in mutator."; } } else if (ShouldStop()) { - LOG(WARNING) << "Custom mutator failed, but ignored since the stop " - "condition it met. Possibly what triggered the stop " - "condition also interrupted the mutator."; + FUZZTEST_LOG(WARNING) + << "Custom mutator failed, but ignored since the stop " + "condition it met. Possibly what triggered the stop " + "condition also interrupted the mutator."; // Returning whatever mutants we got before the failure. return std::move(result).mutants(); } else { - LOG(ERROR) << "Test binary failed when asked to mutate inputs - exiting."; + FUZZTEST_LOG(ERROR) + << "Test binary failed when asked to mutate inputs - exiting."; RequestEarlyStop(EXIT_FAILURE); return {}; } diff --git a/centipede/centipede_interface.cc b/centipede/centipede_interface.cc index 77b7a2d20..1e74b45af 100644 --- a/centipede/centipede_interface.cc +++ b/centipede/centipede_interface.cc @@ -33,8 +33,6 @@ #include "absl/base/optimization.h" #include "absl/cleanup/cleanup.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "absl/strings/ascii.h" @@ -85,7 +83,7 @@ void SetSignalHandlers() { sigact.sa_flags = SA_ONSTACK; sigact.sa_handler = [](int received_signum) { if (received_signum == SIGINT) { - LOG(INFO) << "Ctrl-C pressed: winding down"; + FUZZTEST_LOG(INFO) << "Ctrl-C pressed: winding down"; RequestEarlyStop(EXIT_FAILURE); return; } @@ -102,11 +100,11 @@ int ForEachBlob(const Environment &env) { std::string tmpfile = std::filesystem::path(tmpdir).append("t"); for (const auto &arg : env.args) { - LOG(INFO) << "Running '" << env.for_each_blob << "' on " << arg; + FUZZTEST_LOG(INFO) << "Running '" << env.for_each_blob << "' on " << arg; auto blob_reader = DefaultBlobFileReaderFactory(); absl::Status open_status = blob_reader->Open(arg); if (!open_status.ok()) { - LOG(INFO) << "Failed to open " << arg << ": " << open_status; + FUZZTEST_LOG(INFO) << "Failed to open " << arg << ": " << open_status; return EXIT_FAILURE; } ByteSpan blob; @@ -132,8 +130,8 @@ int ForEachBlob(const Environment &env) { // provided, analyzes differences. If there is one arg provided, reports the // function coverage. Returns EXIT_SUCCESS on success, EXIT_FAILURE otherwise. int Analyze(const Environment &env) { - LOG(INFO) << "Analyze " << absl::StrJoin(env.args, ","); - CHECK(!env.binary.empty()) << "--binary must be used"; + FUZZTEST_LOG(INFO) << "Analyze " << absl::StrJoin(env.args, ","); + FUZZTEST_CHECK(!env.binary.empty()) << "--binary must be used"; if (env.args.size() == 1) { const CoverageResults coverage_results = GetCoverage(env.binary_name, env.binary_hash, env.args[0]); @@ -145,8 +143,9 @@ int Analyze(const Environment &env) { AnalyzeCorporaToLog(env.binary_name, env.binary_hash, env.args[0], env.args[1]); } else { - LOG(FATAL) << "for now, --analyze supports only 1 or 2 work dirs; got " - << env.args.size(); + FUZZTEST_LOG(FATAL) + << "for now, --analyze supports only 1 or 2 work dirs; got " + << env.args.size(); } return EXIT_SUCCESS; } @@ -167,8 +166,8 @@ BinaryInfo PopulateBinaryInfoAndSavePCsIfNecessary( } if (env.save_binary_info) { const std::string binary_info_dir = WorkDir{env}.BinaryInfoDirPath(); - CHECK_OK(RemoteMkdir(binary_info_dir)); - LOG(INFO) << "Serializing binary info to: " << binary_info_dir; + FUZZTEST_CHECK_OK(RemoteMkdir(binary_info_dir)); + FUZZTEST_LOG(INFO) << "Serializing binary info to: " << binary_info_dir; binary_info.Write(binary_info_dir); } if (binary_info.uses_legacy_trace_pc_instrumentation) { @@ -176,7 +175,7 @@ BinaryInfo PopulateBinaryInfoAndSavePCsIfNecessary( SavePCTableToFile(binary_info.pc_table, pcs_file_path); } if (env.use_pcpair_features) { - CHECK(!binary_info.pc_table.empty()) + FUZZTEST_CHECK(!binary_info.pc_table.empty()) << "--use_pcpair_features requires non-empty pc_table"; } return binary_info; @@ -215,7 +214,7 @@ int Fuzz(const Environment &env, const BinaryInfo &binary_info, return absl::Minutes(std::clamp(iteration, 0UL, 10UL)); }, }); - if (!envs.front().experiment.empty() || ABSL_VLOG_IS_ON(1)) { + if (!envs.front().experiment.empty() || FUZZTEST_VLOG_IS_ON(1)) { stats_reporters.emplace_back( [logger = StatsLogger{stats_vec, envs}]() mutable { logger.ReportCurrStats(); @@ -303,7 +302,8 @@ absl::flat_hash_set PruneOldCrashesAndGetRemainingCrashSignatures( for (const std::string &crashing_input_file : crashing_input_files) { ByteArray crashing_input; - CHECK_OK(RemoteFileGetContents(crashing_input_file, crashing_input)); + FUZZTEST_CHECK_OK( + RemoteFileGetContents(crashing_input_file, crashing_input)); const bool is_reproducible = !scoped_callbacks.callbacks()->Execute( env.binary, {crashing_input}, batch_result); const bool is_duplicate = @@ -311,9 +311,10 @@ absl::flat_hash_set PruneOldCrashesAndGetRemainingCrashSignatures( !remaining_crash_signatures.insert(batch_result.failure_signature()) .second; if (!is_reproducible || batch_result.IsSetupFailure() || is_duplicate) { - CHECK_OK(RemotePathDelete(crashing_input_file, /*recursively=*/false)); + FUZZTEST_CHECK_OK( + RemotePathDelete(crashing_input_file, /*recursively=*/false)); } else { - CHECK_OK(RemotePathTouchExistingFile(crashing_input_file)); + FUZZTEST_CHECK_OK(RemotePathTouchExistingFile(crashing_input_file)); } } return remaining_crash_signatures; @@ -334,7 +335,7 @@ void DeduplicateAndStoreNewCrashes( const std::filesystem::path crash_metadata_dir = workdir.CrashMetadataDirPaths().Shard(shard_idx); - CHECK_OK(RemoteMkdir(crashing_dir.c_str())); + FUZZTEST_CHECK_OK(RemoteMkdir(crashing_dir.c_str())); for (const std::string &crashing_input_file : new_crashing_input_files) { const std::string crashing_input_file_name = std::filesystem::path(crashing_input_file).filename(); @@ -344,15 +345,15 @@ void DeduplicateAndStoreNewCrashes( const absl::Status status = RemoteFileGetContents(crash_signature_path, new_crash_signature); if (!status.ok()) { - LOG(WARNING) << "Ignoring crashing input " << crashing_input_file_name - << " due to failure to read the crash signature: " - << status; + FUZZTEST_LOG(WARNING) + << "Ignoring crashing input " << crashing_input_file_name + << " due to failure to read the crash signature: " << status; continue; } const bool is_duplicate = !crash_signatures.insert(new_crash_signature).second; if (is_duplicate) continue; - CHECK_OK( + FUZZTEST_CHECK_OK( RemoteFileRename(crashing_input_file, (crashing_dir / crashing_input_file_name).c_str())); } @@ -401,12 +402,13 @@ SeedCorpusConfig GetSeedCorpusConfig(const Environment &env, absl::Duration ReadFuzzingTime(std::string_view fuzzing_time_file) { std::string fuzzing_time_str; - CHECK_OK(RemoteFileGetContents(fuzzing_time_file, fuzzing_time_str)); + FUZZTEST_CHECK_OK(RemoteFileGetContents(fuzzing_time_file, fuzzing_time_str)); absl::Duration fuzzing_time; if (!absl::ParseDuration(absl::StripAsciiWhitespace(fuzzing_time_str), &fuzzing_time)) { - LOG(WARNING) << "Failed to parse fuzzing time of a resuming fuzz test: '" - << fuzzing_time_str << "'. Assuming no fuzzing time so far."; + FUZZTEST_LOG(WARNING) + << "Failed to parse fuzzing time of a resuming fuzz test: '" + << fuzzing_time_str << "'. Assuming no fuzzing time so far."; return absl::ZeroDuration(); } return fuzzing_time; @@ -418,7 +420,7 @@ PeriodicAction RecordFuzzingTime(std::string_view fuzzing_time_file, absl::Status status = RemoteFileSetContents( fuzzing_time_file, absl::FormatDuration(absl::Now() - start_time)); - LOG_IF(WARNING, !status.ok()) + FUZZTEST_LOG_IF(WARNING, !status.ok()) << "Failed to write fuzzing time: " << status; }, PeriodicAction::ZeroDelayConstInterval(absl::Seconds(15))}; @@ -431,9 +433,10 @@ int UpdateCorpusDatabaseForFuzzTests( env.UpdateWithTargetConfig(fuzztest_config); absl::Time start_time = absl::Now(); - LOG(INFO) << "Starting the update of the corpus database for fuzz tests:" - << "\nBinary: " << env.binary - << "\nCorpus database: " << fuzztest_config.corpus_database; + FUZZTEST_LOG(INFO) + << "Starting the update of the corpus database for fuzz tests:" + << "\nBinary: " << env.binary + << "\nCorpus database: " << fuzztest_config.corpus_database; // Step 1: Preliminary set up of test sharding, binary info, etc. const auto [test_shard_index, total_test_shards] = SetUpTestSharding(); @@ -457,7 +460,7 @@ int UpdateCorpusDatabaseForFuzzTests( }(); std::vector fuzz_tests_to_run; if (env.fuzztest_single_test_mode) { - CHECK(fuzztest_config.fuzz_tests_in_current_shard.size() == 1) + FUZZTEST_CHECK(fuzztest_config.fuzz_tests_in_current_shard.size() == 1) << "Must select exactly one fuzz test when running in the single test " "mode"; fuzz_tests_to_run = fuzztest_config.fuzz_tests_in_current_shard; @@ -468,10 +471,11 @@ int UpdateCorpusDatabaseForFuzzTests( } } } - LOG(INFO) << "Fuzz tests to run:" << absl::StrJoin(fuzz_tests_to_run, ", "); + FUZZTEST_LOG(INFO) << "Fuzz tests to run:" + << absl::StrJoin(fuzz_tests_to_run, ", "); const bool is_workdir_specified = !env.workdir.empty(); - CHECK(!is_workdir_specified || env.fuzztest_single_test_mode); + FUZZTEST_CHECK(!is_workdir_specified || env.fuzztest_single_test_mode); // When env.workdir is empty, the full workdir paths will be formed by // appending the fuzz test names to the base workdir path. We use different // path when only replaying to avoid replaying an unfinished fuzzing sessions. @@ -489,8 +493,8 @@ int UpdateCorpusDatabaseForFuzzTests( BinaryInfo binary_info = PopulateBinaryInfoAndSavePCsIfNecessary( env, callbacks_factory, pcs_file_path); - LOG(INFO) << "Test shard index: " << test_shard_index - << " Total test shards: " << total_test_shards; + FUZZTEST_LOG(INFO) << "Test shard index: " << test_shard_index + << " Total test shards: " << total_test_shards; // Step 2: Iterate over the fuzz tests and run them. const std::string binary = env.binary; @@ -504,7 +508,7 @@ int UpdateCorpusDatabaseForFuzzTests( const absl::Status has_enough_time = VerifyBazelHasEnoughTimeToRunTest( start_time, test_time_limit, /*executed_tests_in_shard=*/i, fuzztest_config.fuzz_tests.size()); - CHECK_OK(has_enough_time) + FUZZTEST_CHECK_OK(has_enough_time) << "Not enough time for running the fuzz test " << fuzz_tests_to_run[i] << " for " << test_time_limit; } @@ -521,39 +525,41 @@ int UpdateCorpusDatabaseForFuzzTests( // Use the execution IDs to resume or skip tests. const bool execution_id_matched = [&] { if (!RemotePathExists(execution_id_path)) return false; - CHECK(!RemotePathIsDirectory(execution_id_path)); + FUZZTEST_CHECK(!RemotePathIsDirectory(execution_id_path)); std::string prev_execution_id; - CHECK_OK(RemoteFileGetContents(execution_id_path, prev_execution_id)); + FUZZTEST_CHECK_OK( + RemoteFileGetContents(execution_id_path, prev_execution_id)); return prev_execution_id == *fuzztest_config.execution_id; }(); if (execution_id_matched) { // If execution IDs match but the previous coverage is missing, it means // the test was previously finished, and we skip running for the test. if (!RemotePathExists(WorkDir{env}.CoverageDirPath())) { - LOG(INFO) << "Skipping running the fuzz test " - << fuzz_tests_to_run[i]; + FUZZTEST_LOG(INFO) + << "Skipping running the fuzz test " << fuzz_tests_to_run[i]; continue; } // If execution IDs match and the previous coverage exists, it means // the same workflow got interrupted when running the test. So we resume // the test. is_resuming = true; - LOG(INFO) << "Resuming running the fuzz test " << fuzz_tests_to_run[i]; + FUZZTEST_LOG(INFO) << "Resuming running the fuzz test " + << fuzz_tests_to_run[i]; } else { // If the execution IDs mismatch, we start a new run. is_resuming = false; - LOG(INFO) << "Starting a new run of the fuzz test " - << fuzz_tests_to_run[i]; + FUZZTEST_LOG(INFO) << "Starting a new run of the fuzz test " + << fuzz_tests_to_run[i]; } } if (RemotePathExists(env.workdir) && !is_resuming) { // This could be a workdir from a failed run that used a different version // of the binary. We delete it so that we don't have to deal with // the assumptions under which it is safe to reuse an old workdir. - CHECK_OK(RemotePathDelete(env.workdir, /*recursively=*/true)); + FUZZTEST_CHECK_OK(RemotePathDelete(env.workdir, /*recursively=*/true)); } const WorkDir workdir{env}; - CHECK_OK(RemoteMkdir( + FUZZTEST_CHECK_OK(RemoteMkdir( workdir.CoverageDirPath())); // Implicitly creates the workdir // Updating execution ID must be after creating the coverage dir. Otherwise @@ -561,13 +567,13 @@ int UpdateCorpusDatabaseForFuzzTests( // attempt would skip this test. if (!is_workdir_specified && fuzztest_config.execution_id.has_value() && !is_resuming) { - CHECK_OK(RemoteFileSetContents(execution_id_path, - *fuzztest_config.execution_id)); + FUZZTEST_CHECK_OK(RemoteFileSetContents(execution_id_path, + *fuzztest_config.execution_id)); } absl::Cleanup clean_up_workdir = [is_workdir_specified, &env] { if (!is_workdir_specified && !EarlyStopRequested()) { - CHECK_OK(RemotePathDelete(env.workdir, /*recursively=*/true)); + FUZZTEST_CHECK_OK(RemotePathDelete(env.workdir, /*recursively=*/true)); } }; @@ -580,7 +586,7 @@ int UpdateCorpusDatabaseForFuzzTests( // Seed the fuzzing session with the latest coverage corpus and regression // inputs from the previous fuzzing session. if (!is_resuming) { - CHECK_OK(GenerateSeedCorpusFromConfig( + FUZZTEST_CHECK_OK(GenerateSeedCorpusFromConfig( GetSeedCorpusConfig(env, regression_dir.c_str(), fuzztest_config.replay_coverage_inputs ? coverage_dir.c_str() @@ -612,14 +618,15 @@ int UpdateCorpusDatabaseForFuzzTests( is_resuming = false; if (EarlyStopRequested()) { - LOG(INFO) << "Skipping test " << fuzz_tests_to_run[i] - << " because early stop requested."; + FUZZTEST_LOG(INFO) << "Skipping test " << fuzz_tests_to_run[i] + << " because early stop requested."; continue; } - LOG(INFO) << (fuzztest_config.only_replay ? "Replaying " : "Fuzzing ") - << fuzz_tests_to_run[i] << " for " << time_limit - << "\n\tTest binary: " << env.binary; + FUZZTEST_LOG(INFO) << (fuzztest_config.only_replay ? "Replaying " + : "Fuzzing ") + << fuzz_tests_to_run[i] << " for " << time_limit + << "\n\tTest binary: " << env.binary; const absl::Time start_time = absl::Now(); ClearEarlyStopRequestAndSetStopTime(/*stop_time=*/start_time + time_limit); @@ -631,15 +638,16 @@ int UpdateCorpusDatabaseForFuzzTests( if (!stats_root_path.empty()) { const auto stats_dir = stats_root_path / fuzz_tests_to_run[i]; - CHECK_OK(RemoteMkdir(stats_dir.c_str())); - CHECK_OK(RemoteFileRename( + FUZZTEST_CHECK_OK(RemoteMkdir(stats_dir.c_str())); + FUZZTEST_CHECK_OK(RemoteFileRename( workdir.FuzzingStatsPath(), (stats_dir / absl::StrCat("fuzzing_stats_", execution_stamp)) .c_str())); } if (EarlyStopRequested()) { - LOG(INFO) << "Skip updating corpus database due to early stop requested."; + FUZZTEST_LOG(INFO) + << "Skip updating corpus database due to early stop requested."; continue; } @@ -652,16 +660,18 @@ int UpdateCorpusDatabaseForFuzzTests( if (RemotePathExists(coverage_dir.c_str())) { // In the future, we will store k latest coverage corpora for some k, but // for now we only keep the latest one. - CHECK_OK(RemotePathDelete(coverage_dir.c_str(), /*recursively=*/true)); + FUZZTEST_CHECK_OK( + RemotePathDelete(coverage_dir.c_str(), /*recursively=*/true)); } - CHECK_OK(RemoteMkdir(coverage_dir.c_str())); + FUZZTEST_CHECK_OK(RemoteMkdir(coverage_dir.c_str())); std::vector distilled_corpus_files; - CHECK_OK(RemoteGlobMatch(workdir.DistilledCorpusFilePaths().AllShardsGlob(), - distilled_corpus_files)); + FUZZTEST_CHECK_OK( + RemoteGlobMatch(workdir.DistilledCorpusFilePaths().AllShardsGlob(), + distilled_corpus_files)); for (const std::string &corpus_file : distilled_corpus_files) { const std::string file_name = std::filesystem::path(corpus_file).filename(); - CHECK_OK( + FUZZTEST_CHECK_OK( RemoteFileRename(corpus_file, (coverage_dir / file_name).c_str())); } @@ -679,9 +689,9 @@ int UpdateCorpusDatabaseForFuzzTests( int ListCrashIds(const Environment &env, const fuzztest::internal::Configuration &target_config) { - CHECK(!env.list_crash_ids_file.empty()) + FUZZTEST_CHECK(!env.list_crash_ids_file.empty()) << "Need list_crash_ids_file to be set for listing crash IDs"; - CHECK_EQ(target_config.fuzz_tests_in_current_shard.size(), 1); + FUZZTEST_CHECK_EQ(target_config.fuzz_tests_in_current_shard.size(), 1); std::vector crash_paths; // TODO: b/406003594 - move the path construction to a library. const auto crash_dir = std::filesystem::path(target_config.corpus_database) / @@ -689,7 +699,7 @@ int ListCrashIds(const Environment &env, target_config.fuzz_tests_in_current_shard[0] / "crashing"; if (RemotePathExists(crash_dir.string())) { - CHECK(RemotePathIsDirectory(crash_dir.string())) + FUZZTEST_CHECK(RemotePathIsDirectory(crash_dir.string())) << "Crash dir " << crash_dir << " in the corpus database " << target_config.corpus_database << " is not a directory"; crash_paths = @@ -701,16 +711,17 @@ int ListCrashIds(const Environment &env, std::string crash_id = std::filesystem::path{crash_path}.filename(); results.push_back(std::move(crash_id)); } - CHECK_OK(RemoteFileSetContents(env.list_crash_ids_file, - absl::StrJoin(results, "\n"))); + FUZZTEST_CHECK_OK(RemoteFileSetContents(env.list_crash_ids_file, + absl::StrJoin(results, "\n"))); return EXIT_SUCCESS; } int ReplayCrash(const Environment &env, const fuzztest::internal::Configuration &target_config, CentipedeCallbacksFactory &callbacks_factory) { - CHECK(!env.crash_id.empty()) << "Need crash_id to be set for replay a crash"; - CHECK(target_config.fuzz_tests_in_current_shard.size() == 1) + FUZZTEST_CHECK(!env.crash_id.empty()) + << "Need crash_id to be set for replay a crash"; + FUZZTEST_CHECK(target_config.fuzz_tests_in_current_shard.size() == 1) << "Expecting exactly one test for replay_crash"; // TODO: b/406003594 - move the path construction to a library. const auto crash_dir = std::filesystem::path(target_config.corpus_database) / @@ -732,8 +743,8 @@ int ReplayCrash(const Environment &env, .filename(), /*shard_index_digits=*/WorkDir::kDigitsInShardIndex, /*num_shards=*/1}}; - CHECK_OK(GenerateSeedCorpusFromConfig(crash_corpus_config, env.binary_name, - env.binary_hash)); + FUZZTEST_CHECK_OK(GenerateSeedCorpusFromConfig( + crash_corpus_config, env.binary_name, env.binary_hash)); Environment run_crash_env = env; run_crash_env.load_shards_only = true; return Fuzz(run_crash_env, {}, "", callbacks_factory); @@ -741,11 +752,11 @@ int ReplayCrash(const Environment &env, int ExportCrash(const Environment &env, const fuzztest::internal::Configuration &target_config) { - CHECK(!env.crash_id.empty()) + FUZZTEST_CHECK(!env.crash_id.empty()) << "Need crash_id to be set for exporting a crash"; - CHECK(!env.export_crash_file.empty()) + FUZZTEST_CHECK(!env.export_crash_file.empty()) << "Need export_crash_file to be set for exporting a crash"; - CHECK(target_config.fuzz_tests_in_current_shard.size() == 1) + FUZZTEST_CHECK(target_config.fuzz_tests_in_current_shard.size() == 1) << "Expecting exactly one test for exporting a crash"; // TODO: b/406003594 - move the path construction to a library. const auto crash_dir = std::filesystem::path(target_config.corpus_database) / @@ -756,15 +767,15 @@ int ExportCrash(const Environment &env, const auto read_status = RemoteFileGetContents((crash_dir / env.crash_id).c_str(), crash_contents); if (!read_status.ok()) { - LOG(ERROR) << "Failed reading the crash " << env.crash_id << " from " - << crash_dir.c_str() << ": " << read_status; + FUZZTEST_LOG(ERROR) << "Failed reading the crash " << env.crash_id + << " from " << crash_dir.c_str() << ": " << read_status; return EXIT_FAILURE; } const auto write_status = RemoteFileSetContents(env.export_crash_file, crash_contents); if (!write_status.ok()) { - LOG(ERROR) << "Failed write the crash " << env.crash_id << " to " - << env.export_crash_file << ": " << write_status; + FUZZTEST_LOG(ERROR) << "Failed write the crash " << env.crash_id << " to " + << env.export_crash_file << ": " << write_status; return EXIT_FAILURE; } return EXIT_SUCCESS; @@ -785,7 +796,8 @@ int CentipedeMain(const Environment &env, if (!env.crashes_to_files.empty()) { const auto status = Centipede::CrashesToFiles(env, env.crashes_to_files); if (status.ok()) return EXIT_SUCCESS; - LOG(ERROR) << "Got error when exporting crashes to files: " << status; + FUZZTEST_LOG(ERROR) << "Got error when exporting crashes to files: " + << status; return EXIT_FAILURE; } @@ -830,21 +842,22 @@ int CentipedeMain(const Environment &env, // to the unified execution model. if (!env.fuzztest_configuration.empty()) { std::string result; - CHECK(absl::WebSafeBase64Unescape(env.fuzztest_configuration, &result)); + FUZZTEST_CHECK( + absl::WebSafeBase64Unescape(env.fuzztest_configuration, &result)); return result; } ScopedCentipedeCallbacks scoped_callbacks(callbacks_factory, env); return scoped_callbacks.callbacks()->GetSerializedTargetConfig(); }(); - CHECK_OK(serialized_target_config.status()); + FUZZTEST_CHECK_OK(serialized_target_config.status()); if (!serialized_target_config->empty()) { const auto target_config = fuzztest::internal::Configuration::Deserialize( *serialized_target_config); - CHECK_OK(target_config.status()) + FUZZTEST_CHECK_OK(target_config.status()) << "Failed to deserialize target configuration"; if (!target_config->corpus_database.empty()) { - LOG_IF(FATAL, - env.list_crash_ids + env.replay_crash + env.export_crash > 1) + FUZZTEST_LOG_IF( + FATAL, env.list_crash_ids + env.replay_crash + env.export_crash > 1) << "At most one of list_crash_ids/replay_crash/export_crash can " "be set, but seeing list_crash_ids: " << env.list_crash_ids << ", replay_crash: " << env.replay_crash @@ -860,11 +873,11 @@ int CentipedeMain(const Environment &env, } const auto time_limit_per_test = target_config->GetTimeLimitPerTest(); - CHECK(target_config->only_replay || - time_limit_per_test < absl::InfiniteDuration()) + FUZZTEST_CHECK(target_config->only_replay || + time_limit_per_test < absl::InfiniteDuration()) << "Updating corpus database requires specifying time limit per " "fuzz test."; - CHECK(time_limit_per_test >= absl::Seconds(1)) + FUZZTEST_CHECK(time_limit_per_test >= absl::Seconds(1)) << "Time limit per fuzz test must be at least 1 second."; return UpdateCorpusDatabaseForFuzzTests(env, *target_config, callbacks_factory); @@ -874,9 +887,9 @@ int CentipedeMain(const Environment &env, // Create the remote coverage dirs once, before creating any threads. const auto coverage_dir = WorkDir{env}.CoverageDirPath(); - CHECK_OK(RemoteMkdir(coverage_dir)); - LOG(INFO) << "Coverage dir: " << coverage_dir - << "; temporary dir: " << tmpdir; + FUZZTEST_CHECK_OK(RemoteMkdir(coverage_dir)); + FUZZTEST_LOG(INFO) << "Coverage dir: " << coverage_dir + << "; temporary dir: " << tmpdir; std::string pcs_file_path; BinaryInfo binary_info = PopulateBinaryInfoAndSavePCsIfNecessary( diff --git a/centipede/centipede_test.cc b/centipede/centipede_test.cc index c66e7ab22..b048e6e6b 100644 --- a/centipede/centipede_test.cc +++ b/centipede/centipede_test.cc @@ -31,8 +31,6 @@ #include "gtest/gtest.h" #include "absl/base/nullability.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/str_cat.h" #include "absl/time/time.h" #include "./centipede/centipede_callbacks.h" @@ -360,14 +358,14 @@ class MutateCallbacks : public CentipedeCallbacks { // Will not be called. bool Execute(std::string_view binary, const std::vector &inputs, BatchResult &batch_result) override { - CHECK(false); + FUZZTEST_CHECK(false); return false; } // Will not be called. std::vector Mutate(const std::vector &inputs, size_t num_mutants) override { - CHECK(false); + FUZZTEST_CHECK(false); } // Redeclare a protected member function as public so the tests can call it. @@ -505,7 +503,7 @@ class MergeMock : public CentipedeCallbacks { BatchResult &batch_result) override { batch_result.results().resize(inputs.size()); for (size_t i = 0, n = inputs.size(); i < n; ++i) { - CHECK_EQ(inputs[i].size(), 1); + FUZZTEST_CHECK_EQ(inputs[i].size(), 1); batch_result.results()[i].mutable_features() = {inputs[i][0]}; } return true; @@ -582,8 +580,10 @@ class FunctionFilterMock : public CentipedeCallbacks { : CentipedeCallbacks(env) { std::vector seed_inputs; const size_t num_seeds_available = GetSeeds(/*num_seeds=*/1, seed_inputs); - CHECK_EQ(num_seeds_available, 1) << "Default seeds must have size one."; - CHECK_EQ(seed_inputs.size(), 1) << "Default seeds must have size one."; + FUZZTEST_CHECK_EQ(num_seeds_available, 1) + << "Default seeds must have size one."; + FUZZTEST_CHECK_EQ(seed_inputs.size(), 1) + << "Default seeds must have size one."; seed_inputs_.insert(seed_inputs.begin(), seed_inputs.end()); } @@ -646,7 +646,7 @@ static std::vector RunWithFunctionFilter( FunctionFilterMock mock(env); MockFactory factory(mock); CentipedeMain(env, factory); - LOG(INFO) << mock.observed_inputs_.size(); + FUZZTEST_LOG(INFO) << mock.observed_inputs_.size(); std::vector res(mock.observed_inputs_.begin(), mock.observed_inputs_.end()); std::sort(res.begin(), res.end()); @@ -808,7 +808,7 @@ class UndetectedCrashingInputMock : public CentipedeCallbacks { explicit UndetectedCrashingInputMock(const Environment &env, size_t crashing_input_idx) : CentipedeCallbacks{env}, crashing_input_idx_{crashing_input_idx} { - CHECK_LE(crashing_input_idx_, std::numeric_limits::max()); + FUZZTEST_CHECK_LE(crashing_input_idx_, std::numeric_limits::max()); } // Doesn't execute anything. @@ -822,7 +822,7 @@ class UndetectedCrashingInputMock : public CentipedeCallbacks { num_inputs_triaged_ += inputs.size(); } for (const auto &input : inputs) { - CHECK_EQ(input.size(), 1); // By construction in `Mutate()`. + FUZZTEST_CHECK_EQ(input.size(), 1); // By construction in `Mutate()`. // The contents of each mutant is its sequential number. if (input[0] == crashing_input_idx_) { if (first_pass_) { @@ -881,8 +881,8 @@ TEST(Centipede, UndetectedCrashingInput) { constexpr size_t kCrashingInputIdx = (kNumBatches / 2) * kBatchSize + kCrashingInputIdxInBatch; - LOG(INFO) << VV(kNumBatches) << VV(kBatchSize) - << VV(kCrashingInputIdxInBatch) VV(kCrashingInputIdx); + FUZZTEST_LOG(INFO) << VV(kNumBatches) << VV(kBatchSize) + << VV(kCrashingInputIdxInBatch) VV(kCrashingInputIdx); TempDir temp_dir{test_info_->name()}; Environment env; diff --git a/centipede/command.cc b/centipede/command.cc index d533bde36..c5d7fd88c 100644 --- a/centipede/command.cc +++ b/centipede/command.cc @@ -37,8 +37,6 @@ #include #include "absl/base/const_init.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "absl/strings/match.h" @@ -125,13 +123,14 @@ struct Command::ForkServerProps { ~ForkServerProps() { for (int i = 0; i < 2; ++i) { if (pipe_[i] >= 0 && close(pipe_[i]) != 0) { - LOG(ERROR) << "Failed to close fork server pipe for " << fifo_path_[i]; + FUZZTEST_LOG(ERROR) + << "Failed to close fork server pipe for " << fifo_path_[i]; } std::error_code ec; if (!fifo_path_[i].empty() && !std::filesystem::remove(fifo_path_[i], ec)) { - LOG(ERROR) << "Failed to remove fork server pipe file " << fifo_path_[i] - << ": " << ec; + FUZZTEST_LOG(ERROR) << "Failed to remove fork server pipe file " + << fifo_path_[i] << ": " << ec; } } } @@ -171,7 +170,7 @@ std::string Command::ToString() const { // Replace @@ with temp_file_path_. constexpr std::string_view kTempFileWildCard = "@@"; if (absl::StrContains(path, kTempFileWildCard)) { - CHECK(!options_.temp_file_path.empty()); + FUZZTEST_CHECK(!options_.temp_file_path.empty()); path = absl::StrReplaceAll(path, {{kTempFileWildCard, options_.temp_file_path}}); } @@ -198,10 +197,10 @@ std::string Command::ToString() const { bool Command::StartForkServer(std::string_view temp_dir_path, std::string_view prefix) { if (absl::StartsWith(path_, kNoForkServerRequestPrefix)) { - VLOG(2) << "Fork server disabled for " << path(); + FUZZTEST_VLOG(2) << "Fork server disabled for " << path(); return false; } - VLOG(2) << "Starting fork server for " << path(); + FUZZTEST_VLOG(2) << "Starting fork server for " << path(); fork_server_.reset(new ForkServerProps); fork_server_->fifo_path_[0] = std::filesystem::path(temp_dir_path) @@ -212,7 +211,7 @@ bool Command::StartForkServer(std::string_view temp_dir_path, std::filesystem::path(temp_dir_path).append("pid"); (void)std::filesystem::create_directory(temp_dir_path); // it may not exist. for (int i = 0; i < 2; ++i) { - PCHECK(mkfifo(fork_server_->fifo_path_[i].c_str(), 0600) == 0) + FUZZTEST_PCHECK(mkfifo(fork_server_->fifo_path_[i].c_str(), 0600) == 0) << VV(i) << VV(fork_server_->fifo_path_[i]); } @@ -231,7 +230,7 @@ bool Command::StartForkServer(std::string_view temp_dir_path, const std::string fork_server_command = absl::StrFormat( kForkServerCommandStub, fork_server_->fifo_path_[0], fork_server_->fifo_path_[1], command_line_, pid_file_path); - VLOG(2) << "Fork server command:" << fork_server_command; + FUZZTEST_VLOG(2) << "Fork server command:" << fork_server_command; const int exit_code = system(fork_server_command.c_str()); @@ -267,7 +266,7 @@ bool Command::StartForkServer(std::string_view temp_dir_path, std::string pid_str; ReadFromLocalFile(pid_file_path, pid_str); - CHECK(absl::SimpleAtoi(pid_str, &fork_server_->pid_)) << VV(pid_str); + FUZZTEST_CHECK(absl::SimpleAtoi(pid_str, &fork_server_->pid_)) << VV(pid_str); auto creation_stamp = GetProcessCreationStamp(fork_server_->pid_); if (!creation_stamp.ok()) { LogProblemInfo( @@ -285,9 +284,10 @@ absl::Status Command::VerifyForkServerIsHealthy() { // Preconditions: the callers (`Execute()`) should call us only when the fork // server is presumed to be running (`fork_server_pid_` >= 0). If it is, the // comms pipes are guaranteed to be opened by `StartForkServer()`. - CHECK(fork_server_ != nullptr) << "Fork server wasn't started"; - CHECK(fork_server_->pid_ >= 0) << "Fork server process failed to start"; - CHECK(fork_server_->pipe_[0] >= 0 && fork_server_->pipe_[1] >= 0) + FUZZTEST_CHECK(fork_server_ != nullptr) << "Fork server wasn't started"; + FUZZTEST_CHECK(fork_server_->pid_ >= 0) + << "Fork server process failed to start"; + FUZZTEST_CHECK(fork_server_->pipe_[0] >= 0 && fork_server_->pipe_[1] >= 0) << "Failed to connect to fork server"; // A process with the fork server PID exists (_some_ process, possibly with a @@ -309,13 +309,13 @@ absl::Status Command::VerifyForkServerIsHealthy() { } int Command::Execute() { - VLOG(1) << "Executing command '" << command_line_ << "'..."; + FUZZTEST_VLOG(1) << "Executing command '" << command_line_ << "'..."; int exit_code = EXIT_SUCCESS; if (fork_server_ != nullptr) { - VLOG(1) << "Sending execution request to fork server: " - << VV(options_.timeout); + FUZZTEST_VLOG(1) << "Sending execution request to fork server: " + << VV(options_.timeout); if (const auto status = VerifyForkServerIsHealthy(); !status.ok()) { LogProblemInfo(absl::StrCat("Fork server should be running, but isn't: ", @@ -325,7 +325,7 @@ int Command::Execute() { // Wake up the fork server. char x = ' '; - CHECK_EQ(1, write(fork_server_->pipe_[0], &x, 1)); + FUZZTEST_CHECK_EQ(1, write(fork_server_->pipe_[0], &x, 1)); // The fork server forks, the child is running. Block until some readable // data appears in the pipe (that is, after the fork server writes the @@ -361,10 +361,10 @@ int Command::Execute() { } // The fork server wrote the execution result to the pipe: read it. - CHECK_EQ(sizeof(exit_code), - read(fork_server_->pipe_[1], &exit_code, sizeof(exit_code))); + FUZZTEST_CHECK_EQ(sizeof(exit_code), read(fork_server_->pipe_[1], + &exit_code, sizeof(exit_code))); } else { - VLOG(1) << "Fork server disabled - executing command directly"; + FUZZTEST_VLOG(1) << "Fork server disabled - executing command directly"; // No fork server, use system(). exit_code = system(command_line_.c_str()); } @@ -454,21 +454,21 @@ void Command::LogProblemInfo(std::string_view message) const { static absl::Mutex mu{absl::kConstInit}; absl::MutexLock lock(&mu); - LOG(ERROR) << message; - LOG(ERROR).NoPrefix() << "=== COMMAND ==="; - LOG(ERROR).NoPrefix() << command_line_; - LOG(ERROR).NoPrefix() << "=== STDOUT ==="; + FUZZTEST_LOG(ERROR) << message; + FUZZTEST_LOG(ERROR).NoPrefix() << "=== COMMAND ==="; + FUZZTEST_LOG(ERROR).NoPrefix() << command_line_; + FUZZTEST_LOG(ERROR).NoPrefix() << "=== STDOUT ==="; for (const auto &line : absl::StrSplit(ReadRedirectedStdout(), '\n')) { - LOG(ERROR).NoPrefix() << line; + FUZZTEST_LOG(ERROR).NoPrefix() << line; } - LOG(ERROR).NoPrefix() << "=== STDERR ==="; + FUZZTEST_LOG(ERROR).NoPrefix() << "=== STDERR ==="; for (const auto &line : absl::StrSplit(ReadRedirectedStderr(), '\n')) { - LOG(ERROR).NoPrefix() << line; + FUZZTEST_LOG(ERROR).NoPrefix() << line; } } void Command::VlogProblemInfo(std::string_view message, int vlog_level) const { - if (ABSL_VLOG_IS_ON(vlog_level)) LogProblemInfo(message); + if (FUZZTEST_VLOG_IS_ON(vlog_level)) LogProblemInfo(message); } } // namespace fuzztest::internal diff --git a/centipede/command.h b/centipede/command.h index 80c78779d..66095a648 100644 --- a/centipede/command.h +++ b/centipede/command.h @@ -101,8 +101,8 @@ class Command final { // by the the command line, followed by the redirected stdout and stderr read // from `options_.out` and `options_.err` files, if any. void LogProblemInfo(std::string_view message) const; - // Just as `LogCrashInfo()`, but logging occurs only when the VLOG level (set - // via `--v` or its equivalents) is >= `min_vlog`. + // Just as `LogCrashInfo()`, but logging occurs only when the FUZZTEST_VLOG + // level (set via `--v` or its equivalents) is >= `min_vlog`. void VlogProblemInfo(std::string_view message, int vlog_level) const; const std::string path_; diff --git a/centipede/command_test.cc b/centipede/command_test.cc index 3129a4103..bd7506888 100644 --- a/centipede/command_test.cc +++ b/centipede/command_test.cc @@ -24,11 +24,11 @@ #include #include "gtest/gtest.h" -#include "absl/log/log.h" #include "absl/strings/substitute.h" #include "absl/time/time.h" #include "./centipede/stop.h" #include "./centipede/util.h" +#include "./common/logging.h" #include "./common/test_util.h" namespace fuzztest::internal { @@ -96,7 +96,7 @@ TEST(CommandDeathTest, Execute) { Command self_sigint{"bash -c 'kill -SIGINT $$'"}; self_sigint.Execute(); if (ShouldStop()) { - LOG(INFO) << "Early stop requested"; + FUZZTEST_LOG(INFO) << "Early stop requested"; exit(ExitCode()); } }; diff --git a/centipede/concurrent_bitset.h b/centipede/concurrent_bitset.h index 09d1aa129..2e38d79fa 100644 --- a/centipede/concurrent_bitset.h +++ b/centipede/concurrent_bitset.h @@ -22,7 +22,7 @@ // // This library must not depend on anything other than libc so that fuzz targets // using it doesn't gain redundant coverage. For the same reason this library -// uses raw __builtin_trap instead of CHECKs. +// uses raw __builtin_trap instead of FUZZTEST_CHECKs. // We make an exception for for std::sort/std::unique, // since is very lightweight. // This library is also header-only, with all functions defined as inline. diff --git a/centipede/config_file.cc b/centipede/config_file.cc index 2b288f147..89c06131c 100644 --- a/centipede/config_file.cc +++ b/centipede/config_file.cc @@ -29,8 +29,6 @@ #include "absl/flags/flag.h" #include "absl/flags/parse.h" #include "absl/flags/reflection.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/match.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_join.h" @@ -116,7 +114,9 @@ AugmentedArgvWithCleanup::AugmentedArgvWithCleanup( const std::string& new_arg = argv_.emplace_back( absl::StrReplaceAll(flag_replaced_arg.value_or(old_arg), replacements)); if (new_arg != old_arg) { - VLOG(1) << "Augmented argv arg:\n" << VV(old_arg) << "\n" << VV(new_arg); + FUZZTEST_VLOG(1) << "Augmented argv arg:\n" + << VV(old_arg) << "\n" + << VV(new_arg); was_augmented_ = true; } } @@ -147,7 +147,7 @@ AugmentedArgvWithCleanup LocalizeConfigFilesInArgv( const std::filesystem::path path = absl::GetFlag(FLAGS_config); if (!path.empty()) { - CHECK_NE(path, absl::GetFlag(FLAGS_save_config)) + FUZZTEST_CHECK_NE(path, absl::GetFlag(FLAGS_save_config)) << "To update config in place, use " << DASHED_FLAG_NAME(update_config); } @@ -162,15 +162,16 @@ AugmentedArgvWithCleanup LocalizeConfigFilesInArgv( if (!path.empty() && !std::filesystem::exists(path)) { // assume remote // Read the remote file. std::string contents; - CHECK_OK(RemoteFileGetContents(path.c_str(), contents)); + FUZZTEST_CHECK_OK(RemoteFileGetContents(path.c_str(), contents)); // Save a temporary local copy. const std::filesystem::path tmp_dir = TemporaryLocalDirPath(); const std::filesystem::path local_path = tmp_dir / path.filename(); - LOG(INFO) << "Localizing remote config: " << VV(path) << VV(local_path); + FUZZTEST_LOG(INFO) << "Localizing remote config: " << VV(path) + << VV(local_path); // NOTE: Ignore "Remote" in the API names here: the paths are always local. - CHECK_OK(RemoteMkdir(tmp_dir.c_str())); - CHECK_OK(RemoteFileSetContents(local_path.c_str(), contents)); + FUZZTEST_CHECK_OK(RemoteMkdir(tmp_dir.c_str())); + FUZZTEST_CHECK_OK(RemoteFileSetContents(local_path.c_str(), contents)); // Augment the argv to point at the local copy and ensure it is cleaned up. replacements.emplace_back(path.c_str(), local_path.c_str()); @@ -188,16 +189,16 @@ std::filesystem::path MaybeSaveConfigToFile( // Initialize `path` if --save_config or --update_config is passed. if (!absl::GetFlag(FLAGS_save_config).empty()) { path = absl::GetFlag(FLAGS_save_config); - CHECK_NE(path, absl::GetFlag(FLAGS_config)) + FUZZTEST_CHECK_NE(path, absl::GetFlag(FLAGS_config)) << "To update config in place, use " << DASHED_FLAG_NAME(update_config); - CHECK(!absl::GetFlag(FLAGS_update_config)) + FUZZTEST_CHECK(!absl::GetFlag(FLAGS_update_config)) << DASHED_FLAG_NAME(save_config) << " and " << DASHED_FLAG_NAME(update_config) << " are mutually exclusive"; } else if (absl::GetFlag(FLAGS_update_config)) { path = absl::GetFlag(FLAGS_config); - CHECK(!path.empty()) << DASHED_FLAG_NAME(update_config) - << " must be used in combination with " - << DASHED_FLAG_NAME(config); + FUZZTEST_CHECK(!path.empty()) + << DASHED_FLAG_NAME(update_config) + << " must be used in combination with " << DASHED_FLAG_NAME(config); } // Save or update the config file. @@ -244,7 +245,7 @@ set -x } else { file_contents = flags_str; } - CHECK_OK(RemoteFileSetContents(path.c_str(), file_contents)); + FUZZTEST_CHECK_OK(RemoteFileSetContents(path.c_str(), file_contents)); } return path; @@ -269,7 +270,7 @@ std::unique_ptr InitCentipede( // const AugmentedArgvWithCleanup localized_argv = LocalizeConfigFilesInArgv(saved_argv); if (localized_argv.was_augmented()) { - LOG(INFO) << "Command line was augmented; reparsing"; + FUZZTEST_LOG(INFO) << "Command line was augmented; reparsing"; runtime_state->leftover_argv() = CastArgv(absl::ParseCommandLine( localized_argv.argc(), CastArgv(localized_argv.argv()).data())); } @@ -279,15 +280,15 @@ std::unique_ptr InitCentipede( // const FlagInfosPerSource flags = GetFlagsPerSource("centipede"); const std::string flags_str = FormatFlagfileString( flags, DefaultedFlags::kCommentedOut, FlagComments::kNone); - LOG(INFO) << "Final resolved config:\n" << flags_str; + FUZZTEST_LOG(INFO) << "Final resolved config:\n" << flags_str; } // If --save_config was passed, save the final resolved flags to the requested // file and exit the program. const auto path = MaybeSaveConfigToFile(leftover_argv); if (!path.empty()) { - LOG(INFO) << "Config written to file: " << VV(path); - LOG(INFO) << "Nothing left to do; exiting"; + FUZZTEST_LOG(INFO) << "Config written to file: " << VV(path); + FUZZTEST_LOG(INFO) << "Nothing left to do; exiting"; exit(EXIT_SUCCESS); } diff --git a/centipede/config_init.cc b/centipede/config_init.cc index 5c5c55548..2d22a3370 100644 --- a/centipede/config_init.cc +++ b/centipede/config_init.cc @@ -37,7 +37,7 @@ RuntimeState::RuntimeState(std::vector leftover_argv) ABSL_ATTRIBUTE_WEAK std::unique_ptr InitRuntime(int argc, char* argv[]) { // NB: The invocation order below is very important. Do not change. - // Make `LOG(INFO)` to go to stderr by default. Note that an explicit + // Make `FUZZTEST_LOG(INFO)` to go to stderr by default. Note that an explicit // `--stderrthreshold=N` on the command line will override this. absl::SetStderrThreshold(absl::LogSeverityAtLeast::kInfo); // Make --help print any flags defined by any Centipede source. diff --git a/centipede/config_init.h b/centipede/config_init.h index 740d2ccb9..59436df33 100644 --- a/centipede/config_init.h +++ b/centipede/config_init.h @@ -42,8 +42,8 @@ class [[nodiscard]] RuntimeState { }; // * Initializes the relevant runtime subsystems in the correct order. -// * Directs all `LOG(INFO)`s to also to stderr (by default, only `LOG(ERROR)`s -// and higher go to stderr). +// * Directs all `FUZZTEST_LOG(INFO)`s to also to stderr (by default, only +// `FUZZTEST_LOG(ERROR)`s and higher go to stderr). // * Tweaks --help behavior to print any flags defined by any Centipede source // (by default, --help only prints flags defined in the source named // .cc or .cc). diff --git a/centipede/control_flow.cc b/centipede/control_flow.cc index 68c443ee0..e053a8029 100644 --- a/centipede/control_flow.cc +++ b/centipede/control_flow.cc @@ -30,8 +30,6 @@ #include #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/match.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_split.h" @@ -47,11 +45,11 @@ namespace fuzztest::internal { PCTable ReadPcTableFromFile(std::string_view file_path) { ByteArray pc_infos_as_bytes; ReadFromLocalFile(file_path, pc_infos_as_bytes); - CHECK_EQ(pc_infos_as_bytes.size() % sizeof(PCInfo), 0); + FUZZTEST_CHECK_EQ(pc_infos_as_bytes.size() % sizeof(PCInfo), 0); size_t pc_table_size = pc_infos_as_bytes.size() / sizeof(PCInfo); const auto *pc_infos = reinterpret_cast(pc_infos_as_bytes.data()); PCTable pc_table{pc_infos, pc_infos + pc_table_size}; - CHECK_EQ(pc_table.size(), pc_table_size); + FUZZTEST_CHECK_EQ(pc_table.size(), pc_table_size); return pc_table; } @@ -68,9 +66,9 @@ PCTable GetPcTableFromBinaryWithTracePC(std::string_view binary_path, if (exit_code != EXIT_SUCCESS) { std::string log_text; ReadFromLocalFile(stderr_path, log_text); - LOG(ERROR) << "Failed to use objdump to get PC table; stderr is:"; + FUZZTEST_LOG(ERROR) << "Failed to use objdump to get PC table; stderr is:"; for (const auto &line : absl::StrSplit(log_text, '\n')) { - LOG(ERROR).NoPrefix() << line; + FUZZTEST_LOG(ERROR).NoPrefix() << line; } std::filesystem::remove(tmp_path); std::filesystem::remove(stderr_path); @@ -79,7 +77,7 @@ PCTable GetPcTableFromBinaryWithTracePC(std::string_view binary_path, std::filesystem::remove(stderr_path); PCTable pc_table; std::ifstream in(std::string{tmp_path}); - CHECK(in.good()) << VV(tmp_path); + FUZZTEST_CHECK(in.good()) << VV(tmp_path); bool saw_new_function = false; // Read the objdump output, find lines that start a function @@ -107,7 +105,7 @@ PCTable GetPcTableFromBinaryWithTracePC(std::string_view binary_path, CFTable ReadCfTable(std::istream &in) { const std::string input_string(std::istreambuf_iterator(in), {}); const ByteArray cf_table_as_bytes(input_string.begin(), input_string.end()); - CHECK_EQ(cf_table_as_bytes.size() % sizeof(CFTable::value_type), 0); + FUZZTEST_CHECK_EQ(cf_table_as_bytes.size() % sizeof(CFTable::value_type), 0); const size_t cf_table_size = cf_table_as_bytes.size() / sizeof(CFTable::value_type); const auto *cf_entries = @@ -117,7 +115,7 @@ CFTable ReadCfTable(std::istream &in) { CFTable ReadCfTable(std::string_view file_path) { std::string cf_table_contents; - CHECK_OK(RemoteFileGetContents(file_path, cf_table_contents)); + FUZZTEST_CHECK_OK(RemoteFileGetContents(file_path, cf_table_contents)); std::istringstream cf_table_stream(cf_table_contents); return ReadCfTable(cf_table_stream); } @@ -135,7 +133,7 @@ DsoTable ReadDsoTableFromFile(std::string_view file_path) { // Use std::string; there is no std::stoul for std::string_view. const std::vector tokens = absl::StrSplit(line, ' ', absl::SkipEmpty()); - CHECK_EQ(tokens.size(), 2) << VV(line); + FUZZTEST_CHECK_EQ(tokens.size(), 2) << VV(line); result.push_back(DsoInfo{tokens[0], std::stoul(tokens[1])}); } return result; @@ -143,7 +141,7 @@ DsoTable ReadDsoTableFromFile(std::string_view file_path) { void ControlFlowGraph::InitializeControlFlowGraph(const CFTable &cf_table, const PCTable &pc_table) { - CHECK(!cf_table.empty()); + FUZZTEST_CHECK(!cf_table.empty()); func_entries_.resize(pc_table.size()); reachability_.resize(pc_table.size()); @@ -162,14 +160,14 @@ void ControlFlowGraph::InitializeControlFlowGraph(const CFTable &cf_table, // Record the list of successors graph_[curr_pc] = std::move(successors); // TODO(ussuri): Remove after debugging. - VLOG(100) << "Added PC: " << curr_pc; + FUZZTEST_VLOG(100) << "Added PC: " << curr_pc; // Iterate over callees. while (cf_table[j]) { ++j; } ++j; // Step over the delimiter. - CHECK_LE(j, cf_table.size()); + FUZZTEST_CHECK_LE(j, cf_table.size()); } // Calculate cyclomatic complexity for all functions. for (PCIndex i = 0; i < pc_table.size(); ++i) { @@ -186,7 +184,7 @@ void ControlFlowGraph::InitializeControlFlowGraph(const CFTable &cf_table, const std::vector &ControlFlowGraph::GetSuccessors( uintptr_t basic_block) const { auto it = graph_.find(basic_block); - CHECK(it != graph_.end()) << VV(basic_block); + FUZZTEST_CHECK(it != graph_.end()) << VV(basic_block); return it->second; } diff --git a/centipede/control_flow.h b/centipede/control_flow.h index f401d84da..2feb9faf1 100644 --- a/centipede/control_flow.h +++ b/centipede/control_flow.h @@ -25,7 +25,6 @@ #include "absl/container/flat_hash_map.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" #include "./centipede/pc_info.h" #include "./common/defs.h" #include "./common/logging.h" @@ -86,26 +85,27 @@ class ControlFlowGraph { return graph_.contains(basic_block); } - // Returns cyclomatic complexity of function PC. CHECK-fails if it is not a - // valid function PC. + // Returns cyclomatic complexity of function PC. FUZZTEST_CHECK-fails if it is + // not a valid function PC. uint32_t GetCyclomaticComplexity(uintptr_t pc) const { auto it = function_complexities_.find(pc); - CHECK(it != function_complexities_.end()); + FUZZTEST_CHECK(it != function_complexities_.end()); return it->second; } // Returns true if the given basic block is function entry. bool BlockIsFunctionEntry(PCIndex pc_index) const { - // TODO(ussuri): Change the following to use CHECK_LE(pc_index, + // TODO(ussuri): Change the following to use FUZZTEST_CHECK_LE(pc_index, // func_entries_.size()) and have a death test. return pc_index < func_entries_.size() ? func_entries_[pc_index] : false; } - // Returns the idx in pc_table associated with the PC, CHECK-fails if the PC - // is not in the pc_table. + // Returns the idx in pc_table associated with the PC, FUZZTEST_CHECK-fails if + // the PC is not in the pc_table. PCIndex GetPcIndex(uintptr_t pc) const { auto it = pc_index_map_.find(pc); - CHECK(it != pc_index_map_.end()) << VV(pc) << " is not in pc_table."; + FUZZTEST_CHECK(it != pc_index_map_.end()) + << VV(pc) << " is not in pc_table."; return it->second; } @@ -117,7 +117,7 @@ class ControlFlowGraph { // The method is const, under the hood it uses a mutable data member. // Thread-safe: can be called concurrently from multiple threads const std::vector &LazyGetReachabilityForPc(uintptr_t pc) const { - CHECK_EQ(reachability_.size(), pc_index_map_.size()); + FUZZTEST_CHECK_EQ(reachability_.size(), pc_index_map_.size()); auto pc_index = GetPcIndex(pc); std::call_once(*(reachability_[pc_index].once), [this, &pc, &pc_index]() { reachability_[pc_index].reach = ComputeReachabilityForPc(pc); diff --git a/centipede/control_flow_test.cc b/centipede/control_flow_test.cc index 4d63e591c..2d21d210c 100644 --- a/centipede/control_flow_test.cc +++ b/centipede/control_flow_test.cc @@ -25,8 +25,6 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/container/flat_hash_map.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "./centipede/binary_info.h" #include "./centipede/pc_info.h" #include "./centipede/symbol_table.h" @@ -87,17 +85,17 @@ TEST(CFTable, MakeCfgFromCfTable) { EXPECT_TRUE(cfg.GetSuccessors(4).empty()); } - CHECK_EQ(cfg.GetPcIndex(1), 0); - CHECK_EQ(cfg.GetPcIndex(2), 1); - CHECK_EQ(cfg.GetPcIndex(3), 2); - CHECK_EQ(cfg.GetPcIndex(4), 3); + FUZZTEST_CHECK_EQ(cfg.GetPcIndex(1), 0); + FUZZTEST_CHECK_EQ(cfg.GetPcIndex(2), 1); + FUZZTEST_CHECK_EQ(cfg.GetPcIndex(3), 2); + FUZZTEST_CHECK_EQ(cfg.GetPcIndex(4), 3); EXPECT_TRUE(cfg.BlockIsFunctionEntry(0)); EXPECT_FALSE(cfg.BlockIsFunctionEntry(1)); EXPECT_FALSE(cfg.BlockIsFunctionEntry(2)); EXPECT_FALSE(cfg.BlockIsFunctionEntry(3)); - CHECK_EQ(cfg.GetCyclomaticComplexity(1), 2); + FUZZTEST_CHECK_EQ(cfg.GetCyclomaticComplexity(1), 2); } TEST(CFTable, SerializesAndDeserializesCfTable) { @@ -205,9 +203,9 @@ TEST(CFTable, GetCfTable) { target_path, GetObjDumpPath(), GetLLVMSymbolizerPath(), GetTestTempDir(test_info_->name()).string()); const auto &cf_table = binary_info.cf_table; - LOG(INFO) << VV(target_path) << VV(tmp_path1) << VV(cf_table.size()); + FUZZTEST_LOG(INFO) << VV(target_path) << VV(tmp_path1) << VV(cf_table.size()); if (cf_table.empty()) { - LOG(INFO) << "__sancov_cfs is empty."; + FUZZTEST_LOG(INFO) << "__sancov_cfs is empty."; // TODO(ussuri): This should be removed once OSS clang supports // control-flow. GTEST_SKIP(); @@ -215,7 +213,7 @@ TEST(CFTable, GetCfTable) { ASSERT_FALSE( std::filesystem::exists(tmp_path1.c_str())); // tmp_path1 was deleted. - LOG(INFO) << VV(cf_table.size()); + FUZZTEST_LOG(INFO) << VV(cf_table.size()); const auto &pc_table = binary_info.pc_table; EXPECT_FALSE(binary_info.uses_legacy_trace_pc_instrumentation); @@ -304,7 +302,7 @@ static void SymbolizeBinary(std::string_view test_dir, for (size_t i = 0; i < symbols.size(); i++) { bool is_func_entry = pc_table[i].has_flag(PCInfo::kFuncEntry); if (is_func_entry) { - LOG(INFO) << symbols.full_description(i); + FUZZTEST_LOG(INFO) << symbols.full_description(i); } single_edge_func_num_edges += symbols.func(i) == "SingleEdgeFunc"; multi_edge_func_num_edges += symbols.func(i) == "MultiEdgeFunc"; diff --git a/centipede/corpus.cc b/centipede/corpus.cc index 42f3e4bb2..16f4b5d2e 100644 --- a/centipede/corpus.cc +++ b/centipede/corpus.cc @@ -22,8 +22,6 @@ #include #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_join.h" #include "absl/strings/substitute.h" @@ -80,7 +78,7 @@ size_t Corpus::Prune(const FeatureSet &fs, const CoverageFrontier &coverage_frontier, size_t max_corpus_size, Rng &rng) { // TODO(kcc): use coverage_frontier. - CHECK(max_corpus_size); + FUZZTEST_CHECK(max_corpus_size); if (records_.size() < 2UL) return 0; // Recompute the weights. size_t num_zero_weights = 0; @@ -103,7 +101,7 @@ size_t Corpus::Prune(const FeatureSet &fs, RemoveSubset(subset_to_remove, records_); weighted_distribution_.RecomputeInternalState(); - CHECK(!records_.empty()); + FUZZTEST_CHECK(!records_.empty()); // Features may have shrunk from CountUnseenAndPruneFrequentFeatures. // Call shrink_to_fit for the features that survived the pruning. @@ -119,9 +117,9 @@ void Corpus::Add(const ByteArray &data, const FeatureVec &fv, const ExecutionMetadata &metadata, const FeatureSet &fs, const CoverageFrontier &coverage_frontier) { // TODO(kcc): use coverage_frontier. - CHECK(!data.empty()) + FUZZTEST_CHECK(!data.empty()) << "Got request to add empty element to corpus: ignoring"; - CHECK_EQ(records_.size(), weighted_distribution_.size()); + FUZZTEST_CHECK_EQ(records_.size(), weighted_distribution_.size()); records_.push_back({data, fv, metadata}); weighted_distribution_.AddWeight(ComputeWeight(fv, fs, coverage_frontier)); } @@ -137,8 +135,8 @@ const CorpusRecord &Corpus::UniformRandom(size_t random) const { void Corpus::DumpStatsToFile(const FeatureSet &fs, std::string_view filepath, std::string_view description) { auto *file = ValueOrDie(RemoteFileOpen(filepath, "w")); - CHECK(file != nullptr) << "Failed to open file: " << filepath; - CHECK_OK(RemoteFileSetWriteBufferSize(file, 100UL * 1024 * 1024)); + FUZZTEST_CHECK(file != nullptr) << "Failed to open file: " << filepath; + FUZZTEST_CHECK_OK(RemoteFileSetWriteBufferSize(file, 100UL * 1024 * 1024)); static constexpr std::string_view kHeaderStub = R"(# $0 { "num_inputs": $1, @@ -151,7 +149,7 @@ void Corpus::DumpStatsToFile(const FeatureSet &fs, std::string_view filepath, )"; const std::string header_str = absl::Substitute(kHeaderStub, description, records_.size()); - CHECK_OK(RemoteFileAppend(file, header_str)); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, header_str)); std::string before_record; for (const auto &record : records_) { std::vector frequencies; @@ -162,11 +160,11 @@ void Corpus::DumpStatsToFile(const FeatureSet &fs, std::string_view filepath, const std::string frequencies_str = absl::StrJoin(frequencies, ", "); const std::string record_str = absl::Substitute( kRecordStub, before_record, record.data.size(), frequencies_str); - CHECK_OK(RemoteFileAppend(file, record_str)); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, record_str)); before_record = ","; } - CHECK_OK(RemoteFileAppend(file, std::string{kFooter})); - CHECK_OK(RemoteFileClose(file)); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, std::string{kFooter})); + FUZZTEST_CHECK_OK(RemoteFileClose(file)); } std::string Corpus::MemoryUsageString() const { @@ -184,7 +182,7 @@ std::string Corpus::MemoryUsageString() const { //------------------------------------------------------------------------------ void WeightedDistribution::AddWeight(uint64_t weight) { - CHECK_EQ(weights_.size(), cumulative_weights_.size()); + FUZZTEST_CHECK_EQ(weights_.size(), cumulative_weights_.size()); weights_.push_back(weight); if (cumulative_weights_.empty()) { cumulative_weights_.push_back(weight); @@ -194,7 +192,7 @@ void WeightedDistribution::AddWeight(uint64_t weight) { } void WeightedDistribution::ChangeWeight(size_t idx, uint64_t new_weight) { - CHECK_LT(idx, size()); + FUZZTEST_CHECK_LT(idx, size()); weights_[idx] = new_weight; cumulative_weights_valid_ = false; } @@ -212,15 +210,15 @@ void WeightedDistribution::RecomputeInternalState() { __attribute__((noinline)) // to see it in profile. size_t WeightedDistribution::RandomIndex(size_t random) const { - CHECK(!weights_.empty()); - CHECK(cumulative_weights_valid_); + FUZZTEST_CHECK(!weights_.empty()); + FUZZTEST_CHECK(cumulative_weights_valid_); uint64_t sum_of_all_weights = cumulative_weights_.back(); if (sum_of_all_weights == 0) return random % size(); // can't do much else here. random = random % sum_of_all_weights; auto it = std::upper_bound(cumulative_weights_.begin(), cumulative_weights_.end(), random); - CHECK(it != cumulative_weights_.end()); + FUZZTEST_CHECK(it != cumulative_weights_.end()); return it - cumulative_weights_.begin(); } diff --git a/centipede/corpus.h b/centipede/corpus.h index e297f0631..dc6bb0017 100644 --- a/centipede/corpus.h +++ b/centipede/corpus.h @@ -23,7 +23,6 @@ #include #include -#include "absl/log/check.h" #include "./centipede/binary_info.h" #include "./centipede/execution_metadata.h" #include "./centipede/feature.h" @@ -180,7 +179,7 @@ class CoverageFrontier { // Returns true iff `idx` belongs to the frontier. bool PcIndexIsFrontier(size_t idx) const { - CHECK_LT(idx, MaxPcIndex()); + FUZZTEST_CHECK_LT(idx, MaxPcIndex()); return frontier_[idx]; } @@ -189,7 +188,7 @@ class CoverageFrontier { // Returns the frontier weight of pc at `idx`, weight of a non-frontier is 0. uint64_t FrontierWeight(size_t idx) const { - CHECK_LT(idx, MaxPcIndex()); + FUZZTEST_CHECK_LT(idx, MaxPcIndex()); return frontier_weight_[idx]; } diff --git a/centipede/corpus_io.cc b/centipede/corpus_io.cc index 23e63c3cd..cdc6de9d6 100644 --- a/centipede/corpus_io.cc +++ b/centipede/corpus_io.cc @@ -22,8 +22,6 @@ #include #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/time/time.h" #include "absl/types/span.h" @@ -46,13 +44,13 @@ void ReadShard(std::string_view corpus_path, std::string_view features_path, !features_path.empty() && RemotePathExists(features_path); if (!good_corpus_path) { - LOG(WARNING) << "Corpus file path empty or not found - returning: " - << corpus_path; + FUZZTEST_LOG(WARNING) << "Corpus file path empty or not found - returning: " + << corpus_path; return; } RPROF_THIS_FUNCTION_WITH_TIMELAPSE( // - /*enable=*/ABSL_VLOG_IS_ON(10), // + /*enable=*/FUZZTEST_VLOG_IS_ON(10), // /*timelapse_interval=*/absl::Seconds(30), // /*also_log_timelapses=*/false); @@ -64,7 +62,7 @@ void ReadShard(std::string_view corpus_path, std::string_view features_path, std::multimap hash_to_input; // Read inputs from the corpus file into `hash_to_input`. auto corpus_reader = DefaultBlobFileReaderFactory(); - CHECK_OK(corpus_reader->Open(corpus_path)) << VV(corpus_path); + FUZZTEST_CHECK_OK(corpus_reader->Open(corpus_path)) << VV(corpus_path); ByteSpan blob; while (corpus_reader->Read(blob).ok()) { std::string hash = Hash(blob); @@ -82,15 +80,17 @@ void ReadShard(std::string_view corpus_path, std::string_view features_path, // If the features file is not passed or doesn't exist, simply ignore it. if (!good_features_path) { - LOG(WARNING) << "Features file path empty or not found - ignoring: " - << features_path; + FUZZTEST_LOG(WARNING) + << "Features file path empty or not found - ignoring: " + << features_path; } else { // Read features from the features file. For each feature, find a matching // input in `hash_to_input`, call `callback` for the pair, and remove the // entry from `hash_to_input`. In the end, `hash_to_input` will contain // only inputs without matching features. auto features_reader = DefaultBlobFileReaderFactory(); - CHECK_OK(features_reader->Open(features_path)) << VV(features_path); + FUZZTEST_CHECK_OK(features_reader->Open(features_path)) + << VV(features_path); ByteSpan hash_and_features; while (features_reader->Read(hash_and_features).ok()) { // Every valid feature record must contain the hash at the end. @@ -127,7 +127,7 @@ void ReadShard(std::string_view corpus_path, std::string_view features_path, RPROF_SNAPSHOT("Reported inputs with no matching features"); - VLOG(1) // + FUZZTEST_VLOG(1) // << "Finished shard reading:\n" << "Corpus path : " << corpus_path << "\n" << "Features path : " << features_path << "\n" @@ -140,17 +140,17 @@ void ReadShard(std::string_view corpus_path, std::string_view features_path, void ExportCorpus(absl::Span sharded_file_paths, std::string_view out_dir) { - LOG(INFO) << "Exporting corpus to " << out_dir; + FUZZTEST_LOG(INFO) << "Exporting corpus to " << out_dir; for (const std::string &file : sharded_file_paths) { auto reader = DefaultBlobFileReaderFactory(); - CHECK_OK(reader->Open(file)) << VV(file); + FUZZTEST_CHECK_OK(reader->Open(file)) << VV(file); ByteSpan blob; size_t num_read = 0; while (reader->Read(blob).ok()) { ++num_read; WriteToRemoteHashedFileInDir(out_dir, blob); } - LOG(INFO) << "Exported " << num_read << " inputs from " << file; + FUZZTEST_LOG(INFO) << "Exported " << num_read << " inputs from " << file; } } diff --git a/centipede/corpus_io_test.cc b/centipede/corpus_io_test.cc index a97572d6f..f368a3195 100644 --- a/centipede/corpus_io_test.cc +++ b/centipede/corpus_io_test.cc @@ -22,7 +22,6 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/log/check.h" #include "absl/types/span.h" #include "./centipede/corpus.h" #include "./centipede/feature.h" @@ -30,6 +29,7 @@ #include "./centipede/workdir.h" #include "./common/blob_file.h" #include "./common/defs.h" +#include "./common/logging.h" #include "./common/test_util.h" namespace fuzztest::internal { @@ -40,11 +40,11 @@ using ::testing::UnorderedElementsAre; void WriteBlobsToFile(std::string_view blob_file_path, absl::Span blobs) { auto writer = DefaultBlobFileWriterFactory(); - CHECK_OK(writer->Open(blob_file_path, "w")); + FUZZTEST_CHECK_OK(writer->Open(blob_file_path, "w")); for (const ByteArray& blob : blobs) { - CHECK_OK(writer->Write(blob)); + FUZZTEST_CHECK_OK(writer->Write(blob)); } - CHECK_OK(writer->Close()); + FUZZTEST_CHECK_OK(writer->Close()); } std::vector ReadInputsFromFiles(std::string_view dir) { @@ -109,7 +109,7 @@ TEST(ReadShardTest, ReadsInputsAndFeaturesAndCallsCallbackForEachPair) { TEST(ExportCorpusTest, ExportsCorpusToIndividualFiles) { const std::filesystem::path temp_dir = GetTestTempDir(test_info_->name()); const std::filesystem::path out_dir = temp_dir / "out_dir"; - CHECK(std::filesystem::create_directory(out_dir)); + FUZZTEST_CHECK(std::filesystem::create_directory(out_dir)); const WorkDir workdir{temp_dir.c_str(), "fake_binary_name", "fake_binary_hash", /*my_shard_index=*/0}; const auto corpus_file_paths = workdir.CorpusFilePaths(); diff --git a/centipede/corpus_test.cc b/centipede/corpus_test.cc index 13b576ca7..89755716e 100644 --- a/centipede/corpus_test.cc +++ b/centipede/corpus_test.cc @@ -135,7 +135,7 @@ TEST(Corpus, Prune) { EXPECT_EQ(corpus.Prune(fs, coverage_frontier, 1, rng), 1); EXPECT_EQ(corpus.NumActive(), 1); EXPECT_DEATH(corpus.Prune(fs, coverage_frontier, 0, rng), - "max_corpus_size"); // CHECK-fail. + "max_corpus_size"); // FUZZTEST_CHECK-fail. EXPECT_EQ(corpus.NumTotal(), 6); } diff --git a/centipede/coverage.cc b/centipede/coverage.cc index 28373ea93..a5a96e200 100644 --- a/centipede/coverage.cc +++ b/centipede/coverage.cc @@ -25,13 +25,13 @@ #include #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" #include "absl/strings/str_split.h" #include "absl/synchronization/mutex.h" #include "./centipede/control_flow.h" #include "./centipede/feature.h" #include "./centipede/pc_info.h" #include "./centipede/symbol_table.h" +#include "./common/logging.h" #include "./common/remote_file.h" #include "./common/status_macros.h" @@ -41,7 +41,7 @@ Coverage::Coverage(const PCTable &pc_table, const PCIndexVec &pci_vec) : func_entries_(pc_table.size()), fully_covered_funcs_vec_(pc_table.size()), covered_pcs_vec_(pc_table.size()) { - CHECK_LT(pc_table.size(), std::numeric_limits::max()); + FUZZTEST_CHECK_LT(pc_table.size(), std::numeric_limits::max()); absl::flat_hash_set covered_pcs(pci_vec.begin(), pci_vec.end()); // Iterate though all the pc_table entries. // The first one is some function's kFuncEntry. @@ -51,7 +51,7 @@ Coverage::Coverage(const PCTable &pc_table, const PCIndexVec &pci_vec) // to fully_covered_funcs or uncovered_funcs correspondingly. // For all others add them to partially_covered_funcs. for (size_t this_func = 0; this_func < pc_table.size();) { - CHECK(pc_table[this_func].has_flag(PCInfo::kFuncEntry)); + FUZZTEST_CHECK(pc_table[this_func].has_flag(PCInfo::kFuncEntry)); func_entries_[this_func] = true; // Find next entry. size_t next_func = this_func + 1; @@ -78,9 +78,10 @@ Coverage::Coverage(const PCTable &pc_table, const PCIndexVec &pci_vec) } else if (pcf.covered.empty()) { uncovered_funcs.push_back(this_func); } else { - CHECK(!pcf.covered.empty()); - CHECK(!pcf.uncovered.empty()); - CHECK_EQ(pcf.covered.size() + pcf.uncovered.size(), num_func_pcs); + FUZZTEST_CHECK(!pcf.covered.empty()); + FUZZTEST_CHECK(!pcf.uncovered.empty()); + FUZZTEST_CHECK_EQ(pcf.covered.size() + pcf.uncovered.size(), + num_func_pcs); partially_covered_funcs.push_back(pcf); } // Move to the next function. @@ -92,46 +93,51 @@ void Coverage::DumpReportToFile(const SymbolTable &symbols, std::string_view filepath, std::string_view description) { auto *file = ValueOrDie(RemoteFileOpen(filepath, "w")); - CHECK(file != nullptr) << "Failed to open file: " << filepath; - CHECK_OK(RemoteFileSetWriteBufferSize(file, 100UL * 1024 * 1024)); + FUZZTEST_CHECK(file != nullptr) << "Failed to open file: " << filepath; + FUZZTEST_CHECK_OK(RemoteFileSetWriteBufferSize(file, 100UL * 1024 * 1024)); if (!description.empty()) { - CHECK_OK(RemoteFileAppend(file, "# ")); - CHECK_OK(RemoteFileAppend(file, std::string{description})); - CHECK_OK(RemoteFileAppend(file, ":\n\n")); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "# ")); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, std::string{description})); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, ":\n\n")); } // Print symbolized function names for all covered functions. for (auto pc_index : fully_covered_funcs) { - CHECK_OK(RemoteFileAppend(file, "FULL: ")); - CHECK_OK(RemoteFileAppend(file, symbols.full_description(pc_index))); - CHECK_OK(RemoteFileAppend(file, "\n")); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "FULL: ")); + FUZZTEST_CHECK_OK( + RemoteFileAppend(file, symbols.full_description(pc_index))); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n")); } - CHECK_OK(RemoteFileFlush(file)); + FUZZTEST_CHECK_OK(RemoteFileFlush(file)); // Same for uncovered functions. for (auto pc_index : uncovered_funcs) { - CHECK_OK(RemoteFileAppend(file, "NONE: ")); - CHECK_OK(RemoteFileAppend(file, symbols.full_description(pc_index))); - CHECK_OK(RemoteFileAppend(file, "\n")); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "NONE: ")); + FUZZTEST_CHECK_OK( + RemoteFileAppend(file, symbols.full_description(pc_index))); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n")); } - CHECK_OK(RemoteFileFlush(file)); + FUZZTEST_CHECK_OK(RemoteFileFlush(file)); // For every partially covered function, first print its name, // then print its covered edges, then uncovered edges. for (auto &pcf : partially_covered_funcs) { - CHECK_OK(RemoteFileAppend(file, "PARTIAL: ")); - CHECK_OK(RemoteFileAppend(file, symbols.full_description(pcf.covered[0]))); - CHECK_OK(RemoteFileAppend(file, "\n")); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "PARTIAL: ")); + FUZZTEST_CHECK_OK( + RemoteFileAppend(file, symbols.full_description(pcf.covered[0]))); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n")); for (auto pc_index : pcf.covered) { - CHECK_OK(RemoteFileAppend(file, " + ")); - CHECK_OK(RemoteFileAppend(file, symbols.full_description(pc_index))); - CHECK_OK(RemoteFileAppend(file, "\n")); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, " + ")); + FUZZTEST_CHECK_OK( + RemoteFileAppend(file, symbols.full_description(pc_index))); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n")); } for (auto pc_index : pcf.uncovered) { - CHECK_OK(RemoteFileAppend(file, " - ")); - CHECK_OK(RemoteFileAppend(file, symbols.full_description(pc_index))); - CHECK_OK(RemoteFileAppend(file, "\n")); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, " - ")); + FUZZTEST_CHECK_OK( + RemoteFileAppend(file, symbols.full_description(pc_index))); + FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n")); } } - CHECK_OK(RemoteFileFlush(file)); - CHECK_OK(RemoteFileClose(file)); + FUZZTEST_CHECK_OK(RemoteFileFlush(file)); + FUZZTEST_CHECK_OK(RemoteFileClose(file)); } std::string CoverageLogger::ObserveAndDescribeIfNew(PCIndex pc_index) { @@ -215,7 +221,7 @@ uint32_t ComputeFrontierWeight(const Coverage &coverage, auto cyclomatic_comp = cfg.GetCyclomaticComplexity(callee); // Determine knob based on callee coverage kind. auto callee_idx = cfg.GetPcIndex(callee); - CHECK(cfg.BlockIsFunctionEntry(callee_idx)); + FUZZTEST_CHECK(cfg.BlockIsFunctionEntry(callee_idx)); auto coverage_multiplier = SelectMultiplierByCoverageKind( uncovered_knob, partially_covered_knob, fully_covered_knob, callee_idx, coverage); diff --git a/centipede/coverage.h b/centipede/coverage.h index 7e681c0c4..340027c80 100644 --- a/centipede/coverage.h +++ b/centipede/coverage.h @@ -26,7 +26,6 @@ #include "absl/base/thread_annotations.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" #include "absl/synchronization/mutex.h" #include "./centipede/control_flow.h" #include "./centipede/feature.h" @@ -55,7 +54,7 @@ class Coverage { // Returns true if the function is fully covered. pc_index is for a function // entry. bool FunctionIsFullyCovered(PCIndex pc_index) const { - CHECK(func_entries_[pc_index]); + FUZZTEST_CHECK(func_entries_[pc_index]); return fully_covered_funcs_vec_[pc_index]; } // Returns true if the given basic block is covered. pc_index is for any BB. diff --git a/centipede/distill.cc b/centipede/distill.cc index 1b16a2b4d..74ecf67ba 100644 --- a/centipede/distill.cc +++ b/centipede/distill.cc @@ -30,8 +30,6 @@ #include "absl/base/thread_annotations.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_join.h" #include "absl/synchronization/mutex.h" @@ -136,9 +134,10 @@ class InputCorpusShardReader { CorpusEltVec ReadShard(size_t shard_idx) { const auto corpus_path = workdir_.CorpusFilePaths().Shard(shard_idx); const auto features_path = workdir_.FeaturesFilePaths().Shard(shard_idx); - VLOG(1) << log_prefix_ << "reading input shard " << shard_idx << ":\n" - << VV(corpus_path) << "\n" - << VV(features_path); + FUZZTEST_VLOG(1) << log_prefix_ << "reading input shard " << shard_idx + << ":\n" + << VV(corpus_path) << "\n" + << VV(features_path); CorpusEltVec elts; // Read elements from the current shard. fuzztest::internal::ReadShard( // @@ -171,8 +170,9 @@ class CorpusShardWriter { features_path_{workdir_.DistilledFeaturesFilePaths().MyShard()}, corpus_writer_{DefaultBlobFileWriterFactory()}, feature_writer_{DefaultBlobFileWriterFactory()} { - CHECK_OK(corpus_writer_->Open(corpus_path_, append ? "a" : "w")); - CHECK_OK(feature_writer_->Open(features_path_, append ? "a" : "w")); + FUZZTEST_CHECK_OK(corpus_writer_->Open(corpus_path_, append ? "a" : "w")); + FUZZTEST_CHECK_OK( + feature_writer_->Open(features_path_, append ? "a" : "w")); } virtual ~CorpusShardWriter() = default; @@ -184,10 +184,10 @@ class CorpusShardWriter { void WriteBatch(CorpusEltVec elts) { absl::MutexLock lock(&mu_); - VLOG(1) << log_prefix_ << "writing " << elts.size() - << " elements to output shard:\n" - << VV(corpus_path_) << "\n" - << VV(features_path_); + FUZZTEST_VLOG(1) << log_prefix_ << "writing " << elts.size() + << " elements to output shard:\n" + << VV(corpus_path_) << "\n" + << VV(features_path_); for (auto &elt : elts) { WriteEltImpl(std::move(elt)); } @@ -214,8 +214,9 @@ class CorpusShardWriter { const auto preprocessed_elt = PreprocessElt(std::move(elt)); if (preprocessed_elt.has_value()) { // Append to the distilled corpus and features files. - CHECK_OK(corpus_writer_->Write(preprocessed_elt->input)); - CHECK_OK(feature_writer_->Write(preprocessed_elt->PackedFeatures())); + FUZZTEST_CHECK_OK(corpus_writer_->Write(preprocessed_elt->input)); + FUZZTEST_CHECK_OK( + feature_writer_->Write(preprocessed_elt->PackedFeatures())); ++stats_.num_written_elts; } } @@ -337,9 +338,9 @@ void DistillToOneOutputShard( // DistillingInputFilter &input_filter, // ResourcePool &ram_pool, // int parallelism) { - LOG(INFO) << LogPrefix(env) << "Distilling to output shard " - << env.my_shard_index << "; input shard indices:\n" - << absl::StrJoin(shard_indices, ", "); + FUZZTEST_LOG(INFO) << LogPrefix(env) << "Distilling to output shard " + << env.my_shard_index << "; input shard indices:\n" + << absl::StrJoin(shard_indices, ", "); // Read and write the shards in parallel, but gate reading of each on the // availability of free RAM to keep the peak RAM usage under control. @@ -360,7 +361,7 @@ void DistillToOneOutputShard( // /*mem_rss=*/reader.EstimateRamFootprint(shard_idx)}, /*timeout=*/kRamLeaseTimeout, }); - CHECK_OK(ram_lease.status()); + FUZZTEST_CHECK_OK(ram_lease.status()); CorpusEltVec shard_elts = reader.ReadShard(shard_idx); // Reverse the order of elements. The intuition is as follows: @@ -371,23 +372,25 @@ void DistillToOneOutputShard( // std::reverse(shard_elts.begin(), shard_elts.end()); writer.WriteBatch(std::move(shard_elts)); const CorpusShardWriter::Stats shard_stats = writer.GetStats(); - LOG(INFO) << LogPrefix(env) - << "batches: " << shard_stats.num_written_batches << "/" - << num_shards << " inputs: " << shard_stats.num_total_elts - << " written: " << shard_stats.num_written_elts; + FUZZTEST_LOG(INFO) << LogPrefix(env) + << "batches: " << shard_stats.num_written_batches + << "/" << num_shards + << " inputs: " << shard_stats.num_total_elts + << " written: " << shard_stats.num_written_elts; }); } } // The threads join here. - LOG(INFO) << LogPrefix(env) << "Done distilling to output shard " - << env.my_shard_index; + FUZZTEST_LOG(INFO) << LogPrefix(env) << "Done distilling to output shard " + << env.my_shard_index; } int Distill(const Environment &env, const DistillOptions &opts) { - RPROF_THIS_FUNCTION_WITH_TIMELAPSE( // - /*enable=*/ABSL_VLOG_IS_ON(1), // - /*timelapse_interval=*/absl::Seconds(ABSL_VLOG_IS_ON(2) ? 10 : 60), // - /*also_log_timelapses=*/ABSL_VLOG_IS_ON(10)); + RPROF_THIS_FUNCTION_WITH_TIMELAPSE( // + /*enable=*/FUZZTEST_VLOG_IS_ON(1), // + /*timelapse_interval=*/ + absl::Seconds(FUZZTEST_VLOG_IS_ON(2) ? 10 : 60), // + /*also_log_timelapses=*/FUZZTEST_VLOG_IS_ON(10)); // Prepare the per-thread envs. std::vector envs_per_thread(env.num_threads, env); @@ -423,16 +426,16 @@ int Distill(const Environment &env, const DistillOptions &opts) { PeriodicAction progress_logger{ [&input_filter]() { const auto stats = input_filter.GetStats(); - LOG(INFO) << LogPrefix() << stats.coverage_str - << " inputs: " << stats.num_total_elts - << " unique: " << stats.num_byte_unique_elts - << " distilled: " << stats.num_feature_unique_elts; + FUZZTEST_LOG(INFO) << LogPrefix() << stats.coverage_str + << " inputs: " << stats.num_total_elts + << " unique: " << stats.num_byte_unique_elts + << " distilled: " << stats.num_feature_unique_elts; }, // Seeing 0's at the beginning is not interesting, unless debugging. // Likewise, increase the frequency --v >= 1 to aid debugging. PeriodicAction::ConstDelayConstInterval( - absl::Seconds(ABSL_VLOG_IS_ON(1) ? 0 : 60), - absl::Seconds(ABSL_VLOG_IS_ON(1) ? 10 : 60)), + absl::Seconds(FUZZTEST_VLOG_IS_ON(1) ? 0 : 60), + absl::Seconds(FUZZTEST_VLOG_IS_ON(1) ? 10 : 60)), }; // The RAM pool shared between all the `DistillToOneOutputShard()` threads. ResourcePool ram_pool{kRamQuota}; diff --git a/centipede/distill_test.cc b/centipede/distill_test.cc index 2d8801029..047f67fa3 100644 --- a/centipede/distill_test.cc +++ b/centipede/distill_test.cc @@ -25,7 +25,6 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/flags/reflection.h" -#include "absl/log/check.h" #include "./centipede/corpus_io.h" #include "./centipede/environment.h" #include "./centipede/feature.h" @@ -33,6 +32,7 @@ #include "./centipede/workdir.h" #include "./common/blob_file.h" #include "./common/defs.h" +#include "./common/logging.h" #include "./common/test_util.h" namespace fuzztest::internal { @@ -70,10 +70,10 @@ void WriteToShard(const Environment &env, const TestCorpusRecord &record, const auto features_path = wd.FeaturesFilePaths().Shard(shard_index); const auto corpus_appender = DefaultBlobFileWriterFactory(env.riegeli); const auto features_appender = DefaultBlobFileWriterFactory(env.riegeli); - CHECK_OK(corpus_appender->Open(corpus_path, "a")); - CHECK_OK(features_appender->Open(features_path, "a")); - CHECK_OK(corpus_appender->Write(record.input)); - CHECK_OK(features_appender->Write( + FUZZTEST_CHECK_OK(corpus_appender->Open(corpus_path, "a")); + FUZZTEST_CHECK_OK(features_appender->Open(features_path, "a")); + FUZZTEST_CHECK_OK(corpus_appender->Write(record.input)); + FUZZTEST_CHECK_OK(features_appender->Write( PackFeaturesAndHash(record.input, record.feature_vec))); } diff --git a/centipede/environment.cc b/centipede/environment.cc index 443a61150..16da62cce 100644 --- a/centipede/environment.cc +++ b/centipede/environment.cc @@ -27,8 +27,6 @@ #include "absl/base/no_destructor.h" #include "absl/container/flat_hash_map.h" #include "absl/flags/marshalling.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_split.h" #include "absl/strings/string_view.h" @@ -46,7 +44,7 @@ namespace fuzztest::internal { namespace { size_t ComputeTimeoutPerBatch(size_t timeout_per_input, size_t batch_size) { - CHECK_GT(batch_size, 0); + FUZZTEST_CHECK_GT(batch_size, 0); // NOTE: If `timeout_per_input` == 0, leave `timeout_per_batch` at 0 too: // the implementation interprets both as "no limit". if (timeout_per_input == 0) return 0; @@ -117,18 +115,19 @@ std::bitset Environment::MakeDomainDiscardMask() // Returns true if `value` is one of "1", "true". // Returns true if `value` is one of "0", "false". -// CHECK-fails otherwise. +// FUZZTEST_CHECK-fails otherwise. static bool GetBoolFlag(std::string_view value) { if (value == "0" || value == "false") return false; - CHECK(value == "1" || value == "true") << value; + FUZZTEST_CHECK(value == "1" || value == "true") << value; return true; } -// Returns `value` as a size_t, CHECK-fails on parse error. +// Returns `value` as a size_t, FUZZTEST_CHECK-fails on parse error. static size_t GetIntFlag(std::string_view value) { size_t result{}; - CHECK(std::from_chars(value.data(), value.data() + value.size(), result).ec == - std::errc()) + FUZZTEST_CHECK( + std::from_chars(value.data(), value.data() + value.size(), result).ec == + std::errc()) << value; return result; } @@ -169,7 +168,8 @@ void Environment::SetFlagForExperiment(std::string_view name, return; } - LOG(FATAL) << "Unknown flag for experiment: " << name << "=" << value; + FUZZTEST_LOG(FATAL) << "Unknown flag for experiment: " << name << "=" + << value; } void Environment::UpdateForExperiment() { @@ -183,7 +183,7 @@ void Environment::UpdateForExperiment() { std::vector experiments; for (auto flag : absl::StrSplit(this->experiment, ':', absl::SkipEmpty())) { std::vector flag_and_value = absl::StrSplit(flag, '='); - CHECK_EQ(flag_and_value.size(), 2) << flag; + FUZZTEST_CHECK_EQ(flag_and_value.size(), 2) << flag; experiments.emplace_back( Experiment{flag_and_value[0], absl::StrSplit(flag_and_value[1], ',')}); } @@ -191,15 +191,15 @@ void Environment::UpdateForExperiment() { // Count the number of flag combinations. size_t num_combinations = 1; for (const auto &exp : experiments) { - CHECK_NE(exp.flag_values.size(), 0) << exp.flag_name; + FUZZTEST_CHECK_NE(exp.flag_values.size(), 0) << exp.flag_name; num_combinations *= exp.flag_values.size(); } - CHECK_GT(num_combinations, 0); - CHECK_EQ(num_threads % num_combinations, 0) + FUZZTEST_CHECK_GT(num_combinations, 0); + FUZZTEST_CHECK_EQ(num_threads % num_combinations, 0) << VV(num_threads) << VV(num_combinations); // Update the flags for the current shard and compute experiment_name. - CHECK_LT(my_shard_index, num_threads); + FUZZTEST_CHECK_LT(my_shard_index, num_threads); size_t my_combination_num = my_shard_index % num_combinations; experiment_name.clear(); experiment_flags.clear(); @@ -228,14 +228,14 @@ void Environment::ReadKnobsFileIfSpecified() { if (knobs_file_path.empty()) return; ByteArray knob_bytes; auto *f = ValueOrDie(RemoteFileOpen(knobs_file, "r")); - CHECK(f) << "Failed to open remote file " << knobs_file; - CHECK_OK(RemoteFileRead(f, knob_bytes)); - CHECK_OK(RemoteFileClose(f)); - VLOG(1) << "Knobs: " << knob_bytes.size() << " knobs read from " - << knobs_file; + FUZZTEST_CHECK(f) << "Failed to open remote file " << knobs_file; + FUZZTEST_CHECK_OK(RemoteFileRead(f, knob_bytes)); + FUZZTEST_CHECK_OK(RemoteFileClose(f)); + FUZZTEST_VLOG(1) << "Knobs: " << knob_bytes.size() << " knobs read from " + << knobs_file; knobs.Set(knob_bytes); knobs.ForEachKnob([](std::string_view name, Knobs::value_type value) { - VLOG(1) << "knob " << name << ": " << static_cast(value); + FUZZTEST_VLOG(1) << "knob " << name << ": " << static_cast(value); }); } @@ -248,11 +248,11 @@ void Environment::UpdateWithTargetConfig( // enough. if (max_num_crash_reports == Default().max_num_crash_reports) { max_num_crash_reports = 20; - LOG(INFO) << "Overriding the default max_num_crash_reports to " - << max_num_crash_reports << " for FuzzTest."; + FUZZTEST_LOG(INFO) << "Overriding the default max_num_crash_reports to " + << max_num_crash_reports << " for FuzzTest."; } if (config.jobs != 0) { - CHECK(j == Default().j || j == config.jobs) + FUZZTEST_CHECK(j == Default().j || j == config.jobs) << "Value for --j is inconsistent with the value for jobs in the " "target binary:" << VV(j) << VV(config.jobs); @@ -266,7 +266,7 @@ void Environment::UpdateWithTargetConfig( [&](absl::Duration duration, absl::string_view duration_name) -> size_t { if (duration == absl::InfiniteDuration()) return 0; // Centipede's time-related fields are in seconds, so we need at least 1s. - CHECK_GE(duration, absl::Seconds(1)) + FUZZTEST_CHECK_GE(duration, absl::Seconds(1)) << duration_name << " must not be less than one second"; return static_cast(absl::ToInt64Seconds(duration)); }; @@ -274,9 +274,9 @@ void Environment::UpdateWithTargetConfig( // Update `timeout_per_input` and consequently `timeout_per_batch`. const size_t time_limit_per_input_sec = convert_to_seconds(config.time_limit_per_input, "Time limit per input"); - CHECK(timeout_per_input == 0 || - timeout_per_input == Default().timeout_per_input || - timeout_per_input == time_limit_per_input_sec) + FUZZTEST_CHECK(timeout_per_input == 0 || + timeout_per_input == Default().timeout_per_input || + timeout_per_input == time_limit_per_input_sec) << "Value for --timeout_per_input is inconsistent with the value for " "time_limit_per_input in the target binary:" << VV(timeout_per_input) << VV(config.time_limit_per_input); @@ -300,8 +300,8 @@ void Environment::UpdateWithTargetConfig( constexpr auto bytes_to_mb = [](size_t bytes) { return bytes == 0 ? 0 : (bytes - 1) / 1024 / 1024 + 1; }; - CHECK(rss_limit_mb == Default().rss_limit_mb || - rss_limit_mb == bytes_to_mb(config.rss_limit)) + FUZZTEST_CHECK(rss_limit_mb == Default().rss_limit_mb || + rss_limit_mb == bytes_to_mb(config.rss_limit)) << "Value for --rss_limit_mb is inconsistent with the value for " "rss_limit in the target binary:" << VV(rss_limit_mb) << VV(config.rss_limit); @@ -311,8 +311,8 @@ void Environment::UpdateWithTargetConfig( constexpr auto bytes_to_kb = [](size_t bytes) { return bytes == 0 ? 0 : (bytes - 1) / 1024 + 1; }; - CHECK(stack_limit_kb == Default().stack_limit_kb || - stack_limit_kb == bytes_to_kb(config.stack_limit)) + FUZZTEST_CHECK(stack_limit_kb == Default().stack_limit_kb || + stack_limit_kb == bytes_to_kb(config.stack_limit)) << "Value for --stack_limit_kb is inconsistent with the value for " "stack_limit in the target binary:" << VV(stack_limit_kb) << VV(config.stack_limit); @@ -327,8 +327,8 @@ void Environment::UpdateWithTargetConfig( void Environment::UpdateTimeoutPerBatchIfEqualTo(size_t val) { if (timeout_per_batch != val) return; timeout_per_batch = ComputeTimeoutPerBatch(timeout_per_input, batch_size); - VLOG(1) << "--timeout_per_batch auto-computed: " << timeout_per_batch - << " sec (see --help for details)"; + FUZZTEST_VLOG(1) << "--timeout_per_batch auto-computed: " << timeout_per_batch + << " sec (see --help for details)"; } void Environment::UpdateBinaryHashIfEmpty() { diff --git a/centipede/environment.h b/centipede/environment.h index aeaeb4431..4871fc836 100644 --- a/centipede/environment.h +++ b/centipede/environment.h @@ -56,7 +56,7 @@ struct Environment { Knobs knobs; // Read from a file by `ReadKnobsFileIfSpecified`, see knobs.h. // Defines internal logging level. Set to zero to reduce logging in tests. - // TODO(ussuri): Retire in favor of VLOGs? + // TODO(ussuri): Retire in favor of FUZZTEST_VLOGs? size_t log_level = 1; // Path to a file with PCs. This file is created and the field is set in @@ -103,7 +103,7 @@ struct Environment { // shard 5 will have {foo=2,bar=30}, // and so on. // - // CHECK-fails if the `--experiment` flag is not well-formed, + // FUZZTEST_CHECK-fails if the `--experiment` flag is not well-formed, // or if num_threads is not a multiple of the number of flag combinations // (which is 6 in this example). // @@ -113,7 +113,7 @@ struct Environment { // which means "value #0 is used for foo and value #1 is used for bar". void UpdateForExperiment(); - // Sets flag 'name' to `value` for an experiment. CHECK-fails on + // Sets flag 'name' to `value` for an experiment. FUZZTEST_CHECK-fails on // invalid name/value combination. Used in `UpdateForExperiment()`. void SetFlagForExperiment(std::string_view name, std::string_view value); @@ -121,9 +121,9 @@ struct Environment { // Reads `knobs` from `knobs_file`. Does nothing if the `knobs_file` is empty. void ReadKnobsFileIfSpecified(); - // Updates `this` with `config` obtained from the target binary. CHECK-fails - // if the fields are non-default and inconsistent with the corresponding - // values in `config`. + // Updates `this` with `config` obtained from the target binary. + // FUZZTEST_CHECK-fails if the fields are non-default and inconsistent with + // the corresponding values in `config`. void UpdateWithTargetConfig(const fuzztest::internal::Configuration& config); // If `timeout_per_batch` is `val`, computes it as a function of // `timeout_per_input` and `batch_size` and updates it. Otherwise, leaves it diff --git a/centipede/environment_flags.cc b/centipede/environment_flags.cc index 72b3d1c0a..8db3381dc 100644 --- a/centipede/environment_flags.cc +++ b/centipede/environment_flags.cc @@ -20,8 +20,6 @@ #include #include "absl/flags/flag.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/match.h" #include "absl/strings/str_split.h" #include "absl/time/clock.h" @@ -64,7 +62,7 @@ namespace { absl::Time GetStopAtTime(absl::Time stop_at, absl::Duration stop_after) { const bool stop_at_is_non_default = stop_at != absl::InfiniteFuture(); const bool stop_after_is_non_default = stop_after != absl::InfiniteDuration(); - CHECK_LE(stop_at_is_non_default + stop_after_is_non_default, 1) + FUZZTEST_CHECK_LE(stop_at_is_non_default + stop_after_is_non_default, 1) << "At most one of --stop_at and --stop_after should be specified, " "including via --config file: " << VV(stop_at) << VV(stop_after); @@ -106,12 +104,12 @@ Environment CreateEnvironmentFromFlags(const std::vector &argv) { env_from_flags.num_threads = j; env_from_flags.my_shard_index = 0; } - CHECK_GE(env_from_flags.total_shards, 1); - CHECK_GE(env_from_flags.batch_size, 1); - CHECK_GE(env_from_flags.num_threads, 1); - CHECK_LE(env_from_flags.num_threads, env_from_flags.total_shards); - CHECK_LE(env_from_flags.my_shard_index + env_from_flags.num_threads, - env_from_flags.total_shards) + FUZZTEST_CHECK_GE(env_from_flags.total_shards, 1); + FUZZTEST_CHECK_GE(env_from_flags.batch_size, 1); + FUZZTEST_CHECK_GE(env_from_flags.num_threads, 1); + FUZZTEST_CHECK_LE(env_from_flags.num_threads, env_from_flags.total_shards); + FUZZTEST_CHECK_LE(env_from_flags.my_shard_index + env_from_flags.num_threads, + env_from_flags.total_shards) << VV(env_from_flags.my_shard_index) << VV(env_from_flags.num_threads); if (!argv.empty()) { @@ -126,7 +124,8 @@ Environment CreateEnvironmentFromFlags(const std::vector &argv) { env_from_flags.clang_coverage_binary); if (absl::StrContains(env_from_flags.binary, "@@")) { - LOG(INFO) << "@@ detected; running in standalone mode with batch_size=1"; + FUZZTEST_LOG(INFO) + << "@@ detected; running in standalone mode with batch_size=1"; env_from_flags.has_input_wildcards = true; env_from_flags.batch_size = 1; // TODO(kcc): do we need to check if extra_binaries have @@? diff --git a/centipede/environment_test.cc b/centipede/environment_test.cc index f78c1be79..a906b998d 100644 --- a/centipede/environment_test.cc +++ b/centipede/environment_test.cc @@ -18,8 +18,8 @@ #include #include "gtest/gtest.h" -#include "absl/log/check.h" #include "absl/time/time.h" +#include "./common/logging.h" #include "./fuzztest/internal/configuration.h" namespace fuzztest::internal { @@ -152,7 +152,7 @@ TEST(Environment, UpdatesTimeoutPerBatchFromTargetConfigTimeLimit) { fuzztest::internal::Configuration config; config.time_limit = absl::Seconds(123); config.time_budget_type = fuzztest::internal::TimeBudgetType::kPerTest; - CHECK(config.GetTimeLimitPerTest() == absl::Seconds(123)); + FUZZTEST_CHECK(config.GetTimeLimitPerTest() == absl::Seconds(123)); env.UpdateWithTargetConfig(config); EXPECT_EQ(env.timeout_per_batch, 123) << "`timeout_per_batch` should be set to the test time limit when it was " diff --git a/centipede/feature.h b/centipede/feature.h index 80cee6b26..e69d75688 100644 --- a/centipede/feature.h +++ b/centipede/feature.h @@ -22,7 +22,7 @@ // // This library must not depend on anything other than libc so that fuzz targets // using it doesn't gain redundant coverage. For the same reason this library -// uses raw __builtin_trap instead of CHECKs. +// uses raw __builtin_trap instead of FUZZTEST_CHECKs. // We make an exception for for std::sort/std::unique, // since is very lightweight. // This library is also header-only, with all functions defined as inline. diff --git a/centipede/feature_set.cc b/centipede/feature_set.cc index 09d936132..f13cc5a47 100644 --- a/centipede/feature_set.cc +++ b/centipede/feature_set.cc @@ -21,7 +21,6 @@ #include #include -#include "absl/log/check.h" #include "absl/strings/str_cat.h" #include "./centipede/control_flow.h" #include "./centipede/feature.h" @@ -102,10 +101,10 @@ FeatureSet::ComputeWeight(const FeatureVec &features) const { // The less frequent is the domain, the more valuable are its features. auto domain_id = feature_domains::Domain::FeatureToDomainId(feature); auto features_in_domain = features_per_domain_[domain_id]; - CHECK(features_in_domain); + FUZZTEST_CHECK(features_in_domain); auto domain_weight = num_features_ / features_in_domain; auto feature_frequency = frequencies_[feature]; - CHECK_GT(feature_frequency, 0) + FUZZTEST_CHECK_GT(feature_frequency, 0) << VV(feature) << VV(domain_id) << VV(features_in_domain) << VV(domain_weight) << VV((int)feature_frequency) << DebugString(); weight += domain_weight * (256 / feature_frequency); diff --git a/centipede/feature_set.h b/centipede/feature_set.h index ce0571252..59a53416d 100644 --- a/centipede/feature_set.h +++ b/centipede/feature_set.h @@ -22,10 +22,10 @@ #include #include -#include "absl/log/log.h" #include "./centipede/control_flow.h" #include "./centipede/feature.h" #include "./centipede/util.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -111,7 +111,7 @@ class FeatureSet { size_t domain_id = feature_domains::Domain::FeatureToDomainId(feature); // TODO(b/385774476): Remove this check once the root cause is fixed. if (domain_id >= feature_domains::kNumDomains) { - LOG(ERROR) << "Unexpected feature with id: " << feature; + FUZZTEST_LOG(WARNING) << "Unexpected feature with id: " << feature; return true; } return should_discard_domain_.test(domain_id); diff --git a/centipede/hashed_ring_buffer.h b/centipede/hashed_ring_buffer.h index f7bc64619..86d555cc8 100644 --- a/centipede/hashed_ring_buffer.h +++ b/centipede/hashed_ring_buffer.h @@ -22,7 +22,7 @@ // // This library must not depend on anything other than libc so that fuzz targets // using it doesn't gain redundant coverage. For the same reason this library -// uses raw __builtin_trap instead of CHECKs. +// uses raw __builtin_trap instead of FUZZTEST_CHECKs. // We make an exception for for std::sort/std::unique, // since is very lightweight. // This library is also header-only, with all functions defined as inline. @@ -69,7 +69,8 @@ class HashedRingBuffer { // Resets the current state, sets the ring buffer size to `size_` (<= kSize). void Reset(size_t size) { memset(this, 0, sizeof(*this)); - if (size > kSize) __builtin_trap(); // can't use CHECK in the runner. + if (size > kSize) + __builtin_trap(); // can't use FUZZTEST_CHECK in the runner. size_ = size; hash_.Reset(size); } diff --git a/centipede/minimize_crash.cc b/centipede/minimize_crash.cc index a9c081f4c..66d417a20 100644 --- a/centipede/minimize_crash.cc +++ b/centipede/minimize_crash.cc @@ -23,8 +23,6 @@ #include #include "absl/base/thread_annotations.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/synchronization/mutex.h" #include "./centipede/centipede_callbacks.h" #include "./centipede/environment.h" @@ -65,7 +63,7 @@ struct MinimizerWorkQueue { // The crasher must be smaller than the original one. void AddCrasher(ByteArray crasher) { absl::MutexLock lock(&mutex_); - CHECK_LT(crasher.size(), crashers_.front().size()); + FUZZTEST_CHECK_LT(crasher.size(), crashers_.front().size()); crashers_.emplace_back(crasher); // Write the crasher to disk. auto hash = Hash(crasher); @@ -96,13 +94,14 @@ static void MinimizeCrash(const Environment &env, size_t num_batches = env.num_runs / env.batch_size; for (size_t i = 0; i < num_batches; ++i) { - LOG_EVERY_POW_2(INFO) << "[" << i << "] Minimizing... Interrupt to stop"; + FUZZTEST_LOG_EVERY_POW_2(INFO) + << "[" << i << "] Minimizing... Interrupt to stop"; if (ShouldStop()) break; // Get up to kMaxNumCrashersToGet most recent crashers. We don't want just // the most recent crasher to avoid being stuck in local minimum. constexpr size_t kMaxNumCrashersToGet = 20; const auto recent_crashers = queue.GetRecentCrashers(kMaxNumCrashersToGet); - CHECK(!recent_crashers.empty()); + FUZZTEST_CHECK(!recent_crashers.empty()); // Compute the minimal known crasher size. size_t min_known_size = recent_crashers.front().size(); for (const auto &crasher : recent_crashers) { @@ -125,10 +124,10 @@ static void MinimizeCrash(const Environment &env, // Execute all mutants. If a new crasher is found, add it to `queue`. if (!callbacks->Execute(env.binary, smaller_mutants, batch_result)) { size_t crash_inputs_idx = batch_result.num_outputs_read(); - CHECK_LT(crash_inputs_idx, smaller_mutants.size()); + FUZZTEST_CHECK_LT(crash_inputs_idx, smaller_mutants.size()); const auto &new_crasher = smaller_mutants[crash_inputs_idx]; - LOG(INFO) << "Crasher: size: " << new_crasher.size() << ": " - << AsPrintableString(new_crasher, /*max_len=*/40); + FUZZTEST_LOG(INFO) << "Crasher: size: " << new_crasher.size() << ": " + << AsPrintableString(new_crasher, /*max_len=*/40); queue.AddCrasher(new_crasher); } } @@ -139,17 +138,17 @@ int MinimizeCrash(ByteSpan crashy_input, const Environment &env, ScopedCentipedeCallbacks scoped_callback(callbacks_factory, env); auto callbacks = scoped_callback.callbacks(); - LOG(INFO) << "MinimizeCrash: trying the original crashy input"; + FUZZTEST_LOG(INFO) << "MinimizeCrash: trying the original crashy input"; BatchResult batch_result; ByteArray original_crashy_input(crashy_input.begin(), crashy_input.end()); if (callbacks->Execute(env.binary, {original_crashy_input}, batch_result)) { - LOG(INFO) << "The original crashy input did not crash; exiting"; + FUZZTEST_LOG(INFO) << "The original crashy input did not crash; exiting"; return EXIT_FAILURE; } - LOG(INFO) << "Starting the crash minimization loop in " << env.num_threads - << "threads"; + FUZZTEST_LOG(INFO) << "Starting the crash minimization loop in " + << env.num_threads << "threads"; MinimizerWorkQueue queue(WorkDir{env}.CrashReproducerDirPaths().MyShard(), original_crashy_input); diff --git a/centipede/pc_info.cc b/centipede/pc_info.cc index 9d99cb528..bbabced47 100644 --- a/centipede/pc_info.cc +++ b/centipede/pc_info.cc @@ -20,9 +20,9 @@ #include #include -#include "absl/log/check.h" #include "absl/types/span.h" #include "./common/defs.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -34,11 +34,11 @@ PCTable ReadPcTable(std::istream &in) { std::string input_string(std::istreambuf_iterator(in), {}); ByteArray pc_infos_as_bytes(input_string.begin(), input_string.end()); - CHECK_EQ(pc_infos_as_bytes.size() % sizeof(PCInfo), 0); + FUZZTEST_CHECK_EQ(pc_infos_as_bytes.size() % sizeof(PCInfo), 0); size_t pc_table_size = pc_infos_as_bytes.size() / sizeof(PCInfo); const auto *pc_infos = reinterpret_cast(pc_infos_as_bytes.data()); PCTable pc_table{pc_infos, pc_infos + pc_table_size}; - CHECK_EQ(pc_table.size(), pc_table_size); + FUZZTEST_CHECK_EQ(pc_table.size(), pc_table_size); return pc_table; } diff --git a/centipede/periodic_action.h b/centipede/periodic_action.h index 302d9a07a..8af5b21f4 100644 --- a/centipede/periodic_action.h +++ b/centipede/periodic_action.h @@ -19,7 +19,7 @@ // Example: // MyStats stats = ...; // PeriodicAction stats_logger{ -// [&stats]() { LOG(INFO) << "Current stats are: " << stats; }, +// [&stats]() { FUZZTEST_LOG(INFO) << "Current stats are: " << stats; }, // {.delay = absl::Minutes(5), .interval = absl::Minutes(1)} // }; // while (true) { diff --git a/centipede/resource_pool.cc b/centipede/resource_pool.cc index 28a2aec13..a499a8f1b 100644 --- a/centipede/resource_pool.cc +++ b/centipede/resource_pool.cc @@ -19,14 +19,13 @@ #include // NOLINT: For thread IDs. #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/strings/str_cat.h" #include "absl/synchronization/mutex.h" #include "absl/time/clock.h" #include "absl/time/time.h" #include "./centipede/rusage_stats.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -44,7 +43,7 @@ ResourcePool::LeaseToken::LeaseToken( // template ResourcePool::LeaseToken::~LeaseToken() { - CHECK(status_checked_) // + FUZZTEST_CHECK(status_checked_) // << "status() was never consulted by caller: " << *this; if (status_.ok()) { leaser_.ReturnLease(*this); @@ -88,18 +87,18 @@ absl::Duration ResourcePool::LeaseToken::age() const { template ResourcePool::ResourcePool(const ResourceT& quota) : quota_{quota}, pool_{quota} { - LOG(INFO) << "Creating pool with quota=[" << quota.ShortStr() << "]"; + FUZZTEST_LOG(INFO) << "Creating pool with quota=[" << quota.ShortStr() << "]"; } template typename ResourcePool::LeaseToken ResourcePool::AcquireLeaseBlocking(LeaseRequest&& request) { - if (ABSL_VLOG_IS_ON(1)) { + if (FUZZTEST_VLOG_IS_ON(1)) { absl::ReaderMutexLock lock{&pool_mu_}; - VLOG(1) << "Received lease request " << request.id // - << "\nrequested: " << request.amount.FormattedStr() // - << "\nquota: " << quota_.FormattedStr() // - << "\navailable: " << pool_.FormattedStr(); + FUZZTEST_VLOG(1) << "Received lease request " << request.id // + << "\nrequested: " << request.amount.FormattedStr() // + << "\nquota: " << quota_.FormattedStr() // + << "\navailable: " << pool_.FormattedStr(); } if (request.amount == ResourceT::Zero()) { @@ -123,7 +122,7 @@ ResourcePool::AcquireLeaseBlocking(LeaseRequest&& request) { pool_mu_.AssertReaderHeld(); const bool got_pool = request.amount <= pool_; if (!got_pool) { - VLOG(10) // + FUZZTEST_VLOG(10) // << "Pending lease '" << request.id << "':" // << "\nreq age : " << request.age() // << "\navailable : " << pool_.FormattedStr() // @@ -138,7 +137,7 @@ ResourcePool::AcquireLeaseBlocking(LeaseRequest&& request) { // the timeout is reached, proceed to the else-branch. if (pool_mu_.LockWhenWithTimeout( // absl::Condition{&got_enough_free_pool}, request.timeout)) { - VLOG(1) // + FUZZTEST_VLOG(1) // << "Granting lease " << request.id // << "\nreq age : " << request.age() // << "\nbefore : " << pool_.FormattedStr() // @@ -161,7 +160,7 @@ ResourcePool::AcquireLeaseBlocking(LeaseRequest&& request) { template void ResourcePool::ReturnLease(const LeaseToken& lease) { absl::WriterMutexLock lock{&pool_mu_}; - VLOG(1) // + FUZZTEST_VLOG(1) // << "Returning lease " << lease.request().id // << "\nreq age : " << lease.request().age() // << "\nlease age : " << lease.age() // diff --git a/centipede/resource_pool.h b/centipede/resource_pool.h index 241150f13..c33a8fff5 100644 --- a/centipede/resource_pool.h +++ b/centipede/resource_pool.h @@ -76,7 +76,7 @@ namespace fuzztest::internal { // .amount = RUsageMemory{.mem_rss = EstimateShardPeakRss()}, // .timeout = absl::Minutes(10), // }); -// CHECK_OK(rss_lease.status()); +// FUZZTEST_CHECK_OK(rss_lease.status()); // ... // } // // `rss_lease` dtor returns the leased RSS to `rss_pool` and unblocks @@ -138,7 +138,7 @@ class ResourcePool { // The outcome of resource acquisition (ie. of // `ResourcePool::AcquireLeaseBlocking()`). Must be consulted by the client - // at least once, otherwise the dtor will CHECK. + // at least once, otherwise the dtor will FUZZTEST_CHECK. const absl::Status& status() const; // The originating request. const LeaseRequest& request() const; diff --git a/centipede/resource_pool_test.cc b/centipede/resource_pool_test.cc index 23bf03bbb..c5b3f5ea7 100644 --- a/centipede/resource_pool_test.cc +++ b/centipede/resource_pool_test.cc @@ -21,7 +21,6 @@ #include #include "gtest/gtest.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/time/clock.h" #include "absl/time/time.h" diff --git a/centipede/runner_fork_server.cc b/centipede/runner_fork_server.cc index 7467f9467..db99a7e72 100644 --- a/centipede/runner_fork_server.cc +++ b/centipede/runner_fork_server.cc @@ -84,8 +84,8 @@ void Log(const char *absl_nonnull str) { } // Maybe writes the `reason` to stderr; then calls _exit. We use this instead of -// CHECK/RunnerCheck since the fork server runs at the very early stage of the -// process, where the logging functions used there may not work. +// FUZZTEST_CHECK/RunnerCheck since the fork server runs at the very early stage +// of the process, where the logging functions used there may not work. void Exit(const char *absl_nonnull reason) { Log(reason); _exit(0); // The exit code does not matter, it won't be checked anyway. diff --git a/centipede/runner_utils.h b/centipede/runner_utils.h index ff3b0443f..efa2b1016 100644 --- a/centipede/runner_utils.h +++ b/centipede/runner_utils.h @@ -26,7 +26,7 @@ namespace fuzztest::internal { // as it is a more common pattern. void PrintErrorAndExitIf(bool condition, const char* absl_nonnull error); -// A rough equivalent of "CHECK(condition) << error;". +// A rough equivalent of "FUZZTEST_CHECK(condition) << error;". inline void RunnerCheck(bool condition, const char* absl_nonnull error) { PrintErrorAndExitIf(!condition, error); } diff --git a/centipede/rusage_profiler.cc b/centipede/rusage_profiler.cc index ae994637a..a8b2ec4da 100644 --- a/centipede/rusage_profiler.cc +++ b/centipede/rusage_profiler.cc @@ -29,8 +29,6 @@ #include "absl/base/attributes.h" #include "absl/base/const_init.h" #include "absl/base/nullability.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/synchronization/mutex.h" @@ -38,6 +36,7 @@ #include "absl/time/time.h" #include "./centipede/periodic_action.h" #include "./centipede/rusage_stats.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -102,7 +101,7 @@ std::string RUsageProfiler::Snapshot::ShortMetricsStr() const { const RUsageProfiler::Snapshot& RUsageProfiler::Snapshot::Log() const { if (id >= 0) { - LOG(INFO).AtLocation(location.file, location.line) + FUZZTEST_LOG(INFO).AtLocation(location.file, location.line) << "PROFILER [P." << profiler_id << (profiler_desc.empty() ? "" : " ") << profiler_desc << "] SNAPSHOT [S." << id << (title.empty() ? "" : " ") << title << "]:\n" @@ -214,7 +213,7 @@ class ProfileReportGenerator { low_water >= kZero ? 0 : std::floor(std::abs(low_water / notch_size)); // clang-format on - CHECK_GE(kBarNotches, notch_zero); + FUZZTEST_CHECK_GE(kBarNotches, notch_zero); // Print a zero mark only if a delta metric goes negative. std::string zero_mark = low_water < kZero ? "|" : ""; @@ -231,7 +230,7 @@ class ProfileReportGenerator { notch_size == kZero ? kBarNotches : std::floor((current - low_water) / notch_size); // clang-format on - CHECK_GE(kBarNotches, notches); + FUZZTEST_CHECK_GE(kBarNotches, notches); if (!is_delta) { // Non-delta metrics can't go negative, so the bar always looks like @@ -422,7 +421,7 @@ void RUsageProfiler::StartTimelapse( // bool also_log, // std::string title) { absl::WriterMutexLock lock{&mutex_}; - CHECK(!timelapse_recorder_) << "StopTimelapse() wasn't called"; + FUZZTEST_CHECK(!timelapse_recorder_) << "StopTimelapse() wasn't called"; timelapse_recorder_ = std::make_unique( [this, loc = std::move(loc), title = std::move(title), also_log]() { const auto& s = TakeSnapshot(loc, title); @@ -433,7 +432,7 @@ void RUsageProfiler::StartTimelapse( // void RUsageProfiler::StopTimelapse() { absl::WriterMutexLock lock{&mutex_}; - CHECK(timelapse_recorder_) << "StartTimelapse() wasn't called"; + FUZZTEST_CHECK(timelapse_recorder_) << "StartTimelapse() wasn't called"; timelapse_recorder_.reset(); } @@ -441,30 +440,31 @@ void RUsageProfiler::PrintReport( // SourceLocation loc, const std::string& title) { if (metrics_ == kMetricsOff) return; - // Logs streamed-in text to LOG(INFO), while dropping the usual log prefix - // (date/time/thread/source). LOG()'s limit on the size of a single message - // applies to one streamed text fragment only (if needed, this can be reduced - // even further to a single line of text in a fragment): this is the main - // purpose of this class, as profiling reports can get very long. especially - // with automatic timelapse snapshotting. + // Logs streamed-in text to FUZZTEST_LOG(INFO), while dropping the usual log + // prefix (date/time/thread/source). FUZZTEST_LOG()'s limit on the size of a + // single message applies to one streamed text fragment only (if needed, this + // can be reduced even further to a single line of text in a fragment): this + // is the main purpose of this class, as profiling reports can get very long. + // especially with automatic timelapse snapshotting. class ReportLogger final : public ReportSink { public: ReportLogger(SourceLocation loc) : loc_{loc} {} ~ReportLogger() override { if (!buffer_.empty()) { - LOG(INFO).AtLocation(loc_.file, loc_.line).NoPrefix() << buffer_; + FUZZTEST_LOG(INFO).AtLocation(loc_.file, loc_.line).NoPrefix() + << buffer_; } } ReportLogger& operator<<(std::string_view fragment) override { const auto last_newline = fragment.rfind('\n'); if (last_newline == std::string_view::npos) { - // Accumulate no-'\n' fragments: LOG() always wraps around. + // Accumulate no-'\n' fragments: FUZZTEST_LOG() always wraps around. buffer_ += fragment; } else { // Now we can log, but save the last bit of text - LOG(INFO).AtLocation(loc_.file, loc_.line).NoPrefix() + FUZZTEST_LOG(INFO).AtLocation(loc_.file, loc_.line).NoPrefix() << buffer_ << fragment.substr(0, last_newline); buffer_ = fragment.substr(last_newline + 1); } @@ -476,7 +476,7 @@ void RUsageProfiler::PrintReport( // std::string buffer_; }; - LOG(INFO).AtLocation(loc.file, loc.line) << title << "\n"; + FUZZTEST_LOG(INFO).AtLocation(loc.file, loc.line) << title << "\n"; ReportLogger report_logger{loc}; GenerateReport(&report_logger); } diff --git a/centipede/rusage_profiler.h b/centipede/rusage_profiler.h index 7e12b9639..a45e6d37d 100644 --- a/centipede/rusage_profiler.h +++ b/centipede/rusage_profiler.h @@ -106,18 +106,21 @@ // ... // profiler.TakeSnapshot(ABSL_LOC).Log(); // Records and logs a snapshot // ... -// VLOG(1) << profiler.TakeSnapshot(ABSL_LOC); // A different way to log +// FUZZTEST_VLOG(1) << profiler.TakeSnapshot(ABSL_LOC); // A different way +// to log // ... // } // Dtor logs a final snapshot // // EXAMPLE USAGE - MACROS // // void foo() { -// RPROF_THIS_FUNCTION(VLOG_IS_ON(2)); // Profile the function @ --v>=2 +// RPROF_THIS_FUNCTION(FUZZTEST_VLOG_IS_ON(2)); // Profile the function @ +// --v>=2 // ... -// RPROF_SNAPSHOT_AND_LOG(); // Record and log a function-level snapshot -// for (...) { -// RPROF_THIS_SCOPE(VLOG_IS_ON(3)); // Profile loop iterations @ --v>=3 +// RPROF_SNAPSHOT_AND_FUZZTEST_LOG(); // Record and log a function-level +// snapshot for (...) { +// RPROF_THIS_SCOPE(FUZZTEST_VLOG_IS_ON(3)); // Profile loop iterations +// @ --v>=3 // ... // } // RPROF_SNAPSHOT(); // Record (not log) another function-level snapshot @@ -261,9 +264,9 @@ class RUsageProfiler { // table-like formatting. std::string ShortMetricsStr() const; - // Logs this snapshot to LOG(INFO). The source location that annotates the - // log message is set to `location` instead of the actual call's location. - // Returns *this so clients can do either of + // Logs this snapshot to FUZZTEST_LOG(INFO). The source location that + // annotates the log message is set to `location` instead of the actual + // call's location. Returns *this so clients can do either of // Snapshot s = profiler.TakeSnapshot(); // Snapshot s = profiler.TakeSnapshot().Log(); const Snapshot& Log() const; @@ -289,8 +292,8 @@ class RUsageProfiler { }; // An abstract interface used to stream in a profiling report in - // GenerateReport(). Also used inside PrintReport() to overcome the LOG()'s - // limitation on the size of a single printed message. + // GenerateReport(). Also used inside PrintReport() to overcome the + // FUZZTEST_LOG()'s limitation on the size of a single printed message. class ReportSink { public: virtual ~ReportSink() = default; @@ -529,7 +532,7 @@ class RUsageProfiler { // earlier RPROF_THIS_FUNCTION() in the same function. An optional snapshot // title can be passed as a macro argument. // clang-format off -#define RPROF_SNAPSHOT_AND_LOG(...) \ +#define RPROF_SNAPSHOT_AND_FUZZTEST_LOG(...) \ FUNCTION_LEVEL_RPROF_NAME.TakeSnapshot( \ {__FILE__, __LINE__}, ##__VA_ARGS__).Log() // clang-format on @@ -550,7 +553,7 @@ class RUsageProfiler { // RPROF_THIS_FUNCTION in the same function. An optional report title can be // passed as a macro argument. // clang-format off -#define RPROF_DUMP_REPORT_TO_LOG(...) \ +#define RPROF_DUMP_REPORT_TO_FUZZTEST_LOG(...) \ FUNCTION_LEVEL_RPROF_NAME.PrintReport({__FILE__, __LINE__}, ##__VA_ARGS__) // clang-format on diff --git a/centipede/rusage_profiler_test.cc b/centipede/rusage_profiler_test.cc index 3960dd4e1..c8c0b9f78 100644 --- a/centipede/rusage_profiler_test.cc +++ b/centipede/rusage_profiler_test.cc @@ -23,10 +23,10 @@ #include "gtest/gtest.h" #include "absl/flags/flag.h" -#include "absl/log/log.h" #include "absl/time/clock.h" #include "absl/time/time.h" #include "./centipede/rusage_stats.h" +#include "./common/logging.h" ABSL_FLAG(bool, verbose, false, "Print extra info for debugging"); ABSL_FLAG(bool, enable_system_load_sensitive_tests, false, @@ -99,7 +99,7 @@ TEST(RUsageProfilerTest, TimelapseSnapshots) { RPROF_START_TIMELAPSE(absl::Seconds(1), /*also_log=*/true, "Timelapse"); WasteTimeAndGobbleBytes(); RPROF_STOP_TIMELAPSE(); - RPROF_DUMP_REPORT_TO_LOG("Report"); + RPROF_DUMP_REPORT_TO_FUZZTEST_LOG("Report"); } // NOTE: Exclude this test from MSAN: 1) MSAN messes with the system memory @@ -144,16 +144,18 @@ TEST(RUsageProfilerTest, ValidateManualSnapshots) { const RUsageMemory delta_memory = after_memory - before_memory; if (absl::GetFlag(FLAGS_verbose)) { - LOG(INFO) << "before_snapshot:\n" << before_snapshot.FormattedMetricsStr(); - LOG(INFO) << "after_snapshot:\n" << after_snapshot.FormattedMetricsStr(); - LOG(INFO) << ""; - LOG(INFO) << "before_timing: " << before_timing.FormattedStr(); - LOG(INFO) << "after_timing: " << after_timing.FormattedStr(); - LOG(INFO) << "delta_timing: " << delta_timing.FormattedStr(); - LOG(INFO) << ""; - LOG(INFO) << "before_memory: " << before_memory.FormattedStr(); - LOG(INFO) << "after_memory: " << after_memory.FormattedStr(); - LOG(INFO) << "delta_memory: " << delta_memory.FormattedStr(); + FUZZTEST_LOG(INFO) << "before_snapshot:\n" + << before_snapshot.FormattedMetricsStr(); + FUZZTEST_LOG(INFO) << "after_snapshot:\n" + << after_snapshot.FormattedMetricsStr(); + FUZZTEST_LOG(INFO) << ""; + FUZZTEST_LOG(INFO) << "before_timing: " << before_timing.FormattedStr(); + FUZZTEST_LOG(INFO) << "after_timing: " << after_timing.FormattedStr(); + FUZZTEST_LOG(INFO) << "delta_timing: " << delta_timing.FormattedStr(); + FUZZTEST_LOG(INFO) << ""; + FUZZTEST_LOG(INFO) << "before_memory: " << before_memory.FormattedStr(); + FUZZTEST_LOG(INFO) << "after_memory: " << after_memory.FormattedStr(); + FUZZTEST_LOG(INFO) << "delta_memory: " << delta_memory.FormattedStr(); } EXPECT_EQ(after_snapshot.delta_timing, @@ -172,7 +174,8 @@ TEST(RUsageProfilerTest, ValidateManualSnapshots) { EXPECT_SYS_TIMING_NEAR(after_snapshot.timing, after_timing); // EXPECT_SYS_TIMING_NEAR(after_snapshot.delta_timing, delta_timing); #else - LOG(WARNING) << "Validation of some test results omitted under *SANs"; + FUZZTEST_LOG(WARNING) + << "Validation of some test results omitted under *SANs"; #endif if (absl::GetFlag(FLAGS_enable_system_load_sensitive_tests)) { @@ -207,7 +210,8 @@ TEST(RUsageProfilerTest, ValidateTimelapseSnapshots) { EXPECT_TIME_NEAR(snapshots[i].time - snapshots[i - 1].time, kInterval, .05); } #else - LOG(WARNING) << "Validation of some test results omitted under *SANs"; + FUZZTEST_LOG(WARNING) + << "Validation of some test results omitted under *SANs"; #endif } @@ -232,7 +236,7 @@ TEST(RUsageProfilerTest, ValidateReport) { public: ~ReportCapture() override = default; ReportCapture& operator<<(std::string_view fragment) override { - LOG(INFO).NoPrefix() << fragment; + FUZZTEST_LOG(INFO).NoPrefix() << fragment; return *this; } }; diff --git a/centipede/rusage_stats.cc b/centipede/rusage_stats.cc index 8ca674bcd..ec5df9d8e 100644 --- a/centipede/rusage_stats.cc +++ b/centipede/rusage_stats.cc @@ -39,11 +39,11 @@ #include // NOLINT: For hardware_concurrency() only. #include "absl/base/nullability.h" -#include "absl/log/check.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/time/clock.h" #include "absl/time/time.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -102,7 +102,7 @@ class RUsageScope::PlatformInfo { // Returns a path to the /proc// or /proc//task//. [[nodiscard]] const std::string& GetProcFilePath(ProcFile file) const { - CHECK_LT(file, proc_file_paths_.size()); + FUZZTEST_CHECK_LT(file, proc_file_paths_.size()); return proc_file_paths_[file]; } @@ -366,7 +366,8 @@ RUsageTiming RUsageTiming::Snapshot( // int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, scope.info().pid()}; struct kinfo_proc info = {}; size_t size = sizeof(info); - CHECK(sysctl(mib, sizeof(mib) / sizeof(mib[0]), &info, &size, NULL, 0) == 0) + FUZZTEST_CHECK( + sysctl(mib, sizeof(mib) / sizeof(mib[0]), &info, &size, NULL, 0) == 0) << "Error getting process information: " << strerror(errno); cpu_utilization = info.kp_proc.p_pctcpu; #else // __APPLE__ @@ -429,7 +430,7 @@ RUsageTiming operator+(const RUsageTiming& t1, const RUsageTiming& t2) { } RUsageTiming operator/(const RUsageTiming& t, int64_t div) { - CHECK_NE(div, 0); + FUZZTEST_CHECK_NE(div, 0); // NOTE: Can't use RUsageTimingOp() as this operation is asymmetrical. // clang-format off return RUsageTiming{ @@ -519,13 +520,13 @@ RUsageMemory RUsageMemory::Snapshot(const RUsageScope& scope) { #ifdef __APPLE__ if (scope.info().pid() != getpid()) return {}; struct proc_taskinfo pti = {}; - CHECK(proc_pidinfo(scope.info().pid(), PROC_PIDTASKINFO, 0, &pti, - PROC_PIDTASKINFO_SIZE) == PROC_PIDTASKINFO_SIZE) + FUZZTEST_CHECK(proc_pidinfo(scope.info().pid(), PROC_PIDTASKINFO, 0, &pti, + PROC_PIDTASKINFO_SIZE) == PROC_PIDTASKINFO_SIZE) << "Unable to get system resource information"; vsize = pti.pti_virtual_size; rss = pti.pti_resident_size; struct rusage rusage = {}; - CHECK(getrusage(RUSAGE_SELF, &rusage) == 0) + FUZZTEST_CHECK(getrusage(RUSAGE_SELF, &rusage) == 0) << "Failed to get memory stats by getrusage"; // `data` and `shared` are not supported in MacOS. // MacOS does not have a builtin way to query the peak size of virtual memory. @@ -608,7 +609,7 @@ RUsageMemory operator+(const RUsageMemory& m1, const RUsageMemory& m2) { } RUsageMemory operator/(const RUsageMemory& m, int64_t div) { - CHECK_NE(div, 0); + FUZZTEST_CHECK_NE(div, 0); // NOTE: Can't use RUsageMemoryOp() as this operation is asymmetrical. // clang-format off return RUsageMemory{ diff --git a/centipede/rusage_stats.h b/centipede/rusage_stats.h index ad6d04e73..d0d1cde58 100644 --- a/centipede/rusage_stats.h +++ b/centipede/rusage_stats.h @@ -31,8 +31,8 @@ #include #include -#include "absl/log/check.h" #include "absl/time/time.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -78,7 +78,7 @@ class RUsageScope { const PlatformInfo& info() const { // This can fail only when called after the object is moved. - CHECK(info_ != nullptr); + FUZZTEST_CHECK(info_ != nullptr); return *info_; } diff --git a/centipede/rusage_stats_test.cc b/centipede/rusage_stats_test.cc index 6d4ea5516..69d1a76b2 100644 --- a/centipede/rusage_stats_test.cc +++ b/centipede/rusage_stats_test.cc @@ -23,7 +23,6 @@ #include "gtest/gtest.h" #include "absl/base/nullability.h" #include "absl/flags/flag.h" -#include "absl/log/log.h" #include "absl/synchronization/barrier.h" #include "absl/synchronization/mutex.h" #include "absl/synchronization/notification.h" @@ -208,9 +207,9 @@ TEST(RUsageTimingTest, Accuracy) { } if (absl::GetFlag(FLAGS_verbose)) { - LOG(INFO) << "before: " << before; - LOG(INFO) << "after: " << after; - LOG(INFO) << "delta: " << delta; + FUZZTEST_LOG(INFO) << "before: " << before; + FUZZTEST_LOG(INFO) << "after: " << after; + FUZZTEST_LOG(INFO) << "delta: " << delta; } EXPECT_EQ(delta.user_time, after.user_time - before.user_time); @@ -220,10 +219,10 @@ TEST(RUsageTimingTest, Accuracy) { if (absl::GetFlag(FLAGS_enable_system_load_sensitive_tests)) { if (absl::GetFlag(FLAGS_verbose)) { - LOG(INFO) << "user_time_histo:\n" << user_time_histo; - LOG(INFO) << "cpu_util_histo:\n" << cpu_util_histo; - LOG(INFO) << "wall_time_histo:\n" << wall_time_histo; - LOG(INFO) << "cpu_cores_histo:\n" << cpu_cores_histo; + FUZZTEST_LOG(INFO) << "user_time_histo:\n" << user_time_histo; + FUZZTEST_LOG(INFO) << "cpu_util_histo:\n" << cpu_util_histo; + FUZZTEST_LOG(INFO) << "wall_time_histo:\n" << wall_time_histo; + FUZZTEST_LOG(INFO) << "cpu_cores_histo:\n" << cpu_cores_histo; } EXPECT_NEAR( // @@ -260,9 +259,9 @@ TEST(RUsageMemoryTest, Accuracy) { const auto delta = after - before; if (absl::GetFlag(FLAGS_verbose)) { - LOG(INFO) << "before: " << before; - LOG(INFO) << "after: " << after; - LOG(INFO) << "delta: " << delta; + FUZZTEST_LOG(INFO) << "before: " << before; + FUZZTEST_LOG(INFO) << "after: " << after; + FUZZTEST_LOG(INFO) << "delta: " << delta; } // NOTE: The sanitizers heavily instrument the code and skew any time @@ -280,15 +279,16 @@ TEST(RUsageMemoryTest, Accuracy) { EXPECT_LE(before.mem_rss, before.mem_vsize); EXPECT_LE(after.mem_rss, after.mem_vsize); #else - LOG(WARNING) << "Validation of test results omitted under *SAN: see code"; + FUZZTEST_LOG(WARNING) + << "Validation of test results omitted under *SAN: see code"; #endif mem_rss_histo.Add(delta.mem_rss); mem_data_histo.Add(delta.mem_data); } if (absl::GetFlag(FLAGS_verbose)) { - LOG(INFO) << "mem_rss_histo:\n" << mem_rss_histo; - LOG(INFO) << "mem_data_histo:\n" << mem_data_histo; + FUZZTEST_LOG(INFO) << "mem_rss_histo:\n" << mem_rss_histo; + FUZZTEST_LOG(INFO) << "mem_data_histo:\n" << mem_data_histo; } // NOTE: The sanitizers heavily instrument the code and skew any time @@ -302,22 +302,19 @@ TEST(RUsageMemoryTest, Accuracy) { EXPECT_NEAR(mem_data_histo.Average(), kBytes, kDataLeeway) << mem_data_histo; #endif #else - LOG(WARNING) << "Validation of test results omitted under *SAN: see code"; + FUZZTEST_LOG(WARNING) + << "Validation of test results omitted under *SAN: see code"; #endif } TEST(RUsageMemoryTest, BadScope) { constexpr pid_t kBadPid = 999999999; EXPECT_NO_FATAL_FAILURE( // - const auto timing = - RUsageTiming::Snapshot(RUsageScope::Process(kBadPid)); - VLOG(1) << "Timing: " << timing; - ); + const auto timing = RUsageTiming::Snapshot(RUsageScope::Process(kBadPid)); + FUZZTEST_VLOG(1) << "Timing: " << timing;); EXPECT_NO_FATAL_FAILURE( // - const auto memory = - RUsageMemory::Snapshot(RUsageScope::Process(kBadPid)); - VLOG(1) << "Memory: " << memory; - ); + const auto memory = RUsageMemory::Snapshot(RUsageScope::Process(kBadPid)); + FUZZTEST_VLOG(1) << "Memory: " << memory;); } TEST(RUsageTimingTest, ConstantsAndMath) { diff --git a/centipede/seed_corpus_maker.cc b/centipede/seed_corpus_maker.cc index 695ce07e0..01830d87c 100644 --- a/centipede/seed_corpus_maker.cc +++ b/centipede/seed_corpus_maker.cc @@ -18,35 +18,35 @@ #include "absl/base/nullability.h" #include "absl/flags/flag.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "./centipede/config_init.h" #include "./centipede/seed_corpus_maker_flags.h" #include "./centipede/seed_corpus_maker_proto_lib.h" #include "./centipede/util.h" +#include "./common/logging.h" #include "./common/remote_file.h" int main(int argc, char** absl_nonnull argv) { (void)fuzztest::internal::InitRuntime(argc, argv); const std::string config = absl::GetFlag(FLAGS_config); - QCHECK(!config.empty()); + FUZZTEST_QCHECK(!config.empty()); const std::string override_out_dir = absl::GetFlag(FLAGS_override_out_dir); const std::string binary_path = absl::GetFlag(FLAGS_coverage_binary_path); const std::string binary_name = std::filesystem::path{binary_path}.filename(); - QCHECK(!binary_name.empty()) + FUZZTEST_QCHECK(!binary_name.empty()) << "--coverage_binary_path yields empty basename"; std::string binary_hash = absl::GetFlag(FLAGS_coverage_binary_hash); if (binary_hash.empty()) { - QCHECK(fuzztest::internal::RemotePathExists(binary_path)) + FUZZTEST_QCHECK(fuzztest::internal::RemotePathExists(binary_path)) << "--coverage_binary_path doesn't exist"; binary_hash = fuzztest::internal::HashOfFileContents(binary_path); - LOG(INFO) << "--coverage_binary_hash was not provided: computed " - << binary_hash - << " from actual file at --coverage_binary_path=" << binary_path; + FUZZTEST_LOG(INFO) << "--coverage_binary_hash was not provided: computed " + << binary_hash + << " from actual file at --coverage_binary_path=" + << binary_path; } - QCHECK_OK(fuzztest::internal::GenerateSeedCorpusFromConfigProto( // + FUZZTEST_QCHECK_OK(fuzztest::internal::GenerateSeedCorpusFromConfigProto( // config, binary_name, binary_hash, override_out_dir)); return EXIT_SUCCESS; diff --git a/centipede/seed_corpus_maker_lib.cc b/centipede/seed_corpus_maker_lib.cc index 0a3c70171..f1f588f4b 100644 --- a/centipede/seed_corpus_maker_lib.cc +++ b/centipede/seed_corpus_maker_lib.cc @@ -37,8 +37,6 @@ #include #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/random/random.h" #include "absl/status/status.h" #include "absl/strings/match.h" @@ -71,7 +69,7 @@ namespace { std::string ShardPathsForLogging( // const std::string& corpus_fname, const std::string& features_fname) { - if (ABSL_VLOG_IS_ON(3)) { + if (FUZZTEST_VLOG_IS_ON(3)) { return absl::StrCat( // ":\nCorpus: ", corpus_fname, "\nFeatures:", features_fname); } @@ -93,13 +91,15 @@ absl::Status SampleSeedCorpusElementsFromSource( // coverage_binary_name, ", and ", coverage_binary_hash)); } - RPROF_THIS_FUNCTION_WITH_TIMELAPSE( // - /*enable=*/ABSL_VLOG_IS_ON(1), // - /*timelapse_interval=*/absl::Seconds(ABSL_VLOG_IS_ON(2) ? 10 : 60), // - /*also_log_timelapses=*/ABSL_VLOG_IS_ON(10)); + RPROF_THIS_FUNCTION_WITH_TIMELAPSE( // + /*enable=*/FUZZTEST_VLOG_IS_ON(1), // + /*timelapse_interval=*/ + absl::Seconds(FUZZTEST_VLOG_IS_ON(2) ? 10 : 60), // + /*also_log_timelapses=*/FUZZTEST_VLOG_IS_ON(10)); - LOG(INFO) << "Reading/sampling seed corpus elements from source glob: " - << source.dir_glob; + FUZZTEST_LOG(INFO) + << "Reading/sampling seed corpus elements from source glob: " + << source.dir_glob; // Find `source.dir_glob()`-matching dirs and pick at most // `source.num_recent_dirs()` most recent ones. @@ -109,14 +109,14 @@ absl::Status SampleSeedCorpusElementsFromSource( // !match_status.ok() && !absl::IsNotFound(match_status)) { return match_status; } - LOG(INFO) << "Found " << src_dirs.size() << " corpus dir(s) matching " - << source.dir_glob; + FUZZTEST_LOG(INFO) << "Found " << src_dirs.size() + << " corpus dir(s) matching " << source.dir_glob; // Sort in the ascending lexicographical order. We expect that dir names // contain timestamps and therefore will be sorted from oldest to newest. std::sort(src_dirs.begin(), src_dirs.end(), std::less()); if (source.num_recent_dirs < src_dirs.size()) { src_dirs.erase(src_dirs.begin(), src_dirs.end() - source.num_recent_dirs); - LOG(INFO) << "Selected " << src_dirs.size() << " corpus dir(s)"; + FUZZTEST_LOG(INFO) << "Selected " << src_dirs.size() << " corpus dir(s)"; } // Find all the corpus shard and individual input files in the found dirs. @@ -130,16 +130,16 @@ absl::Status SampleSeedCorpusElementsFromSource( // const std::string glob = fs::path{dir} / source.shard_rel_glob; const auto match_status = RemoteGlobMatch(glob, matched_fnames); if (!match_status.ok() && !absl::IsNotFound(match_status)) { - LOG(ERROR) << "Got error when glob-matching in " << dir << ": " - << match_status; + FUZZTEST_LOG(ERROR) << "Got error when glob-matching in " << dir << ": " + << match_status; } else { current_corpus_shard_fnames.insert(matched_fnames.begin(), matched_fnames.end()); corpus_shard_fnames.insert(corpus_shard_fnames.end(), matched_fnames.begin(), matched_fnames.end()); - LOG(INFO) << "Found " << matched_fnames.size() << " shard(s) matching " - << glob; + FUZZTEST_LOG(INFO) << "Found " << matched_fnames.size() + << " shard(s) matching " << glob; } } if (!source.individual_input_rel_glob.empty()) { @@ -147,8 +147,8 @@ absl::Status SampleSeedCorpusElementsFromSource( // const std::string glob = fs::path{dir} / source.individual_input_rel_glob; const auto match_status = RemoteGlobMatch(glob, matched_fnames); if (!match_status.ok() && !absl::IsNotFound(match_status)) { - LOG(ERROR) << "Got error when glob-matching in " << dir << ": " - << match_status; + FUZZTEST_LOG(ERROR) << "Got error when glob-matching in " << dir << ": " + << match_status; } else { size_t num_added_individual_inputs = 0; for (auto& fname : matched_fnames) { @@ -157,17 +157,18 @@ absl::Status SampleSeedCorpusElementsFromSource( // ++num_added_individual_inputs; individual_input_fnames.push_back(std::move(fname)); } - LOG(INFO) << "Found " << num_added_individual_inputs - << " individual input(s) with glob " << glob; + FUZZTEST_LOG(INFO) << "Found " << num_added_individual_inputs + << " individual input(s) with glob " << glob; } } } - LOG(INFO) << "Found " << corpus_shard_fnames.size() << " shard(s) and " - << individual_input_fnames.size() - << " individual input(s) total in source " << source.dir_glob; + FUZZTEST_LOG(INFO) << "Found " << corpus_shard_fnames.size() + << " shard(s) and " << individual_input_fnames.size() + << " individual input(s) total in source " + << source.dir_glob; if (corpus_shard_fnames.empty() && individual_input_fnames.empty()) { - LOG(WARNING) << "Skipping empty source " << source.dir_glob; + FUZZTEST_LOG(WARNING) << "Skipping empty source " << source.dir_glob; return absl::OkStatus(); } @@ -205,8 +206,8 @@ absl::Status SampleSeedCorpusElementsFromSource( // ? work_dir.DistilledFeaturesFilePaths().MyShard() : ""; - VLOG(2) << "Reading elements from source shard " << shard - << ShardPathsForLogging(corpus_fname, features_fname); + FUZZTEST_VLOG(2) << "Reading elements from source shard " << shard + << ShardPathsForLogging(corpus_fname, features_fname); ReadShard(corpus_fname, features_fname, [shard, &shard_elts, &shard_elts_with_features]( // @@ -219,21 +220,23 @@ absl::Status SampleSeedCorpusElementsFromSource( // ++shard_elts_with_features; } shard_elts.emplace_back(input, std::move(features)); - VLOG_EVERY_N(10, 100000) + FUZZTEST_VLOG_EVERY_N(10, 100000) << "Read " << shard_elts.size() << " elements from shard " << shard << " so far"; }); - LOG(INFO) << "Read " << shard_elts.size() << " elements (" - << shard_elts_with_features - << " with computed features) from source shard " << shard - << ShardPathsForLogging(corpus_fname, features_fname); + FUZZTEST_LOG(INFO) << "Read " << shard_elts.size() << " elements (" + << shard_elts_with_features + << " with computed features) from source shard " + << shard + << ShardPathsForLogging(corpus_fname, + features_fname); }; threads.Schedule(read_shard); } - RPROF_SNAPSHOT_AND_LOG("Done reading shards"); + RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done reading shards"); src_elts.resize(individual_input_fnames.size()); for (size_t index = 0; index < individual_input_fnames.size(); ++index) { @@ -242,8 +245,8 @@ absl::Status SampleSeedCorpusElementsFromSource( // const auto& path = individual_input_fnames[index]; const auto read_status = RemoteFileGetContents(path, input); if (!read_status.ok()) { - LOG(WARNING) << "Skipping individual input path " << path - << " due to read error: " << read_status; + FUZZTEST_LOG(WARNING) << "Skipping individual input path " << path + << " due to read error: " << read_status; return; } src_elts[index] = {std::move(input), {}}; @@ -251,7 +254,7 @@ absl::Status SampleSeedCorpusElementsFromSource( // } } - RPROF_SNAPSHOT_AND_LOG("Done reading"); + RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done reading"); size_t src_num_features = 0; @@ -270,21 +273,22 @@ absl::Status SampleSeedCorpusElementsFromSource( // src_elts_with_features_per_shard.clear(); src_elts_with_features_per_shard.shrink_to_fit(); - RPROF_SNAPSHOT_AND_LOG("Done merging"); + RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done merging"); // Remove empty inputs possibly due to read errors. auto remove_it = std::remove_if(src_elts.begin(), src_elts.end(), [](const auto& elt) { return std::get<0>(elt).empty(); }); if (remove_it != src_elts.end()) { - LOG(WARNING) << "Removed " << std::distance(remove_it, src_elts.end()) - << " empty inputs"; + FUZZTEST_LOG(WARNING) << "Removed " + << std::distance(remove_it, src_elts.end()) + << " empty inputs"; src_elts.erase(remove_it, src_elts.end()); } - LOG(INFO) << "Read total of " << src_elts.size() << " elements (" - << src_num_features << " with features) from source " - << source.dir_glob; + FUZZTEST_LOG(INFO) << "Read total of " << src_elts.size() << " elements (" + << src_num_features << " with features) from source " + << source.dir_glob; // Extract a sample of the elements of the size specified in // `source.sample_size`. @@ -306,10 +310,10 @@ absl::Status SampleSeedCorpusElementsFromSource( // } if (sample_size < src_elts.size()) { - LOG(INFO) << "Sampling " << sample_size << " elements out of " - << src_elts.size(); + FUZZTEST_LOG(INFO) << "Sampling " << sample_size << " elements out of " + << src_elts.size(); } else { - LOG(INFO) << "Using all " << src_elts.size() << " elements"; + FUZZTEST_LOG(INFO) << "Using all " << src_elts.size() << " elements"; } // Extract a sample by shuffling the elements' indices and resizing to the @@ -321,7 +325,7 @@ absl::Status SampleSeedCorpusElementsFromSource( // std::shuffle(src_sample_idxs.begin(), src_sample_idxs.end(), absl::BitGen{}); src_sample_idxs.resize(sample_size); - RPROF_SNAPSHOT_AND_LOG("Done sampling"); + RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done sampling"); // Now move each sampled element from `src_elts` to `elements`. elements.reserve(elements.size() + sample_size); @@ -329,7 +333,7 @@ absl::Status SampleSeedCorpusElementsFromSource( // elements.emplace_back(std::move(src_elts[idx])); } - RPROF_SNAPSHOT_AND_LOG("Done appending"); + RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done appending"); return absl::OkStatus(); } @@ -356,13 +360,15 @@ absl::Status WriteSeedCorpusElementsToDestination( // "Unable to write seed corpus to empty destination path"); } - RPROF_THIS_FUNCTION_WITH_TIMELAPSE( // - /*enable=*/ABSL_VLOG_IS_ON(1), // - /*timelapse_interval=*/absl::Seconds(ABSL_VLOG_IS_ON(2) ? 10 : 60), // - /*also_log_timelapses=*/ABSL_VLOG_IS_ON(10)); + RPROF_THIS_FUNCTION_WITH_TIMELAPSE( // + /*enable=*/FUZZTEST_VLOG_IS_ON(1), // + /*timelapse_interval=*/ + absl::Seconds(FUZZTEST_VLOG_IS_ON(2) ? 10 : 60), // + /*also_log_timelapses=*/FUZZTEST_VLOG_IS_ON(10)); - LOG(INFO) << "Writing " << elements.size() - << " seed corpus elements to destination: " << destination.dir_path; + FUZZTEST_LOG(INFO) << "Writing " << elements.size() + << " seed corpus elements to destination: " + << destination.dir_path; if (destination.num_shards <= 0) { return absl::InvalidArgumentError( @@ -379,7 +385,7 @@ absl::Status WriteSeedCorpusElementsToDestination( // // first N shards. const size_t num_shards = std::min(destination.num_shards, elements.size()); - CHECK_GT(num_shards, 0); + FUZZTEST_CHECK_GT(num_shards, 0); const size_t shard_size = elements.size() / num_shards; std::vector shard_sizes(num_shards, shard_size); const size_t excess_elts = elements.size() % num_shards; @@ -402,7 +408,7 @@ absl::Status WriteSeedCorpusElementsToDestination( // const auto elt_range_begin = shard_elt_it; std::advance(shard_elt_it, shard_size); const auto elt_range_end = shard_elt_it; - CHECK(shard_elt_it <= elements.cend()) << VV(shard); + FUZZTEST_CHECK(shard_elt_it <= elements.cend()) << VV(shard); const auto write_shard = [shard, elt_range_begin, elt_range_end, coverage_binary_name, coverage_binary_hash, @@ -436,11 +442,12 @@ absl::Status WriteSeedCorpusElementsToDestination( // work_dir.CorpusFilePaths().IsShard(corpus_fname) ? work_dir.FeaturesFilePaths().MyShard() : work_dir.DistilledFeaturesFilePaths().MyShard(); - CHECK(!features_fname.empty()); + FUZZTEST_CHECK(!features_fname.empty()); - VLOG(2) << "Writing " << std::distance(elt_range_begin, elt_range_end) - << " elements to destination shard " << shard - << ShardPathsForLogging(corpus_fname, features_fname); + FUZZTEST_VLOG(2) << "Writing " + << std::distance(elt_range_begin, elt_range_end) + << " elements to destination shard " << shard + << ShardPathsForLogging(corpus_fname, features_fname); // Features files are always saved in a subdir of the workdir // (== `destination.dir_path` here), which might not exist yet, so we @@ -463,12 +470,12 @@ absl::Status WriteSeedCorpusElementsToDestination( // const std::unique_ptr corpus_writer = DefaultBlobFileWriterFactory(); - CHECK(corpus_writer != nullptr); + FUZZTEST_CHECK(corpus_writer != nullptr); RETURN_IF_NOT_OK(corpus_writer->Open(corpus_fname, "w")); const std::unique_ptr features_writer = DefaultBlobFileWriterFactory(); - CHECK(features_writer != nullptr); + FUZZTEST_CHECK(features_writer != nullptr); RETURN_IF_NOT_OK(features_writer->Open(features_fname, "w")); // Write the shard's elements to the corpus and features shard files. @@ -486,10 +493,12 @@ absl::Status WriteSeedCorpusElementsToDestination( // } } - LOG(INFO) << "Wrote " << std::distance(elt_range_begin, elt_range_end) - << " elements (" << shard_elts_with_features - << " with features) to destination shard " << shard - << ShardPathsForLogging(corpus_fname, features_fname); + FUZZTEST_LOG(INFO) << "Wrote " + << std::distance(elt_range_begin, elt_range_end) + << " elements (" << shard_elts_with_features + << " with features) to destination shard " << shard + << ShardPathsForLogging(corpus_fname, + features_fname); dst_elts_with_features += shard_elts_with_features; @@ -506,10 +515,10 @@ absl::Status WriteSeedCorpusElementsToDestination( // RETURN_IF_NOT_OK(write_status); } - LOG(INFO) << "Wrote total of " << elements.size() << " elements (" - << dst_elts_with_features - << " with precomputed features) to destination " - << destination.dir_path; + FUZZTEST_LOG(INFO) << "Wrote total of " << elements.size() << " elements (" + << dst_elts_with_features + << " with precomputed features) to destination " + << destination.dir_path; return absl::OkStatus(); } @@ -524,19 +533,19 @@ absl::Status GenerateSeedCorpusFromConfig( // RETURN_IF_NOT_OK(SampleSeedCorpusElementsFromSource( // source, coverage_binary_name, coverage_binary_hash, elements)); } - LOG(INFO) << "Sampled " << elements.size() << " elements from " - << config.sources.size() << " seed corpus source(s)"; + FUZZTEST_LOG(INFO) << "Sampled " << elements.size() << " elements from " + << config.sources.size() << " seed corpus source(s)"; // Write the sampled elements to the destination. if (elements.empty()) { - LOG(WARNING) + FUZZTEST_LOG(WARNING) << "No elements to write to seed corpus destination - doing nothing"; } else { RETURN_IF_NOT_OK(WriteSeedCorpusElementsToDestination( // elements, coverage_binary_name, coverage_binary_hash, config.destination)); - LOG(INFO) << "Wrote " << elements.size() - << " elements to seed corpus destination"; + FUZZTEST_LOG(INFO) << "Wrote " << elements.size() + << " elements to seed corpus destination"; } return absl::OkStatus(); } diff --git a/centipede/seed_corpus_maker_lib_test.cc b/centipede/seed_corpus_maker_lib_test.cc index 2be35f0eb..d749ca39b 100644 --- a/centipede/seed_corpus_maker_lib_test.cc +++ b/centipede/seed_corpus_maker_lib_test.cc @@ -25,7 +25,6 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/log/check.h" #include "absl/strings/str_cat.h" #include "./centipede/feature.h" #include "./centipede/workdir.h" @@ -207,7 +206,7 @@ TEST(SeedCorpusMakerLibTest, LoadsBothIndividualInputsAndShardsFromSource) { /*shard_index_digits=*/kIdxDigits, /*num_shards=*/kNumShards, }; - CHECK_OK(WriteSeedCorpusElementsToDestination( // + FUZZTEST_CHECK_OK(WriteSeedCorpusElementsToDestination( // kShardedInputs, kCovBin, kCovHash, destination)); const std::string workdir = (test_dir / kRelDir).c_str(); ASSERT_NO_FATAL_FAILURE(VerifyShardsExist( // @@ -218,7 +217,8 @@ TEST(SeedCorpusMakerLibTest, LoadsBothIndividualInputsAndShardsFromSource) { for (int i = 0; i < kIndividualInputs.size(); ++i) { const auto path = std::filesystem::path(test_dir) / kRelDir / absl::StrCat("individual_input_", i); - CHECK_OK(RemoteFileSetContents(path.string(), kIndividualInputs[i])); + FUZZTEST_CHECK_OK( + RemoteFileSetContents(path.string(), kIndividualInputs[i])); } // Test that sharded and individual inputs matches what we wrote. diff --git a/centipede/seed_corpus_maker_proto_lib.cc b/centipede/seed_corpus_maker_proto_lib.cc index 80ae4c934..fd44c5853 100644 --- a/centipede/seed_corpus_maker_proto_lib.cc +++ b/centipede/seed_corpus_maker_proto_lib.cc @@ -19,7 +19,6 @@ #include #include -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" @@ -48,16 +47,18 @@ absl::StatusOr ResolveSeedCorpusConfigProto( // } if (RemotePathExists(config_spec)) { - LOG(INFO) << "Config spec points at an existing file; trying to parse " - "textproto config from it: " - << VV(config_spec); + FUZZTEST_LOG(INFO) + << "Config spec points at an existing file; trying to parse " + "textproto config from it: " + << VV(config_spec); RETURN_IF_NOT_OK(RemoteFileGetContents(config_spec, config_str)); - LOG(INFO) << "Raw config read from file:\n" << config_str; + FUZZTEST_LOG(INFO) << "Raw config read from file:\n" << config_str; base_dir = std::filesystem::path{config_spec}.parent_path(); } else { - LOG(INFO) << "Config spec is not a file, or file doesn't exist; trying to " - "parse textproto config verbatim: " - << VV(config_spec); + FUZZTEST_LOG(INFO) + << "Config spec is not a file, or file doesn't exist; trying to " + "parse textproto config verbatim: " + << VV(config_spec); config_str = config_spec; base_dir = fs::current_path(); } @@ -73,7 +74,7 @@ absl::StatusOr ResolveSeedCorpusConfigProto( // "destination, config_spec: ", config_spec, ", config: ", config)); } - LOG(INFO) << "Parsed config:\n" << config; + FUZZTEST_LOG(INFO) << "Parsed config:\n" << config; // Resolve relative `source.dir_glob`s in the config to absolute ones. for (auto& src : *config.mutable_sources()) { @@ -99,7 +100,7 @@ absl::StatusOr ResolveSeedCorpusConfigProto( // WorkDir::kDigitsInShardIndex); } - LOG(INFO) << "Resolved config:\n" << config; + FUZZTEST_LOG(INFO) << "Resolved config:\n" << config; return config; } @@ -164,7 +165,7 @@ absl::Status GenerateSeedCorpusFromConfigProto( // const proto::SeedCorpusConfig config_proto, ResolveSeedCorpusConfigProto(config_spec, override_out_dir)); if (config_proto.sources_size() == 0 || !config_proto.has_destination()) { - LOG(WARNING) << "Config is empty: skipping seed corpus generation"; + FUZZTEST_LOG(WARNING) << "Config is empty: skipping seed corpus generation"; return absl::OkStatus(); } RETURN_IF_NOT_OK(DumpConfigProtoToDebugDir(config_proto, coverage_binary_name, diff --git a/centipede/stats.cc b/centipede/stats.cc index 748c6f5cb..50225ed3f 100644 --- a/centipede/stats.cc +++ b/centipede/stats.cc @@ -34,8 +34,6 @@ #include #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/ascii.h" #include "absl/strings/match.h" #include "absl/strings/str_cat.h" @@ -60,7 +58,7 @@ using TraitBits = Stats::TraitBits; StatsReporter::StatsReporter(const std::vector> &stats_vec, const std::vector &env_vec) : stats_vec_{stats_vec}, env_vec_{env_vec} { - CHECK_EQ(stats_vec.size(), env_vec.size()); + FUZZTEST_CHECK_EQ(stats_vec.size(), env_vec.size()); for (size_t i = 0; i < env_vec.size(); ++i) { const auto &env = env_vec[i]; group_to_indices_[env.experiment_name].push_back(i); @@ -162,7 +160,8 @@ void StatsLogger::ReportFlags(const GroupToFlags &group_to_flags) { } void StatsLogger::DoneFieldSamplesBatch() { - LOG(INFO) << "Current stats:\n" << absl::StripAsciiWhitespace(os_.str()); + FUZZTEST_LOG(INFO) << "Current stats:\n" + << absl::StripAsciiWhitespace(os_.str()); // Reset the stream for the next round of logging. os_.str(""); } @@ -173,7 +172,7 @@ void StatsLogger::DoneFieldSamplesBatch() { StatsCsvFileAppender::~StatsCsvFileAppender() { if (files_ == nullptr) return; for (const auto &[group_name, file] : *files_) { - CHECK_OK(RemoteFileClose(file.file)); + FUZZTEST_CHECK_OK(RemoteFileClose(file.file)); } } @@ -195,7 +194,7 @@ void StatsCsvFileAppender::PreAnnounceFields( } void StatsCsvFileAppender::SetCurrGroup(const Environment &master_env) { - CHECK(files_ != nullptr); + FUZZTEST_CHECK(files_ != nullptr); BufferedRemoteFile &file = (*files_)[master_env.experiment_name]; if (file.file == nullptr) { const std::string filename = @@ -208,20 +207,21 @@ void StatsCsvFileAppender::SetCurrGroup(const Environment &master_env) { bool append = false; if (RemotePathExists(filename)) { std::string contents; - CHECK_OK(RemoteFileGetContents(filename, contents)); + FUZZTEST_CHECK_OK(RemoteFileGetContents(filename, contents)); // NOTE: `csv_header_` ends with '\n', so the match is exact. if (absl::StartsWith(contents, csv_header_)) { append = true; } else { append = false; - CHECK_OK(RemoteFileSetContents(GetBackupFilename(filename), contents)); + FUZZTEST_CHECK_OK( + RemoteFileSetContents(GetBackupFilename(filename), contents)); } } file.file = *RemoteFileOpen(filename, append ? "a" : "w"); - CHECK(file.file != nullptr) << VV(filename); + FUZZTEST_CHECK(file.file != nullptr) << VV(filename); if (!append) { - CHECK_OK(RemoteFileAppend(file.file, csv_header_)); - CHECK_OK(RemoteFileFlush(file.file)); + FUZZTEST_CHECK_OK(RemoteFileAppend(file.file, csv_header_)); + FUZZTEST_CHECK_OK(RemoteFileFlush(file.file)); } } // This is OK even though hash maps provide no pointer stability because the @@ -245,7 +245,7 @@ void StatsCsvFileAppender::ReportCurrFieldSample( } double avg = !values.empty() ? (1.0 * sum / values.size()) : 0; - CHECK(curr_file_ != nullptr); + FUZZTEST_CHECK(curr_file_ != nullptr); std::string &values_str = curr_file_->buffer; if (curr_field_info_.traits & TraitBits::kMin) absl::StrAppendFormat(&values_str, "%" PRIu64 ",", min); @@ -263,10 +263,11 @@ void StatsCsvFileAppender::ReportFlags(const GroupToFlags &group_to_flags) { } void StatsCsvFileAppender::DoneFieldSamplesBatch() { - CHECK(files_ != nullptr); + FUZZTEST_CHECK(files_ != nullptr); for (auto &[group_name, file] : *files_) { - CHECK_OK(RemoteFileAppend(file.file, absl::StrCat(file.buffer, "\n"))); - CHECK_OK(RemoteFileFlush(file.file)); + FUZZTEST_CHECK_OK( + RemoteFileAppend(file.file, absl::StrCat(file.buffer, "\n"))); + FUZZTEST_CHECK_OK(RemoteFileFlush(file.file)); file.buffer.clear(); } } @@ -286,7 +287,7 @@ std::string StatsCsvFileAppender::GetBackupFilename( void PrintRewardValues(absl::Span> stats_vec, std::ostream &os) { size_t n = stats_vec.size(); - CHECK_GT(n, 0); + FUZZTEST_CHECK_GT(n, 0); std::vector num_covered_pcs(n); for (size_t i = 0; i < n; ++i) { num_covered_pcs[i] = stats_vec[i].load().num_covered_pcs; diff --git a/centipede/stats.h b/centipede/stats.h index 603afcc26..635533d60 100644 --- a/centipede/stats.h +++ b/centipede/stats.h @@ -514,8 +514,9 @@ class StatsReporter { inline StatsReporter::StatsReporter(StatsReporter &&) noexcept = default; // Takes a set of `Stats` objects and a corresponding set of `Environment` -// objects and logs the current `Stats` values to LOG(INFO) on each invocation -// of `ReportCurrStats()`. If the environments indicate the use of the +// objects and logs the current `Stats` values to FUZZTEST_LOG(INFO) on each +// invocation of `ReportCurrStats()`. If the environments indicate the use of +// the // --experiment flag, the stats for each of the experiment are juxtaposed for // easy visual comparison. class StatsLogger : public StatsReporter { diff --git a/centipede/stats_test.cc b/centipede/stats_test.cc index d21221a84..491a428d9 100644 --- a/centipede/stats_test.cc +++ b/centipede/stats_test.cc @@ -25,7 +25,6 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/log/check.h" #include "absl/log/log_entry.h" #include "absl/log/log_sink.h" #include "absl/log/log_sink_registry.h" @@ -847,7 +846,8 @@ TEST(Stats, DumpStatsToExistingCsvFile) { ReadFromLocalFile(kExpectedCsvBak, contents_bak); const std::vector lines_bak = absl::StrSplit(contents_bak, '\n'); - CHECK_NE(lines.size(), kFakeOldCsvLines.size()); // Prevent false positives + FUZZTEST_CHECK_NE(lines.size(), + kFakeOldCsvLines.size()); // Prevent false positives EXPECT_EQ(lines_bak.size(), kFakeOldCsvLines.size()); } } diff --git a/centipede/symbol_table.cc b/centipede/symbol_table.cc index d6aecb4ba..2168c00a1 100644 --- a/centipede/symbol_table.cc +++ b/centipede/symbol_table.cc @@ -27,8 +27,6 @@ #include #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/match.h" #include "absl/strings/numbers.h" #include "absl/strings/str_cat.h" @@ -68,13 +66,15 @@ void SymbolTable::ReadFromLLVMSymbolizer(std::istream &in) { if (lines_view.size() == 1 && lines_view.back().empty()) return; while (!lines_view.empty()) { - CHECK_GE(lines_view.size(), 3) << "Unexpected symbolizer output format."; + FUZZTEST_CHECK_GE(lines_view.size(), 3) + << "Unexpected symbolizer output format."; std::string_view func = lines_view[0]; std::string_view file = lines_view[1]; std::string_view empty = lines_view[2]; - CHECK(empty.empty()) << "Unexpected symbolizer output format: " << VV(func) - << VV(file) << VV(empty); + FUZZTEST_CHECK(empty.empty()) + << "Unexpected symbolizer output format: " << VV(func) << VV(file) + << VV(empty); for (auto &useless_prefix : {"/proc/self/cwd/", "./"}) { file = absl::StripPrefix(file, useless_prefix); } @@ -113,8 +113,8 @@ void SymbolTable::GetSymbolsFromOneDso(absl::Span pc_infos, WriteToLocalFile(pcs_file.path(), pcs_string); // Run the symbolizer. - LOG(INFO) << "Symbolizing " << pc_infos.size() << " PCs from " - << dso_basename; + FUZZTEST_LOG(INFO) << "Symbolizing " << pc_infos.size() << " PCs from " + << dso_basename; Command::Options cmd_options; cmd_options.args = { "--no-inlines", @@ -127,8 +127,9 @@ void SymbolTable::GetSymbolsFromOneDso(absl::Span pc_infos, Command cmd{symbolizer_path, std::move(cmd_options)}; int exit_code = cmd.Execute(); if (exit_code != EXIT_SUCCESS) { - LOG(ERROR) << "Symbolization failed, debug symbols will not be used: " - << VV(dso_path) << VV(cmd.ToString()) << VV(exit_code); + FUZZTEST_LOG(ERROR) + << "Symbolization failed, debug symbols will not be used: " + << VV(dso_path) << VV(cmd.ToString()) << VV(exit_code); return; } @@ -139,9 +140,10 @@ void SymbolTable::GetSymbolsFromOneDso(absl::Span pc_infos, size_t new_size = size(); size_t added_size = new_size - old_size; if (added_size != pc_infos.size()) { - LOG(ERROR) << "Symbolization failed: debug symbols will not be used: " - << VV(dso_path) << VV(cmd.ToString()) << VV(exit_code) - << VV(pc_infos.size()) << VV(added_size); + FUZZTEST_LOG(ERROR) + << "Symbolization failed: debug symbols will not be used: " + << VV(dso_path) << VV(cmd.ToString()) << VV(exit_code) + << VV(pc_infos.size()) << VV(added_size); } } @@ -152,12 +154,14 @@ void SymbolTable::GetSymbolsFromBinary(const PCTable &pc_table, // NOTE: --symbolizer_path=/dev/null is a somewhat expected alternative to // "" that users might pass. if (symbolizer_path.empty() || symbolizer_path == "/dev/null") { - LOG(WARNING) << "Symbolizer unspecified: debug symbols will not be used"; + FUZZTEST_LOG(WARNING) + << "Symbolizer unspecified: debug symbols will not be used"; SetAllToUnknown(pc_table.size()); return; } - LOG(INFO) << "Symbolizing " << dso_table.size() << " instrumented DSOs."; + FUZZTEST_LOG(INFO) << "Symbolizing " << dso_table.size() + << " instrumented DSOs."; // Iterate all DSOs, symbolize their respective PCs. // Symbolizing the PCs can take time, so we @@ -173,7 +177,8 @@ void SymbolTable::GetSymbolsFromBinary(const PCTable &pc_table, for (size_t dso_id = 0; dso_id < dso_table.size(); ++dso_id) { const auto &dso_info = dso_table[dso_id]; auto &symbol_table = symbol_tables[dso_id]; - CHECK_LE(pc_idx_begin + dso_info.num_instrumented_pcs, pc_table.size()) + FUZZTEST_CHECK_LE(pc_idx_begin + dso_info.num_instrumented_pcs, + pc_table.size()) << VV(pc_idx_begin) << VV(dso_info.num_instrumented_pcs); const absl::Span pc_infos = {pc_table.data() + pc_idx_begin, dso_info.num_instrumented_pcs}; @@ -188,7 +193,7 @@ void SymbolTable::GetSymbolsFromBinary(const PCTable &pc_table, for (const auto &table : symbol_tables) { AddEntries(table); } - CHECK_EQ(pc_idx_begin, pc_table.size()); + FUZZTEST_CHECK_EQ(pc_idx_begin, pc_table.size()); if (size() != pc_table.size()) { // Something went wrong. Set symbols to unknown so the sizes of pc_table and @@ -214,19 +219,19 @@ void SymbolTable::AddEntry(std::string_view func, } const std::vector file_line_col_split = absl::StrSplit(file_line_col, ':'); - CHECK_LE(file_line_col_split.size(), 3); - CHECK_GE(file_line_col_split.size(), 1) + FUZZTEST_CHECK_LE(file_line_col_split.size(), 3); + FUZZTEST_CHECK_GE(file_line_col_split.size(), 1) << "Unexpected symbolizer input format when getting source location: " << file_line_col; int line = -1; int col = -1; if (file_line_col_split.size() >= 2) { - CHECK(absl::SimpleAtoi(file_line_col_split[1], &line)) + FUZZTEST_CHECK(absl::SimpleAtoi(file_line_col_split[1], &line)) << "Unable to convert line number string to an int: " << file_line_col_split[1]; } if (file_line_col_split.size() == 3) { - CHECK(absl::SimpleAtoi(file_line_col_split[2], &col)) + FUZZTEST_CHECK(absl::SimpleAtoi(file_line_col_split[2], &col)) << "Unable to convert column number string to an int: " << file_line_col_split[2]; } diff --git a/centipede/test_coverage_util.cc b/centipede/test_coverage_util.cc index d65dff0e0..e499179d6 100644 --- a/centipede/test_coverage_util.cc +++ b/centipede/test_coverage_util.cc @@ -18,7 +18,6 @@ #include #include -#include "absl/log/check.h" #include "./centipede/corpus.h" #include "./centipede/environment.h" #include "./centipede/feature.h" @@ -46,7 +45,7 @@ std::vector RunInputsAndCollectCorpusRecords( // Repackage execution results into a vector of CorpusRecords. std::vector corpus_records; std::vector &execution_results = batch_result.results(); - CHECK_EQ(byte_array_inputs.size(), execution_results.size()); + FUZZTEST_CHECK_EQ(byte_array_inputs.size(), execution_results.size()); corpus_records.reserve(byte_array_inputs.size()); for (int i = 0; i < byte_array_inputs.size(); ++i) { diff --git a/centipede/test_coverage_util.h b/centipede/test_coverage_util.h index 6a9b5d593..c06a9bf7a 100644 --- a/centipede/test_coverage_util.h +++ b/centipede/test_coverage_util.h @@ -21,7 +21,6 @@ #include #include -#include "absl/log/check.h" #include "./centipede/centipede_callbacks.h" #include "./centipede/corpus.h" #include "./centipede/environment.h" @@ -48,7 +47,7 @@ class TestCallbacks : public CentipedeCallbacks { BatchResult &batch_result) override { int result = ExecuteCentipedeSancovBinaryWithShmem(binary, inputs, batch_result); - CHECK_EQ(EXIT_SUCCESS, result); + FUZZTEST_CHECK_EQ(EXIT_SUCCESS, result); return true; } std::vector Mutate(const std::vector &inputs, diff --git a/centipede/thread_pool.h b/centipede/thread_pool.h index a742ba682..7c228012d 100644 --- a/centipede/thread_pool.h +++ b/centipede/thread_pool.h @@ -24,7 +24,6 @@ #include "absl/base/thread_annotations.h" #include "absl/functional/any_invocable.h" -#include "absl/log/check.h" #include "absl/synchronization/mutex.h" namespace fuzztest::internal { @@ -60,7 +59,7 @@ class ThreadPool { // Schedules a function to be run on a ThreadPool thread immediately. void Schedule(absl::AnyInvocable func) { - CHECK(func != nullptr); + FUZZTEST_CHECK(func != nullptr); absl::MutexLock l{&mu_}; queue_.push(std::move(func)); } diff --git a/centipede/util.cc b/centipede/util.cc index c5e1b7466..988f25eae 100644 --- a/centipede/util.cc +++ b/centipede/util.cc @@ -45,7 +45,6 @@ #include "absl/base/const_init.h" #include "absl/base/nullability.h" #include "absl/base/thread_annotations.h" -#include "absl/log/check.h" #include "absl/strings/str_format.h" #include "absl/strings/str_replace.h" #include "absl/strings/str_split.h" @@ -86,11 +85,11 @@ void ReadFromLocalFile(std::string_view file_path, Container &data) { f.seekg(0, std::ios_base::end); auto size = f.tellg(); f.seekg(0, std::ios_base::beg); - CHECK_EQ(size % sizeof(data[0]), 0); + FUZZTEST_CHECK_EQ(size % sizeof(data[0]), 0); data.resize(size / sizeof(data[0])); f.read(reinterpret_cast(data.data()), size); - CHECK(f) << "Failed to read from local file: " << VV(file_path) << VV(f.eof()) - << VV(f.bad()) << VV(f.fail()) << VV(size); + FUZZTEST_CHECK(f) << "Failed to read from local file: " << VV(file_path) + << VV(f.eof()) << VV(f.bad()) << VV(f.fail()) << VV(size); f.close(); } @@ -110,15 +109,15 @@ void ReadFromLocalFile(std::string_view file_path, void ClearLocalFileContents(std::string_view file_path) { std::ofstream f(std::string{file_path}, std::ios::out | std::ios::trunc); - CHECK(f) << "Failed to clear the file: " << file_path; + FUZZTEST_CHECK(f) << "Failed to clear the file: " << file_path; } void WriteToLocalFile(std::string_view file_path, ByteSpan data) { std::ofstream f(std::string{file_path}); - CHECK(f) << "Failed to open local file: " << file_path; + FUZZTEST_CHECK(f) << "Failed to open local file: " << file_path; f.write(reinterpret_cast(data.data()), static_cast(data.size())); - CHECK(f) << "Failed to write to local file: " << file_path; + FUZZTEST_CHECK(f) << "Failed to write to local file: " << file_path; f.close(); } @@ -140,14 +139,14 @@ void WriteToLocalHashedFileInDir(std::string_view dir_path, ByteSpan data) { void WriteToRemoteHashedFileInDir(std::string_view dir_path, ByteSpan data) { if (dir_path.empty()) return; std::string file_path = std::filesystem::path(dir_path).append(Hash(data)); - CHECK_OK( + FUZZTEST_CHECK_OK( RemoteFileSetContents(file_path, std::string(data.begin(), data.end()))); } std::string HashOfFileContents(std::string_view file_path) { if (file_path.empty()) return ""; std::string file_contents; - CHECK_OK(RemoteFileGetContents(file_path, file_contents)); + FUZZTEST_CHECK_OK(RemoteFileGetContents(file_path, file_contents)); return Hash(file_contents); } @@ -183,7 +182,7 @@ static void RemoveDirsAtExit() { void CreateLocalDirRemovedAtExit(std::string_view path) { // Safeguard against removing dirs not created by TemporaryLocalDirPath(). - CHECK_NE(path.find("/centipede-"), std::string::npos); + FUZZTEST_CHECK_NE(path.find("/centipede-"), std::string::npos); // Create the dir. std::filesystem::remove_all(path); std::filesystem::create_directories(path); @@ -202,12 +201,12 @@ ScopedFile::ScopedFile(std::string_view dir_path, std::string_view name) ScopedFile::~ScopedFile() { std::filesystem::remove_all(my_path_); } void AppendHashToArray(ByteArray &ba, std::string_view hash) { - CHECK_EQ(hash.size(), kHashLen); + FUZZTEST_CHECK_EQ(hash.size(), kHashLen); ba.insert(ba.end(), hash.begin(), hash.end()); } std::string ExtractHashFromArray(ByteArray &ba) { - CHECK_GE(ba.size(), kHashLen); + FUZZTEST_CHECK_GE(ba.size(), kHashLen); std::string res; res.insert(res.end(), ba.end() - kHashLen, ba.end()); ba.resize(ba.size() - kHashLen); @@ -223,7 +222,7 @@ ByteArray PackFeaturesAndHashAsRawBytes(const ByteArray &data, ByteSpan features) { ByteArray feature_bytes_with_hash(features.size() + kHashLen); auto hash = Hash(data); - CHECK_EQ(hash.size(), kHashLen); + FUZZTEST_CHECK_EQ(hash.size(), kHashLen); memcpy(feature_bytes_with_hash.data(), features.data(), features.size()); memcpy(feature_bytes_with_hash.data() + features.size(), hash.data(), kHashLen); @@ -350,13 +349,13 @@ std::vector RandomWeightedSubset(absl::Span set, uint8_t *MmapNoReserve(size_t size) { auto result = mmap(0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0); - CHECK(result != MAP_FAILED); + FUZZTEST_CHECK(result != MAP_FAILED); return reinterpret_cast(result); } void Munmap(uint8_t *ptr, size_t size) { auto result = munmap(ptr, size); - CHECK_EQ(result, 0); + FUZZTEST_CHECK_EQ(result, 0); } } // namespace fuzztest::internal diff --git a/centipede/util.h b/centipede/util.h index 1f31e4023..93ca1cbd4 100644 --- a/centipede/util.h +++ b/centipede/util.h @@ -23,10 +23,10 @@ #include #include "absl/base/nullability.h" -#include "absl/log/check.h" #include "absl/types/span.h" #include "./centipede/feature.h" #include "./common/defs.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -158,13 +158,13 @@ bool ParseAFLDictionary(std::string_view dictionary_text, std::vector &dictionary_entries); // Maps `size` bytes with `mmap(NO_RESERVE)` or equivalent, returns the result. -// CHECK-fails on error. +// FUZZTEST_CHECK-fails on error. // The resulting memory is unreserved, and will be zero-initialized on first // access. uint8_t *MmapNoReserve(size_t size); // Unmaps memory returned by `MmapNoReserve`(). -// CHECK-fails on error. +// FUZZTEST_CHECK-fails on error. void Munmap(uint8_t *ptr, size_t size); // Fixed size array allocated/deallocated with MmapNoReserve/Munmap. @@ -179,11 +179,11 @@ class MmapNoReserveArray { MmapNoReserveArray(MmapNoReserveArray &&) = delete; MmapNoReserveArray &operator=(MmapNoReserveArray &&) = delete; uint8_t operator[](size_t i) const { - CHECK_LT(i, kSize); + FUZZTEST_CHECK_LT(i, kSize); return array_[i]; } uint8_t &operator[](size_t i) { - CHECK_LT(i, kSize); + FUZZTEST_CHECK_LT(i, kSize); return array_[i]; } diff --git a/centipede/util_test.cc b/centipede/util_test.cc index 792c9f9d0..7be77e88c 100644 --- a/centipede/util_test.cc +++ b/centipede/util_test.cc @@ -24,11 +24,11 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/container/flat_hash_map.h" -#include "absl/log/log.h" #include "./centipede/feature.h" #include "./centipede/thread_pool.h" #include "./common/defs.h" #include "./common/hash.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -106,7 +106,7 @@ TEST(UtilTest, TemporaryLocalDirPath) { { // Check that repeated calls return the same path. auto temp_dir = TemporaryLocalDirPath(); - LOG(INFO) << temp_dir; + FUZZTEST_LOG(INFO) << temp_dir; EXPECT_EQ(temp_dir, TemporaryLocalDirPath()); } diff --git a/centipede/workdir.cc b/centipede/workdir.cc index 59b2e0fd0..c0f4090d6 100644 --- a/centipede/workdir.cc +++ b/centipede/workdir.cc @@ -23,8 +23,6 @@ #include #include -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/match.h" #include "absl/strings/numbers.h" #include "absl/strings/str_cat.h" @@ -46,7 +44,7 @@ inline constexpr std::string_view kDistilledCorpusShardStemPrefix = std::string NormalizeAnnotation(std::string_view annotation) { std::string ret; if (!annotation.empty()) { - CHECK_NE(annotation.front(), '.'); + FUZZTEST_CHECK_NE(annotation.front(), '.'); ret = absl::StrCat(".", annotation); } return ret; @@ -101,15 +99,16 @@ WorkDir WorkDir::FromCorpusShardPath( // const std::filesystem::path path{corpus_shard_path}; const std::string dir = path.parent_path(); const std::string stem = path.stem(); - CHECK(stem == kCorpusShardStem || - absl::StartsWith(stem, kDistilledCorpusShardStemPrefix)) + FUZZTEST_CHECK(stem == kCorpusShardStem || + absl::StartsWith(stem, kDistilledCorpusShardStemPrefix)) << VV(corpus_shard_path); const std::string dot_ext = path.extension(); - CHECK(!dot_ext.empty() && dot_ext[0] == '.') << VV(corpus_shard_path); + FUZZTEST_CHECK(!dot_ext.empty() && dot_ext[0] == '.') + << VV(corpus_shard_path); const std::string ext = dot_ext.substr(1); - CHECK_EQ(ext.size(), kDigitsInShardIndex) << VV(corpus_shard_path); + FUZZTEST_CHECK_EQ(ext.size(), kDigitsInShardIndex) << VV(corpus_shard_path); size_t shard_index = -1; - CHECK(absl::SimpleAtoi(ext, &shard_index)) << VV(corpus_shard_path); + FUZZTEST_CHECK(absl::SimpleAtoi(ext, &shard_index)) << VV(corpus_shard_path); return WorkDir{ dir, std::string{binary_name}, @@ -241,8 +240,8 @@ std::vector WorkDir::EnumerateRawCoverageProfiles() const { const auto dir_iter = std::filesystem::directory_iterator(dir_path, dir_error); if (dir_error) { - LOG(ERROR) << "Failed to access coverage dir '" << dir_path - << "': " << dir_error.message(); + FUZZTEST_LOG(ERROR) << "Failed to access coverage dir '" << dir_path + << "': " << dir_error.message(); return {}; } std::vector raw_profiles; diff --git a/common/BUILD b/common/BUILD index 753a042d2..d0fb585ab 100644 --- a/common/BUILD +++ b/common/BUILD @@ -40,7 +40,7 @@ cc_library( srcs = ["bazel.cc"], hdrs = ["bazel.h"], deps = [ - "@abseil-cpp//absl/log:check", + ":logging", "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", @@ -64,8 +64,6 @@ cc_library( ":status_macros", "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/base:nullability", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings:str_format", @@ -106,8 +104,8 @@ cc_library( name = "logging", hdrs = ["logging.h"], deps = [ - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", + "@abseil-cpp//absl/log:absl_check", + "@abseil-cpp//absl/log:absl_log", ], ) @@ -124,7 +122,6 @@ cc_library( ":logging", ":status_macros", "@abseil-cpp//absl/base:nullability", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", @@ -156,8 +153,6 @@ cc_library( ":logging", ":status_macros", "@abseil-cpp//absl/base:nullability", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", @@ -186,8 +181,8 @@ cc_library( name = "status_macros", hdrs = ["status_macros.h"], deps = [ + ":logging", "@abseil-cpp//absl/base:core_headers", - "@abseil-cpp//absl/log", ], ) @@ -200,8 +195,6 @@ cc_library( ":blob_file", ":defs", ":logging", - "@abseil-cpp//absl/log", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@googletest//:gtest", @@ -213,7 +206,7 @@ cc_library( srcs = ["temp_dir.cc"], hdrs = ["temp_dir.h"], deps = [ - "@abseil-cpp//absl/log:check", + ":logging", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:string_view", ], @@ -254,7 +247,6 @@ cc_library( ":logging", ":remote_file", ":test_util", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/time", "@googletest//:gtest", diff --git a/common/bazel.cc b/common/bazel.cc index 1a9780d7b..75f2141e3 100644 --- a/common/bazel.cc +++ b/common/bazel.cc @@ -18,12 +18,12 @@ #include #include -#include "absl/log/check.h" #include "absl/status/status.h" #include "absl/strings/numbers.h" #include "absl/strings/str_cat.h" #include "absl/time/clock.h" #include "absl/time/time.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -40,7 +40,7 @@ absl::Duration GetBazelTestTimeout() { return absl::InfiniteDuration(); } int timeout_s = 0; - CHECK(absl::SimpleAtoi(test_timeout_env, &timeout_s)) + FUZZTEST_CHECK(absl::SimpleAtoi(test_timeout_env, &timeout_s)) << "Failed to parse TEST_TIMEOUT: \"" << test_timeout_env << "\""; return absl::Seconds(timeout_s); } @@ -52,18 +52,20 @@ TestShard GetBazelTestShard() { TestShard test_shard; if (const char *test_total_shards_env = std::getenv("TEST_TOTAL_SHARDS"); test_total_shards_env != nullptr) { - CHECK(absl::SimpleAtoi(test_total_shards_env, &test_shard.total_shards)) + FUZZTEST_CHECK( + absl::SimpleAtoi(test_total_shards_env, &test_shard.total_shards)) << "Failed to parse TEST_TOTAL_SHARDS as an integer: \"" << test_total_shards_env << "\""; - CHECK_GT(test_shard.total_shards, 0) + FUZZTEST_CHECK_GT(test_shard.total_shards, 0) << "TEST_TOTAL_SHARDS must be greater than 0."; } if (const char *test_shard_index_env = std::getenv("TEST_SHARD_INDEX"); test_shard_index_env != nullptr) { - CHECK(absl::SimpleAtoi(test_shard_index_env, &test_shard.index)) + FUZZTEST_CHECK(absl::SimpleAtoi(test_shard_index_env, &test_shard.index)) << "Failed to parse TEST_SHARD_INDEX as an integer: \"" << test_shard_index_env << "\""; - CHECK(0 <= test_shard.index && test_shard.index < test_shard.total_shards) + FUZZTEST_CHECK(0 <= test_shard.index && + test_shard.index < test_shard.total_shards) << "TEST_SHARD_INDEX must be in the range [0, " << test_shard.total_shards << ")."; } @@ -102,7 +104,7 @@ absl::Status VerifyBazelHasEnoughTimeToRunTest(absl::Time target_start_time, // timeout. This case can only happen if we would in fact need more than // `kMaxShardCount` shards, indicating that there are simply too many fuzz // tests in a binary. - CHECK_EQ(suggested_shard_count, kMaxShardCount); + FUZZTEST_CHECK_EQ(suggested_shard_count, kMaxShardCount); absl::StrAppend(&error, "split the fuzz tests into several test binaries where " "each binary has at most ", @@ -112,7 +114,7 @@ absl::Status VerifyBazelHasEnoughTimeToRunTest(absl::Time target_start_time, // In this case, `suggested_shard_count` must be greater than // `shard_count`, otherwise we would have already executed all the tests // without a timeout. - CHECK_GT(suggested_shard_count, shard_count); + FUZZTEST_CHECK_GT(suggested_shard_count, shard_count); absl::StrAppend(&error, "increase the `shard_count` to ", suggested_shard_count, ", "); } diff --git a/common/blob_file.cc b/common/blob_file.cc index dc9a40ef3..6193c4fb2 100644 --- a/common/blob_file.cc +++ b/common/blob_file.cc @@ -27,8 +27,6 @@ #include "absl/base/nullability.h" #include "absl/base/optimization.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/strings/str_format.h" #include "absl/strings/string_view.h" @@ -71,7 +69,7 @@ class SimpleBlobFileReader : public BlobFileReader { ~SimpleBlobFileReader() override { if (file_ && !closed_) { // Virtual resolution is off in dtors, so use a specific Close(). - CHECK_OK(SimpleBlobFileReader::Close()); + FUZZTEST_CHECK_OK(SimpleBlobFileReader::Close()); } } @@ -125,12 +123,12 @@ class SimpleBlobFileWriter : public BlobFileWriter { ~SimpleBlobFileWriter() override { if (file_ && !closed_) { // Virtual resolution is off in dtors, so use a specific Close(). - CHECK_OK(SimpleBlobFileWriter::Close()); + FUZZTEST_CHECK_OK(SimpleBlobFileWriter::Close()); } } absl::Status Open(std::string_view path, std::string_view mode) override { - CHECK(mode == "w" || mode == "a") << VV(mode); + FUZZTEST_CHECK(mode == "w" || mode == "a") << VV(mode); if (closed_) return absl::FailedPreconditionError("already closed"); if (file_) return absl::FailedPreconditionError("already open"); ASSIGN_OR_RETURN_IF_NOT_OK(file_, RemoteFileOpen(path, mode.data())); @@ -170,7 +168,7 @@ class DefaultBlobFileReader : public BlobFileReader { public: ~DefaultBlobFileReader() override { // Virtual resolution is off in dtors, so use a specific Close(). - CHECK_OK(DefaultBlobFileReader::Close()); + FUZZTEST_CHECK_OK(DefaultBlobFileReader::Close()); } absl::Status Open(std::string_view path) override { @@ -247,8 +245,8 @@ class DefaultBlobFileReader : public BlobFileReader { // TODO(b/313706444): Reconsider error handling after experiments. // TODO(b/310701588): Try adding a test for this. if (riegeli_reader_.ok() && !riegeli_reader_.Close()) { - LOG(WARNING) << "Ignoring errors while closing Riegeli file: " - << riegeli_reader_.status(); + FUZZTEST_LOG(WARNING) << "Ignoring errors while closing Riegeli file: " + << riegeli_reader_.status(); } // Any non-ok status of `riegeli_reader_` persists for subsequent // operations; therefore, re-initialize it to a closed ok state. @@ -272,11 +270,11 @@ class RiegeliWriter : public BlobFileWriter { public: ~RiegeliWriter() override { // Virtual resolution is off in dtors, so use a specific Close(). - CHECK_OK(RiegeliWriter::Close()); + FUZZTEST_CHECK_OK(RiegeliWriter::Close()); } absl::Status Open(std::string_view path, std::string_view mode) override { - CHECK(mode == "w" || mode == "a") << VV(mode); + FUZZTEST_CHECK(mode == "w" || mode == "a") << VV(mode); if (absl::Status s = Close(); !s.ok()) return s; const auto kWriterOpts = riegeli::RecordWriterBase::Options{}.set_chunk_size(kMaxBufferedBytes); @@ -305,7 +303,7 @@ class RiegeliWriter : public BlobFileWriter { if (!PostWriteFlush(blob.size())) return writer_.status(); write_duration_ += absl::Now() - now; if (written_blobs_ + buffered_blobs_ % 10000 == 0) - VLOG(10) << "Current stats: " << StatsString(); + FUZZTEST_VLOG(10) << "Current stats: " << StatsString(); return absl::OkStatus(); } @@ -322,7 +320,7 @@ class RiegeliWriter : public BlobFileWriter { written_bytes_ += buffered_bytes_; buffered_blobs_ = 0; buffered_bytes_ = 0; - VLOG(1) << "Final stats: " << StatsString(); + FUZZTEST_VLOG(1) << "Final stats: " << StatsString(); return absl::OkStatus(); } @@ -358,7 +356,8 @@ class RiegeliWriter : public BlobFileWriter { : (absl::Now() - flushed_at_ > kMaxFlushInterval) ? "time" : ""; if (!flush_reason.empty()) { - VLOG(20) << "Flushing b/c " << flush_reason << ": " << StatsString(); + FUZZTEST_VLOG(20) << "Flushing b/c " << flush_reason << ": " + << StatsString(); if (!writer_.Flush(riegeli::FlushType::kFromMachine)) return false; flushed_at_ = absl::Now(); written_blobs_ += buffered_blobs_; @@ -376,7 +375,8 @@ class RiegeliWriter : public BlobFileWriter { bool PostWriteFlush(size_t blob_size) { const auto record_size = blob_size + kRiegeliPerRecordMetadataSize; if (record_size >= kMaxBufferedBytes) { - VLOG(20) << "Post-write flushing b/c blob size: " << StatsString(); + FUZZTEST_VLOG(20) << "Post-write flushing b/c blob size: " + << StatsString(); if (!writer_.Flush(riegeli::FlushType::kFromMachine)) return false; flushed_at_ = absl::Now(); written_blobs_ += 1; @@ -446,7 +446,7 @@ class RiegeliWriter : public BlobFileWriter { ByteArray PackBytesForAppendFile(ByteSpan blob) { ByteArray res; auto hash = Hash(blob); - CHECK_EQ(hash.size(), kHashLen); + FUZZTEST_CHECK_EQ(hash.size(), kHashLen); size_t size = blob.size(); uint8_t size_bytes[sizeof(size)]; std::memcpy(size_bytes, &size, sizeof(size)); @@ -496,7 +496,8 @@ std::unique_ptr DefaultBlobFileReaderFactory() { std::unique_ptr DefaultBlobFileWriterFactory(bool riegeli) { if (riegeli) #ifdef CENTIPEDE_DISABLE_RIEGELI - LOG(FATAL) << "Riegeli unavailable: built with --use_riegeli set to false."; + FUZZTEST_LOG(FATAL) + << "Riegeli unavailable: built with --use_riegeli set to false."; #else return std::make_unique(); #endif // CENTIPEDE_DISABLE_RIEGELI diff --git a/common/logging.h b/common/logging.h index 702008532..8f25c92e5 100644 --- a/common/logging.h +++ b/common/logging.h @@ -15,13 +15,32 @@ #ifndef FUZZTEST_COMMON_LOGGING_H_ #define FUZZTEST_COMMON_LOGGING_H_ -// TODO(b/315519925): Temporary leftover from switching to now-available -// OSS Abseil VLOG and friends. Explicitly include these wherever necessary and -// remove from here. -#include "absl/log/check.h" // IWYU pragma: keep -#include "absl/log/log.h" // IWYU pragma: keep +#include "absl/log/absl_check.h" +#include "absl/log/absl_log.h" -// Easy variable value logging: LOG(INFO) << VV(foo) << VV(bar); +// Easy variable value logging: FUZZTEST_LOG(INFO) << VV(foo) << VV(bar); #define VV(x) #x ": " << (x) << " " +// NOTE: these macros are for internal use within the fuzztest codebase. +#define FUZZTEST_LOG(severity) ABSL_LOG(severity) +#define FUZZTEST_LOG_EVERY_POW_2(severity) ABSL_LOG_EVERY_POW_2(severity) +#define FUZZTEST_LOG_FIRST_N(severity, n) ABSL_LOG_FIRST_N(severity, n) +#define FUZZTEST_VLOG(verbose_level) ABSL_VLOG(verbose_level) +#define FUZZTEST_VLOG_EVERY_N(verbose_level, n) \ + ABSL_VLOG_EVERY_N(verbose_level, n) +#define FUZZTEST_VLOG_IS_ON(verbose_level) ABSL_VLOG_IS_ON(verbose_level) +#define FUZZTEST_LOG_IF(severity, condition) ABSL_LOG_IF(severity, condition) +#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond) << "Internal error: " +#define FUZZTEST_PCHECK(cond) ABSL_PCHECK(cond) << "Internal error: " +#define FUZZTEST_PRECONDITION(cond) ABSL_CHECK(cond) << "Failed precondition: " +#define FUZZTEST_CHECK_OK(status) ABSL_CHECK_OK(status) +#define FUZZTEST_CHECK_GT(a, b) ABSL_CHECK_GT(a, b) +#define FUZZTEST_CHECK_GE(a, b) ABSL_CHECK_GE(a, b) +#define FUZZTEST_CHECK_EQ(a, b) ABSL_CHECK_EQ(a, b) +#define FUZZTEST_CHECK_NE(a, b) ABSL_CHECK_NE(a, b) +#define FUZZTEST_CHECK_LE(a, b) ABSL_CHECK_LE(a, b) +#define FUZZTEST_CHECK_LT(a, b) ABSL_CHECK_LT(a, b) +#define FUZZTEST_QCHECK(cond) ABSL_QCHECK(cond) +#define FUZZTEST_QCHECK_OK(status) ABSL_QCHECK_OK(status) + #endif // FUZZTEST_COMMON_LOGGING_H_ diff --git a/common/remote_file.cc b/common/remote_file.cc index 714855e55..b628ad610 100644 --- a/common/remote_file.cc +++ b/common/remote_file.cc @@ -21,7 +21,6 @@ #include #include "absl/base/nullability.h" -#include "absl/log/check.h" #include "absl/status/status.h" #include "./common/defs.h" #include "./common/logging.h" diff --git a/common/remote_file_oss.cc b/common/remote_file_oss.cc index 0f0acba9b..fb6f23ad8 100644 --- a/common/remote_file_oss.cc +++ b/common/remote_file_oss.cc @@ -37,8 +37,6 @@ #include #include "absl/base/nullability.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" @@ -69,7 +67,8 @@ class LocalRemoteFile : public RemoteFile { } ~LocalRemoteFile() { - CHECK(file_ == nullptr) << "Dtor called before Close(): " << VV(path_); + FUZZTEST_CHECK(file_ == nullptr) + << "Dtor called before Close(): " << VV(path_); } // Movable but not copyable. @@ -123,7 +122,7 @@ class LocalRemoteFile : public RemoteFile { ": ", std::strerror(errno))); } static constexpr auto elt_size = sizeof(ba[0]); - CHECK_EQ(file_size % elt_size, 0) + FUZZTEST_CHECK_EQ(file_size % elt_size, 0) << VV(file_size) << VV(elt_size) << VV(path_); if (file_size % elt_size != 0) { return absl::FailedPreconditionError( @@ -165,36 +164,36 @@ class LocalRemoteFile : public RemoteFile { #if defined(FUZZTEST_STUB_STD_FILESYSTEM) absl::Status RemoteMkdir(std::string_view path) { - LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } bool RemotePathExists(std::string_view path) { - LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } bool RemotePathIsDirectory(std::string_view path) { - LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } absl::StatusOr> RemoteListFiles(std::string_view path, bool recursively) { - LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } absl::Status RemoteFileRename(std::string_view from, std::string_view to) { - LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } absl::Status RemoteFileCopy(std::string_view from, std::string_view to) { - LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } absl::Status RemotePathTouchExistingFile(std::string_view path) { - LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } absl::Status RemotePathDelete(std::string_view path, bool recursively) { - LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } #else @@ -310,7 +309,7 @@ absl::Status RemotePathDelete(std::string_view path, bool recursively) { // TODO(ussuri): For now, simulate the old behavior, where a failure to open // a file returned nullptr. Adjust the clients to expect non-null and use a -// normal ctor with a CHECK instead of `Create()` here instead. +// normal ctor with a FUZZTEST_CHECK instead of `Create()` here instead. absl::StatusOr RemoteFileOpen(std::string_view path, const char *mode) { return LocalRemoteFile::Create(std::string(path), mode); @@ -367,7 +366,8 @@ namespace { #if defined(FUZZTEST_HAS_OSS_GLOB) int HandleGlobError(const char *epath, int eerrno) { if (eerrno == ENOENT) return 0; - LOG(FATAL) << "Error while globbing path: " << VV(epath) << VV(eerrno); + FUZZTEST_LOG(FATAL) << "Error while globbing path: " << VV(epath) + << VV(eerrno); return -1; } #endif // defined(FUZZTEST_HAS_OSS_GLOB) diff --git a/common/remote_file_test.cc b/common/remote_file_test.cc index ade0988fe..82fd85b0d 100644 --- a/common/remote_file_test.cc +++ b/common/remote_file_test.cc @@ -23,7 +23,6 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/log/check.h" #include "absl/status/status.h" #include "absl/time/clock.h" #include "absl/time/time.h" @@ -40,9 +39,9 @@ using ::testing::UnorderedElementsAre; void CreateFileOrDie(std::string_view path, std::string_view contents = "") { std::ofstream f{std::string(path)}; - CHECK(f.good()) << VV(path); + FUZZTEST_CHECK(f.good()) << VV(path); f << contents; - CHECK(f.good()) << VV(path); + FUZZTEST_CHECK(f.good()) << VV(path); } TEST(RemoteFile, GetSize) { @@ -137,7 +136,7 @@ TEST(RemoteListFiles, ReturnsAnEmptyVectorWhenPathDoesNotExist) { TEST(RemotePathDelete, RecursivelyDeletesAllFilesAndSubdirectories) { const fs::path temp_dir = GetTestTempDir(test_info_->name()); const fs::path a_b_c = temp_dir / "a" / "b" / "c"; - CHECK(fs::create_directories(a_b_c)) << VV(a_b_c); + FUZZTEST_CHECK(fs::create_directories(a_b_c)) << VV(a_b_c); const std::string file_path = a_b_c / "file"; CreateFileOrDie(file_path); diff --git a/common/status_macros.h b/common/status_macros.h index 0fe940fc9..882f2f55f 100644 --- a/common/status_macros.h +++ b/common/status_macros.h @@ -21,7 +21,7 @@ #include "absl/base/attributes.h" #include "absl/base/optimization.h" -#include "absl/log/log.h" +#include "./common/logging.h" // If `status_expr` (an expression of type `absl::Status`) is not OK then return // it from the current function. Otherwise, do nothing. @@ -55,8 +55,9 @@ decltype(auto) ValueOrDie(T&& value ABSL_ATTRIBUTE_LIFETIME_BOUND, std::uint_least32_t line = __builtin_LINE(), const char* file_name = __builtin_FILE()) { if (ABSL_PREDICT_FALSE(!value.ok())) { - LOG(FATAL) << file_name << ":" << line - << ": ValueOrDie on non-OK status: " << value.status(); + FUZZTEST_CHECK(false) << file_name << ":" << line + << ": ValueOrDie on non-OK status: " + << value.status(); } return *std::forward(value); } diff --git a/common/temp_dir.cc b/common/temp_dir.cc index e57e23702..f9dba377a 100644 --- a/common/temp_dir.cc +++ b/common/temp_dir.cc @@ -4,9 +4,9 @@ #include // NOLINT #include // NOLINT -#include "absl/log/check.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -18,24 +18,24 @@ TempDir::TempDir(absl::string_view custom_prefix) { if (temp_root.empty()) { std::error_code error; temp_root = std::filesystem::temp_directory_path(error); - CHECK(!error) << "Failed to get the root temp directory path: " - << error.message(); + FUZZTEST_CHECK(!error) << "Failed to get the root temp directory path: " + << error.message(); } absl::string_view prefix = custom_prefix.empty() ? "temp_dir" : custom_prefix; const fs::path path_template = temp_root / absl::StrCat(prefix, "_XXXXXX"); #if !defined(_MSC_VER) path_ = mkdtemp(path_template.string().data()); #else - CHECK(false) << "Windows is not supported yet."; + FUZZTEST_CHECK(false) << "Windows is not supported yet."; #endif - CHECK(std::filesystem::is_directory(path_)); + FUZZTEST_CHECK(std::filesystem::is_directory(path_)); } TempDir::~TempDir() { std::error_code error; std::filesystem::remove_all(path_, error); - CHECK(!error) << "Unable to clean up temporary dir " << path_ << ": " - << error.message(); + FUZZTEST_CHECK(!error) << "Unable to clean up temporary dir " << path_ << ": " + << error.message(); } } // namespace fuzztest::internal diff --git a/common/test_util.cc b/common/test_util.cc index 368f67388..3232d551f 100644 --- a/common/test_util.cc +++ b/common/test_util.cc @@ -19,8 +19,6 @@ #include // NOLINT #include "gtest/gtest.h" -#include "absl/log/check.h" -#include "absl/log/log.h" #include "absl/strings/str_cat.h" #include "./common/logging.h" @@ -28,13 +26,14 @@ namespace fuzztest::internal { std::filesystem::path GetTestTempDir(std::string_view subdir) { const std::filesystem::path test_tempdir = ::testing::TempDir(); - CHECK(!test_tempdir.empty()) + FUZZTEST_CHECK(!test_tempdir.empty()) << "testing::TempDir() is expected to always return non-empty path"; const auto dir = test_tempdir / subdir; if (!std::filesystem::exists(dir)) { std::error_code error; std::filesystem::create_directories(dir, error); - CHECK(!error) << "Failed to create dir: " VV(dir) << error.message(); + FUZZTEST_CHECK(!error) << "Failed to create dir: " VV(dir) + << error.message(); } return std::filesystem::canonical(dir); } @@ -45,13 +44,13 @@ std::string GetTempFilePath(std::string_view subdir, size_t i) { std::filesystem::path GetTestRunfilesDir() { const auto test_srcdir = ::testing::SrcDir(); - CHECK(!test_srcdir.empty()) + FUZZTEST_CHECK(!test_srcdir.empty()) << "testing::SrcDir() is expected to always return non-empty path"; const char* test_workspace = std::getenv("TEST_WORKSPACE"); - CHECK(test_workspace != nullptr) + FUZZTEST_CHECK(test_workspace != nullptr) << "TEST_WORKSPACE envvar is expected to be set by build system"; auto path = std::filesystem::path{test_srcdir}.append(test_workspace); - CHECK(std::filesystem::exists(path)) // + FUZZTEST_CHECK(std::filesystem::exists(path)) // << "No such dir: " << VV(path) << VV(test_srcdir) << VV(test_workspace); return path; } @@ -60,19 +59,19 @@ std::filesystem::path GetDataDependencyFilepath(std::string_view rel_path) { const auto runfiles_dir = GetTestRunfilesDir(); auto path = runfiles_dir; path.append(rel_path); - CHECK(std::filesystem::exists(path)) // + FUZZTEST_CHECK(std::filesystem::exists(path)) // << "No such path: " << VV(path) << VV(runfiles_dir) << VV(rel_path); return path; } std::string GetLLVMSymbolizerPath() { - CHECK_EQ(system("which llvm-symbolizer"), EXIT_SUCCESS) + FUZZTEST_CHECK_EQ(system("which llvm-symbolizer"), EXIT_SUCCESS) << "llvm-symbolizer has to be installed and findable via PATH"; return "llvm-symbolizer"; } std::string GetObjDumpPath() { - CHECK_EQ(system("which objdump"), EXIT_SUCCESS) + FUZZTEST_CHECK_EQ(system("which objdump"), EXIT_SUCCESS) << "objdump has to be installed and findable via PATH"; return "objdump"; } @@ -80,7 +79,7 @@ std::string GetObjDumpPath() { void PrependDirToPathEnvvar(std::string_view dir) { const std::string new_path_envvar = absl::StrCat(dir, ":", getenv("PATH")); setenv("PATH", new_path_envvar.c_str(), /*replace*/ 1); - LOG(INFO) << "New PATH: " << new_path_envvar; + FUZZTEST_LOG(INFO) << "New PATH: " << new_path_envvar; } } // namespace fuzztest::internal diff --git a/common/test_util.h b/common/test_util.h index 11cc60c70..c859bff94 100644 --- a/common/test_util.h +++ b/common/test_util.h @@ -22,10 +22,10 @@ #include #include -#include "absl/log/check.h" #include "absl/strings/str_format.h" #include "./common/blob_file.h" #include "./common/defs.h" +#include "./common/logging.h" #include "./common/logging.h" @@ -116,7 +116,7 @@ class TempCorpusDir : public TempDir { while (reader_->Read(blob).ok()) { corpus.emplace_back(blob.begin(), blob.end()); } - CHECK_OK(reader_->Close()); + FUZZTEST_CHECK_OK(reader_->Close()); return corpus; } diff --git a/domain_tests/BUILD b/domain_tests/BUILD index a2584b19e..a558db201 100644 --- a/domain_tests/BUILD +++ b/domain_tests/BUILD @@ -126,6 +126,7 @@ cc_library( "@abseil-cpp//absl/random:bit_gen_ref", "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:logging", "@com_google_fuzztest//fuzztest/internal:meta", "@com_google_fuzztest//fuzztest/internal:serialization", diff --git a/domain_tests/domain_testing.h b/domain_tests/domain_testing.h index e8b9009aa..9574b5805 100644 --- a/domain_tests/domain_testing.h +++ b/domain_tests/domain_testing.h @@ -35,6 +35,7 @@ #include "absl/status/status.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/mutation_metadata.h" #include "./fuzztest/internal/logging.h" #include "./fuzztest/internal/meta.h" @@ -145,8 +146,8 @@ struct Value { Value(const Domain& domain, T user_value) : corpus_value([&]() { auto corpus_value = domain.FromValue(user_value); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(corpus_value.has_value(), - "Invalid user_value!"); + FUZZTEST_PRECONDITION(corpus_value.has_value()) + << "Invalid user_value!"; return *corpus_value; }()), user_value(std::move(user_value)) {} diff --git a/e2e_tests/BUILD b/e2e_tests/BUILD index 78cb11b15..9ca044f86 100644 --- a/e2e_tests/BUILD +++ b/e2e_tests/BUILD @@ -25,10 +25,10 @@ cc_library( hdrs = ["test_binary_util.h"], deps = [ "@abseil-cpp//absl/container:flat_hash_map", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:string_view", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:flag_name", "@com_google_fuzztest//fuzztest/internal:subprocess", ], @@ -65,6 +65,7 @@ cc_test( "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/time", "@com_google_fuzztest//centipede:weak_sancov_stubs", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:temp_dir", "@com_google_fuzztest//fuzztest/internal:escaping", "@com_google_fuzztest//fuzztest/internal:io", @@ -91,7 +92,7 @@ cc_binary( "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/time", - "@com_google_fuzztest//fuzztest/internal:logging", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:subprocess", "@re2", ], @@ -146,7 +147,6 @@ cc_test( ":test_binary_util", "@abseil-cpp//absl/base:no_destructor", "@abseil-cpp//absl/container:flat_hash_map", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", diff --git a/e2e_tests/benchmark_test.cc b/e2e_tests/benchmark_test.cc index feaa786ad..ef6146c7d 100644 --- a/e2e_tests/benchmark_test.cc +++ b/e2e_tests/benchmark_test.cc @@ -37,7 +37,7 @@ #include "absl/strings/string_view.h" #include "absl/strings/strip.h" #include "absl/time/time.h" -#include "./fuzztest/internal/logging.h" +#include "./common/logging.h" #include "./fuzztest/internal/subprocess.h" #include "re2/re2.h" @@ -65,7 +65,7 @@ struct TestResult { std::string SelfPath() { char buf[4096]; ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf)); - FUZZTEST_INTERNAL_CHECK(len < sizeof(buf), "Path too long!"); + FUZZTEST_CHECK(len < sizeof(buf)) << "Path too long!"; return std::string(buf, len); } std::string MicrobenchmarksBinaryPath() { @@ -73,28 +73,30 @@ std::string MicrobenchmarksBinaryPath() { const std::size_t dir_path_len = self_path.find_last_of('/'); std::string binary_path = self_path.substr(0, dir_path_len) + "/testdata/fuzz_tests_for_microbenchmarking"; - FUZZTEST_INTERNAL_CHECK(std::filesystem::exists(binary_path), "Can't find ", - binary_path); + FUZZTEST_CHECK(std::filesystem::exists(binary_path)) + << "Can't find " << binary_path; return binary_path; } uint64_t ExtractTime(absl::string_view output) { static constexpr LazyRE2 kElapsedTimeRE = {"\nElapsed time: (.+)\n"}; std::string duration_str; - FUZZTEST_INTERNAL_CHECK( - RE2::PartialMatch(output, *kElapsedTimeRE, &duration_str), - "\n\nCould not find:\n\nElapsed time:\n\nin:\n\n", output); + FUZZTEST_CHECK(RE2::PartialMatch(output, *kElapsedTimeRE, &duration_str)) + << "\n\nCould not find:\n\nElapsed time:\n\nin:\n\n" + << output; absl::Duration duration; - FUZZTEST_INTERNAL_CHECK(absl::ParseDuration(duration_str, &duration), - "Could not parse duration:", duration_str); + FUZZTEST_CHECK(absl::ParseDuration(duration_str, &duration)) + << "Could not parse duration:" << duration_str; return absl::ToInt64Nanoseconds(duration); } uint64_t ExtractNumber(absl::string_view output, absl::string_view name) { uint64_t number; - FUZZTEST_INTERNAL_CHECK( - RE2::PartialMatch(output, absl::StrCat("\n", name, ": (.+)\n"), &number), - "\n\nCould not find\n\n", name, ":\n\nin:\n\n", output); + FUZZTEST_CHECK( + RE2::PartialMatch(output, absl::StrCat("\n", name, ": (.+)\n"), &number)) + << "\n\nCould not find\n\n" + << name << ":\n\nin:\n\n" + << output; return number; } @@ -141,8 +143,8 @@ std::string AllJsonResults(const std::vector& test_results) { // This measures the cost of the framework on processing the edge map. // This way we can see if differences in a CL come from edge count // change or from implementation changes. - FUZZTEST_INTERNAL_CHECK(result.stats.total_edges != 0, - "Total edges cannot be zero!"); + FUZZTEST_CHECK(result.stats.total_edges != 0) + << "Total edges cannot be zero!"; json_results.push_back(SingleJsonResult( "Control.Edges10000(time)", 10000 * result.stats.nanos / result.stats.total_edges)); @@ -226,8 +228,7 @@ void RunMicrobenchmarks(const bool list_tests, const std::string& filter) { int main(int argc, char** argv) { #if defined(__has_feature) #if !__has_feature(coverage_sanitizer) - FUZZTEST_INTERNAL_CHECK(false, - "\n\nPlease compile with --config=fuzztest.\n"); + FUZZTEST_CHECK(false) << "\n\nPlease compile with --config=fuzztest.\n"; #endif #endif absl::ParseCommandLine(argc, argv); diff --git a/e2e_tests/corpus_database_test.cc b/e2e_tests/corpus_database_test.cc index 98422cded..af147ecc3 100644 --- a/e2e_tests/corpus_database_test.cc +++ b/e2e_tests/corpus_database_test.cc @@ -22,7 +22,6 @@ #include "gtest/gtest.h" #include "absl/base/no_destructor.h" #include "absl/container/flat_hash_map.h" -#include "absl/log/check.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" @@ -75,11 +74,12 @@ class UpdateCorpusDatabaseTest static void SetUpTestSuite() { #if defined(__has_feature) #if !__has_feature(address_sanitizer) - CHECK(false) << "The test binary is not built with ASAN. Please run with " - "--config=asan."; + FUZZTEST_CHECK(false) + << "The test binary is not built with ASAN. Please run with " + "--config=asan."; #elif !__has_feature(coverage_sanitizer) || !defined(FUZZTEST_USE_CENTIPEDE) - CHECK(false) << "The test binary is not built with coverage " - "instrumentation for Centipede. " + FUZZTEST_CHECK(false) << "The test binary is not built with coverage " + "instrumentation for Centipede. " "Please run with --config=fuzztest-experimental."; #endif #endif @@ -146,7 +146,7 @@ class UpdateCorpusDatabaseTest return RunBinary(CentipedePath(), centipede_options); } } - FUZZTEST_INTERNAL_CHECK(false, "Unsupported execution model!\n"); + FUZZTEST_INTERNAL_FUZZTEST_CHECK(false, "Unsupported execution model!\n"); } private: diff --git a/e2e_tests/functional_test.cc b/e2e_tests/functional_test.cc index 9ee676eb5..591013bf1 100644 --- a/e2e_tests/functional_test.cc +++ b/e2e_tests/functional_test.cc @@ -33,6 +33,7 @@ #include "absl/strings/substitute.h" #include "absl/time/clock.h" #include "absl/time/time.h" +#include "./common/logging.h" #include "./common/temp_dir.h" #include "./e2e_tests/test_binary_util.h" #include "./fuzztest/internal/escaping.h" @@ -1288,7 +1289,7 @@ class FuzzingModeFixtureTest return RunBinary(CentipedePath(), run_options); } } - FUZZTEST_INTERNAL_CHECK(false, "Unsupported execution model!\n"); + FUZZTEST_CHECK(false) << "Unsupported execution model!\n"; } }; diff --git a/e2e_tests/test_binary_util.cc b/e2e_tests/test_binary_util.cc index 7aac989c0..0fe311292 100644 --- a/e2e_tests/test_binary_util.cc +++ b/e2e_tests/test_binary_util.cc @@ -20,10 +20,10 @@ #include // NOLINT #include -#include "absl/log/check.h" #include "absl/strings/match.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" #include "./fuzztest/internal/flag_name.h" #include "./fuzztest/internal/subprocess.h" @@ -34,12 +34,14 @@ namespace { // root. std::string GetFullPath(const std::filesystem::path& relative_path) { const auto test_srcdir = absl::NullSafeStringView(std::getenv("TEST_SRCDIR")); - CHECK(!test_srcdir.empty()) << "Please set TEST_SRCDIR to non-empty value or " - "use bazel to run the test."; + FUZZTEST_CHECK(!test_srcdir.empty()) + << "Please set TEST_SRCDIR to non-empty value or " + "use bazel to run the test."; const std::string full_path = std::filesystem::path(test_srcdir) / "_main" / relative_path; - CHECK(std::filesystem::exists(full_path)) << "Can't find " << full_path; + FUZZTEST_CHECK(std::filesystem::exists(full_path)) + << "Can't find " << full_path; return full_path; } diff --git a/e2e_tests/testdata/BUILD b/e2e_tests/testdata/BUILD index 3c623f3ac..b21cb8f80 100644 --- a/e2e_tests/testdata/BUILD +++ b/e2e_tests/testdata/BUILD @@ -50,7 +50,6 @@ cc_library( "@abseil-cpp//absl/algorithm:container", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", "@abseil-cpp//absl/types:span", @@ -93,13 +92,13 @@ cc_binary( "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", "@abseil-cpp//absl/functional:function_ref", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/random:bit_gen_ref", "@abseil-cpp//absl/random:distributions", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/time", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest", "@com_google_fuzztest//fuzztest:fuzztest_gtest_main", "@com_google_fuzztest//fuzztest:googletest_fixture_adapter", diff --git a/e2e_tests/testdata/fuzz_tests_for_functional_testing.cc b/e2e_tests/testdata/fuzz_tests_for_functional_testing.cc index 804950520..17df65285 100644 --- a/e2e_tests/testdata/fuzz_tests_for_functional_testing.cc +++ b/e2e_tests/testdata/fuzz_tests_for_functional_testing.cc @@ -38,6 +38,7 @@ #include "absl/strings/string_view.h" #include "absl/time/clock.h" #include "absl/time/time.h" +#include "./common/logging.h" #include "./fuzztest/internal/logging.h" #include "./fuzztest/internal/test_protobuf.pb.h" #include "google/protobuf/descriptor.h" @@ -735,12 +736,11 @@ class AlternateSignalStackFixture { // where the callbacks from the signal handler happen in a separate stack. new_sigact.sa_flags = SA_SIGINFO | SA_ONSTACK; - FUZZTEST_INTERNAL_CHECK(sigaction(SIGUSR1, &new_sigact, nullptr) == 0, - errno); + FUZZTEST_CHECK(sigaction(SIGUSR1, &new_sigact, nullptr) == 0) << errno; stack_t test_stack = {}; test_stack.ss_size = 1 << 20; test_stack.ss_sp = malloc(test_stack.ss_size); - FUZZTEST_INTERNAL_CHECK(sigaltstack(&test_stack, &old_stack) == 0, errno); + FUZZTEST_CHECK(sigaltstack(&test_stack, &old_stack) == 0) << errno; } void StackCalculationWorksWithAlternateStackForSignalHandlers(int i) { @@ -750,7 +750,7 @@ class AlternateSignalStackFixture { // "stack overflow" detection and we will continue here. raise(SIGUSR1); // Just make sure the signal handler ran. - FUZZTEST_INTERNAL_CHECK(dummy_to_trigger_cmp_in_handler != 0, ""); + FUZZTEST_CHECK(dummy_to_trigger_cmp_in_handler != 0); if (i == 123456789) { std::abort(); @@ -760,7 +760,7 @@ class AlternateSignalStackFixture { ~AlternateSignalStackFixture() { stack_t test_stack = {}; // Resume to the old signal stack. - FUZZTEST_INTERNAL_CHECK(sigaltstack(&old_stack, &test_stack) == 0, errno); + FUZZTEST_CHECK(sigaltstack(&old_stack, &test_stack) == 0) << errno; free(test_stack.ss_sp); } diff --git a/e2e_tests/testdata/fuzz_tests_with_proto_inputs.cc b/e2e_tests/testdata/fuzz_tests_with_proto_inputs.cc index 5fbc36201..5cc7ee115 100644 --- a/e2e_tests/testdata/fuzz_tests_with_proto_inputs.cc +++ b/e2e_tests/testdata/fuzz_tests_with_proto_inputs.cc @@ -30,7 +30,6 @@ #include "absl/algorithm/container.h" #include "absl/container/flat_hash_map.h" #include "absl/container/flat_hash_set.h" -#include "absl/log/check.h" #include "absl/strings/str_cat.h" #include "absl/time/clock.h" #include "absl/time/time.h" diff --git a/fuzztest/BUILD b/fuzztest/BUILD index 7dc2a1466..11ef50923 100644 --- a/fuzztest/BUILD +++ b/fuzztest/BUILD @@ -79,6 +79,7 @@ cc_library( "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:string_view", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:logging", "@com_google_fuzztest//fuzztest/internal:registration", "@com_google_fuzztest//fuzztest/internal:registry", @@ -91,9 +92,9 @@ cc_test( srcs = ["fuzztest_macros_test.cc"], deps = [ ":fuzztest_macros", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:temp_dir", "@googletest//:gtest_main", ], @@ -124,6 +125,7 @@ cc_library( "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:configuration", "@com_google_fuzztest//fuzztest/internal:flag_name", "@com_google_fuzztest//fuzztest/internal:googletest_adaptor", @@ -160,12 +162,11 @@ cc_library( "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/base:no_destructor", "@abseil-cpp//absl/flags:flag", - "@abseil-cpp//absl/log:absl_check", "@abseil-cpp//absl/random", "@abseil-cpp//absl/random:bit_gen_ref", "@abseil-cpp//absl/synchronization", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:io", - "@com_google_fuzztest//fuzztest/internal:logging", "@com_google_fuzztest//fuzztest/internal/domains:core_domains_impl", ], alwayslink = True, @@ -193,6 +194,7 @@ cc_library( "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings:string_view", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:any", "@com_google_fuzztest//fuzztest/internal:logging", "@com_google_fuzztest//fuzztest/internal:meta", diff --git a/fuzztest/domain_core.h b/fuzztest/domain_core.h index 926aba4ab..86a520ef0 100644 --- a/fuzztest/domain_core.h +++ b/fuzztest/domain_core.h @@ -44,6 +44,7 @@ #include "absl/status/status.h" #include "absl/strings/string_view.h" #include "absl/types/span.h" +#include "./common/logging.h" #include "./fuzztest/internal/any.h" #include "./fuzztest/internal/domains/aggregate_of_impl.h" #include "./fuzztest/internal/domains/arbitrary_impl.h" @@ -83,18 +84,18 @@ class DomainBuilder { // values it can handle until we call Set on the name. template Domain Get(std::string_view name) { - FUZZTEST_INTERNAL_CHECK(domain_lookup_table_ != nullptr, - "Finalize() has been called!"); + FUZZTEST_CHECK(domain_lookup_table_ != nullptr) + << "Finalize() has been called!"; return IndirectDomain(GetIndirect(name)); } template void Set(std::string_view name, const Domain& domain) { - FUZZTEST_INTERNAL_CHECK(domain_lookup_table_ != nullptr, - "Finalize() has been called!"); + FUZZTEST_CHECK(domain_lookup_table_ != nullptr) + << "Finalize() has been called!"; auto* indirect = GetIndirect(name); - FUZZTEST_INTERNAL_CHECK(!indirect->has_value(), - "Cannot set the same domain twice!"); + FUZZTEST_CHECK(!indirect->has_value()) + << "Cannot set the same domain twice!"; *indirect = internal::MoveOnlyAny(std::in_place_type>, domain); } @@ -105,18 +106,17 @@ class DomainBuilder { // anymore. template Domain Finalize(std::string_view name) && { - FUZZTEST_INTERNAL_CHECK(domain_lookup_table_ != nullptr, - "Finalize() has been called!"); - FUZZTEST_INTERNAL_CHECK( - GetIndirect(name)->has_value(), - // FUZZTEST_INTERNAL_CHECK uses absl::StrCat, which does not accept + FUZZTEST_CHECK(domain_lookup_table_ != nullptr) + << "Finalize() has been called!"; + FUZZTEST_CHECK(GetIndirect(name)->has_value()) + << + // FUZZTEST_CHECK uses absl::StrCat, which does not accept // std::string_view in iOS builds, so convert to absl::string_view. - "Finalize() has been called with an unknown name: ", - absl::string_view{name.data(), name.size()}); + "Finalize() has been called with an unknown name: " + << absl::string_view{name.data(), name.size()}; for (auto& iter : *domain_lookup_table_) { - FUZZTEST_INTERNAL_CHECK( - iter.second != nullptr && iter.second->has_value(), - "Some domain is not set yet!"); + FUZZTEST_CHECK(iter.second != nullptr && iter.second->has_value()) + << "Some domain is not set yet!"; } auto domain = GetIndirect(name)->template GetAs>(); return OwningDomain(std::move(domain), std::move(domain_lookup_table_)); @@ -140,9 +140,8 @@ class DomainBuilder { if (!indirection) { indirection = std::make_unique(); } - FUZZTEST_INTERNAL_CHECK( - !indirection->has_value() || indirection->Has>(), - "The indirection must either be empty or hold a value of Domain"); + FUZZTEST_CHECK(!indirection->has_value() || indirection->Has>()) + << "The indirection must either be empty or hold a value of Domain"; return indirection.get(); } diff --git a/fuzztest/fuzztest_macros.cc b/fuzztest/fuzztest_macros.cc index c8b5da349..ee3b1c521 100644 --- a/fuzztest/fuzztest_macros.cc +++ b/fuzztest/fuzztest_macros.cc @@ -32,6 +32,7 @@ #include "absl/strings/str_cat.h" #include "absl/strings/str_split.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" #include "./fuzztest/internal/logging.h" #include "./fuzztest/internal/runtime.h" @@ -88,17 +89,17 @@ std::vector> ReadFilesFromDirectory( std::string_view dir, std::function filter) { std::vector> out; const std::filesystem::path fs_dir(dir); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(std::filesystem::is_directory(fs_dir), - "Not a directory: ", fs_dir.string()); + FUZZTEST_PRECONDITION(std::filesystem::is_directory(fs_dir)) + << "Not a directory: " << fs_dir.string(); for (const auto& entry : std::filesystem::recursive_directory_iterator(fs_dir)) { if (std::filesystem::is_directory(entry)) continue; if (!filter(entry.path().string())) continue; std::ifstream stream(entry.path()); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - stream.good(), "Cannot read input file: ", entry.path().string(), ": ", - strerror(errno)); + FUZZTEST_PRECONDITION(stream.good()) + << "Cannot read input file: " << entry.path().string() << ": " + << strerror(errno); std::stringstream buffer; buffer << stream.rdbuf(); @@ -145,20 +146,19 @@ absl::StatusOr> ParseDictionary( std::vector ReadDictionaryFromFile( std::string_view dictionary_file) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !std::filesystem::is_directory(dictionary_file), - "Not a file: ", dictionary_file); + FUZZTEST_PRECONDITION(!std::filesystem::is_directory(dictionary_file)) + << "Not a file: " << dictionary_file; const std::filesystem::path fs_path(dictionary_file); std::ifstream stream(fs_path); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(stream.good(), "Error reading ", - fs_path.string(), ": ", strerror(errno)); + FUZZTEST_PRECONDITION(stream.good()) + << "Error reading " << fs_path.string() << ": " << strerror(errno); std::stringstream buffer; buffer << stream.rdbuf(); absl::StatusOr> parsed_entries = ParseDictionary(buffer.str()); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - parsed_entries.status().ok(), "Could not parse dictionary file ", - fs_path.string(), ": ", parsed_entries.status()); + FUZZTEST_PRECONDITION(parsed_entries.status().ok()) + << "Could not parse dictionary file " << fs_path.string() << ": " + << parsed_entries.status(); return *parsed_entries; } diff --git a/fuzztest/fuzztest_macros_test.cc b/fuzztest/fuzztest_macros_test.cc index 0ddc00989..41f44d9a2 100644 --- a/fuzztest/fuzztest_macros_test.cc +++ b/fuzztest/fuzztest_macros_test.cc @@ -8,9 +8,9 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/log/check.h" #include "absl/status/status.h" #include "absl/strings/match.h" +#include "./common/logging.h" #include "./common/temp_dir.h" namespace fuzztest::internal { @@ -24,7 +24,7 @@ using ::testing::UnorderedElementsAre; void WriteFile(const std::string& file_name, const std::string& contents) { std::ofstream f(file_name); - CHECK(f.is_open()); + FUZZTEST_CHECK(f.is_open()); f << contents; f.close(); } diff --git a/fuzztest/init_fuzztest.cc b/fuzztest/init_fuzztest.cc index 39b6d59bd..421c0d8b8 100644 --- a/fuzztest/init_fuzztest.cc +++ b/fuzztest/init_fuzztest.cc @@ -30,6 +30,7 @@ #include "absl/strings/string_view.h" #include "absl/strings/strip.h" #include "absl/time/time.h" +#include "./common/logging.h" #include "./fuzztest/internal/configuration.h" #include "./fuzztest/internal/flag_name.h" #include "./fuzztest/internal/googletest_adaptor.h" @@ -189,12 +190,12 @@ FUZZTEST_DEFINE_FLAG( "Internal-only flag - do not use directly. If set, only perform operations " "for the exact fuzz test regardless of other flags.") .OnUpdate([] { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( + FUZZTEST_PRECONDITION( !absl::GetFlag(FUZZTEST_FLAG(internal_override_fuzz_test)) - .has_value() || - std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr, - "must not set --" FUZZTEST_FLAG_PREFIX - "internal_override_fuzz_test directly"); + .has_value() || + std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr) + << "must not set --" FUZZTEST_FLAG_PREFIX + "internal_override_fuzz_test directly"; }); FUZZTEST_DEFINE_FLAG( @@ -205,12 +206,12 @@ FUZZTEST_DEFINE_FLAG( "--" FUZZTEST_FLAG_PREFIX "fuzz_for / --" FUZZTEST_FLAG_PREFIX "replay_corpus_for with --time_budget_type set to total.") .OnUpdate([] { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( + FUZZTEST_PRECONDITION( absl::GetFlag(FUZZTEST_FLAG(internal_override_total_time_limit)) == - absl::InfiniteDuration() || - std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr, - "must not set --" FUZZTEST_FLAG_PREFIX - "internal_override_total_time_limit directly"); + absl::InfiniteDuration() || + std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr) + << "must not set --" FUZZTEST_FLAG_PREFIX + "internal_override_total_time_limit directly"; }); FUZZTEST_DEFINE_FLAG(std::optional, @@ -220,12 +221,12 @@ FUZZTEST_DEFINE_FLAG(std::optional, "internal_override_fuzz_test are set, replay " "the input in the corpus database with the specified ID.") .OnUpdate([] { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( + FUZZTEST_PRECONDITION( !absl::GetFlag(FUZZTEST_FLAG(internal_crashing_input_to_reproduce)) - .has_value() || - std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr, - "must not set --" FUZZTEST_FLAG_PREFIX - "internal_crashing_input_to_reproduce directly"); + .has_value() || + std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr) + << "must not set --" FUZZTEST_FLAG_PREFIX + "internal_crashing_input_to_reproduce directly"; }); namespace fuzztest { @@ -324,8 +325,9 @@ internal::Configuration CreateConfigurationsFromFlags( ? internal::TimeBudgetType::kTotal : absl::GetFlag(FUZZTEST_FLAG(time_budget_type)); const std::optional jobs = absl::GetFlag(FUZZTEST_FLAG(jobs)); - FUZZTEST_INTERNAL_CHECK(!jobs.has_value() || *jobs > 0, "If specified, --", - FUZZTEST_FLAG(jobs).Name(), " must be positive."); + FUZZTEST_CHECK(!jobs.has_value() || *jobs > 0) + << "If specified, --" << FUZZTEST_FLAG(jobs).Name() + << " must be positive."; return internal::Configuration{ absl::GetFlag(FUZZTEST_FLAG(corpus_database)), /*stats_root=*/"", @@ -378,9 +380,8 @@ void InitFuzzTest(int* argc, char*** argv, std::string_view binary_id) { std::optional fuzzing_time_limit = GetFuzzingTime(); std::optional replay_corpus_time_limit = GetReplayCorpusTime(); - FUZZTEST_INTERNAL_CHECK( - !fuzzing_time_limit || !replay_corpus_time_limit, - "Cannot run in fuzzing and corpus replay mode at the same time."); + FUZZTEST_CHECK(!fuzzing_time_limit || !replay_corpus_time_limit) + << "Cannot run in fuzzing and corpus replay mode at the same time."; const auto test_to_fuzz = absl::GetFlag(FUZZTEST_FLAG(fuzz)); const auto test_to_replay_corpus = absl::GetFlag(FUZZTEST_FLAG(replay_corpus)); diff --git a/fuzztest/internal/BUILD b/fuzztest/internal/BUILD index 5f88da010..01f5c94ad 100644 --- a/fuzztest/internal/BUILD +++ b/fuzztest/internal/BUILD @@ -24,6 +24,7 @@ cc_library( deps = [ ":logging", ":meta", + "@com_google_fuzztest//common:logging", ], ) @@ -56,7 +57,6 @@ cc_library( "@abseil-cpp//absl/algorithm:container", "@abseil-cpp//absl/base:no_destructor", "@abseil-cpp//absl/functional:any_invocable", - "@abseil-cpp//absl/log:absl_log", "@abseil-cpp//absl/memory", "@abseil-cpp//absl/random", "@abseil-cpp//absl/random:distributions", @@ -78,6 +78,7 @@ cc_library( "@com_google_fuzztest//centipede:stop", "@com_google_fuzztest//centipede:workdir", "@com_google_fuzztest//common:defs", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", "@com_google_fuzztest//common:temp_dir", "@com_google_fuzztest//fuzztest/internal/domains:core_domains_impl", @@ -107,12 +108,12 @@ cc_library( srcs = ["configuration.cc"], hdrs = ["configuration.h"], deps = [ - "@abseil-cpp//absl/log:absl_check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:string_view", "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", ], ) @@ -155,7 +156,7 @@ cc_library( "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/types:span", - "@com_google_fuzztest//fuzztest/internal/domains:core_domains_impl", + "@com_google_fuzztest//common:logging", ], ) @@ -196,6 +197,7 @@ cc_test( ":registration", "@abseil-cpp//absl/functional:any_invocable", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest:domain_core", "@googletest//:gtest_main", ], @@ -243,6 +245,7 @@ cc_library( "@abseil-cpp//absl/types:span", "@com_google_fuzztest//common:blob_file", "@com_google_fuzztest//common:defs", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", ] + select({ "//conditions:default": [], @@ -254,7 +257,6 @@ cc_test( srcs = ["io_test.cc"], deps = [ ":io", - "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", @@ -274,6 +276,7 @@ cc_library( "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/synchronization", + "@com_google_fuzztest//common:logging", ], ) @@ -299,9 +302,9 @@ cc_library( deps = [ "@abseil-cpp//absl/base:fast_type_id", "@abseil-cpp//absl/functional:function_ref", - "@abseil-cpp//absl/log:absl_check", "@abseil-cpp//absl/random:distributions", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", ], ) @@ -360,7 +363,6 @@ cc_library( "@abseil-cpp//absl/functional:any_invocable", "@abseil-cpp//absl/functional:bind_front", "@abseil-cpp//absl/functional:function_ref", - "@abseil-cpp//absl/log:absl_check", "@abseil-cpp//absl/random", "@abseil-cpp//absl/random:bit_gen_ref", "@abseil-cpp//absl/random:distributions", @@ -371,6 +373,7 @@ cc_library( "@abseil-cpp//absl/time", "@abseil-cpp//absl/types:span", "@com_google_fuzztest//common:bazel", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal/domains:core_domains_impl", ], ) @@ -400,6 +403,7 @@ cc_library( "@abseil-cpp//absl/random", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", ], ) @@ -454,12 +458,12 @@ cc_library( srcs = ["subprocess.cc"], hdrs = ["subprocess.h"], deps = [ - ":logging", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/functional:function_ref", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", ], ) diff --git a/fuzztest/internal/any.h b/fuzztest/internal/any.h index 6c26c97e0..184e3a7cc 100644 --- a/fuzztest/internal/any.h +++ b/fuzztest/internal/any.h @@ -20,6 +20,7 @@ #include #include +#include "./common/logging.h" #include "./fuzztest/internal/logging.h" #include "./fuzztest/internal/meta.h" @@ -44,8 +45,8 @@ class AnyBase { } bool has_value() const { - FUZZTEST_INTERNAL_CHECK((vtable_ == nullptr) == (value_ == nullptr), - "Inconsistent state between value and vtable."); + FUZZTEST_CHECK((vtable_ == nullptr) == (value_ == nullptr)) + << "Inconsistent state between value and vtable."; return value_ != nullptr; } @@ -56,29 +57,29 @@ class AnyBase { template T& GetAs() & { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!"); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has(), "Wrong type!"); + FUZZTEST_PRECONDITION(has_value()) << "Object is empty!"; + FUZZTEST_PRECONDITION(Has()) << "Wrong type!"; return *static_cast(value_); } template const T& GetAs() const& { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!"); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has(), "Wrong type!"); + FUZZTEST_PRECONDITION(has_value()) << "Object is empty!"; + FUZZTEST_PRECONDITION(Has()) << "Wrong type!"; return *static_cast(value_); } template T&& GetAs() && { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!"); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has(), "Wrong type!"); + FUZZTEST_PRECONDITION(has_value()) << "Object is empty!"; + FUZZTEST_PRECONDITION(Has()) << "Wrong type!"; return std::move(*static_cast(value_)); } template const T&& GetAs() const&& { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!"); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has(), "Wrong type!"); + FUZZTEST_PRECONDITION(has_value()) << "Object is empty!"; + FUZZTEST_PRECONDITION(Has()) << "Wrong type!"; return std::move(*static_cast(value_)); } @@ -104,7 +105,7 @@ class AnyBase { } void CopyFrom(const AnyBase& other) { - FUZZTEST_INTERNAL_CHECK(!has_value(), "CopyFrom called on a full object"); + FUZZTEST_CHECK(!has_value()) << "CopyFrom called on a full object"; if (other.has_value()) { vtable_ = other.vtable_; value_ = vtable_->copy(other.value_); diff --git a/fuzztest/internal/centipede_adaptor.cc b/fuzztest/internal/centipede_adaptor.cc index 13833cab9..826626686 100644 --- a/fuzztest/internal/centipede_adaptor.cc +++ b/fuzztest/internal/centipede_adaptor.cc @@ -48,7 +48,6 @@ #include "absl/algorithm/container.h" #include "absl/base/no_destructor.h" #include "absl/functional/any_invocable.h" -#include "absl/log/absl_log.h" #include "absl/memory/memory.h" #include "absl/random/distributions.h" #include "absl/random/random.h" @@ -75,6 +74,7 @@ #include "./centipede/stop.h" #include "./centipede/workdir.h" #include "./common/defs.h" +#include "./common/logging.h" #include "./common/remote_file.h" #include "./common/temp_dir.h" #include "./fuzztest/internal/any.h" @@ -209,19 +209,17 @@ fuzztest::internal::Environment CreateCentipedeEnvironmentFromConfiguration( std::numeric_limits::max()); } constexpr size_t kMiB = 1024 * 1024; - FUZZTEST_INTERNAL_CHECK(configuration.rss_limit % kMiB == 0, - "configuration.rss_limit is not a multiple of MiB."); + FUZZTEST_CHECK(configuration.rss_limit % kMiB == 0) + << "configuration.rss_limit is not a multiple of MiB."; env.rss_limit_mb = configuration.rss_limit / kMiB; constexpr size_t kKiB = 1024; - FUZZTEST_INTERNAL_CHECK( - configuration.stack_limit % kKiB == 0, - "configuration.stack_limit is not a multiple of KiB."); + FUZZTEST_CHECK(configuration.stack_limit % kKiB == 0) + << "configuration.stack_limit is not a multiple of KiB."; env.stack_limit_kb = configuration.stack_limit / kKiB; env.populate_binary_info = false; const auto args = GetProcessArgs(); - FUZZTEST_INTERNAL_CHECK( - args.ok(), - absl::StrCat("failed to get the original process args: ", args.status())); + FUZZTEST_CHECK(args.ok()) << absl::StrCat( + "failed to get the original process args: ", args.status()); env.binary.clear(); for (const auto& arg : *args) { // We need shell escaping, because env.binary will be passed to system(), @@ -348,9 +346,9 @@ void InstallCentipedeTerminationHandler() { // needs to be properly handled. new_sigact.sa_flags = SA_ONSTACK; - FUZZTEST_INTERNAL_CHECK(sigaction(signum, &new_sigact, nullptr) == 0, - "Error installing signal handler: %s\n", - strerror(errno)); + FUZZTEST_CHECK(sigaction(signum, &new_sigact, nullptr) == 0) + << "Error installing signal handler: %s\n" + << strerror(errno); } return true; }(); @@ -387,8 +385,8 @@ int RunCentipede(const Environment& env, // Encoding signaled exit similarly as Bash. return 128 + static_cast(std::get(status.Status())); } - FUZZTEST_INTERNAL_CHECK( - status.Exited(), "Termination status must be Exited if not Signaled"); + FUZZTEST_CHECK(status.Exited()) + << "Termination status must be Exited if not Signaled"; return static_cast(std::get(status.Status())); } static absl::NoDestructor> @@ -557,8 +555,8 @@ class CentipedeAdaptorRunnerCallbacks metadata->ForEachCmpEntry( [&cmp_tables](fuzztest::internal::ByteSpan a, fuzztest::internal::ByteSpan b) { - FUZZTEST_INTERNAL_CHECK(a.size() == b.size(), - "cmp operands must have the same size"); + FUZZTEST_CHECK(a.size() == b.size()) + << "cmp operands must have the same size"; const size_t size = a.size(); if (size < kMinCmpEntrySize) return; if (size > kMaxCmpEntrySize) return; @@ -627,8 +625,8 @@ class CentipedeFixtureDriver : public UntypedFixtureDriver { void RunFuzzTest(absl::AnyInvocable run_fuzz_test_once) override { orig_fixture_driver_->RunFuzzTest([&, this] { - FUZZTEST_INTERNAL_CHECK(configuration_ != nullptr, - "Setting up a fuzz test without configuration!"); + FUZZTEST_CHECK(configuration_ != nullptr) + << "Setting up a fuzz test without configuration!"; PopulateTestLimitsToCentipedeRunner(*configuration_); std::move(run_fuzz_test_once)(); }); @@ -675,8 +673,8 @@ CentipedeFuzzerAdaptor::CentipedeFuzzerAdaptor( centipede_fixture_driver_( new CentipedeFixtureDriver(runtime_, std::move(fixture_driver))), fuzzer_impl_(test_, absl::WrapUnique(centipede_fixture_driver_)) { - FUZZTEST_INTERNAL_CHECK(centipede_fixture_driver_ != nullptr, - "Invalid fixture driver!"); + FUZZTEST_CHECK(centipede_fixture_driver_ != nullptr) + << "Invalid fixture driver!"; } bool CentipedeFuzzerAdaptor::RunInUnitTestMode( @@ -768,9 +766,8 @@ absl::Status ExportReproducersFromCentipede( output.dir_path); break; default: - FUZZTEST_INTERNAL_CHECK(false, - "unsupported reproducer output location type " - "to report reproducers from Centipede"); + FUZZTEST_CHECK(false) << "unsupported reproducer output location type " + "to report reproducers from Centipede"; } // Will be set when there is only one reproducer - nullopt otherwise. @@ -903,26 +900,25 @@ bool CentipedeFuzzerAdaptor::Run(int* argc, char*** argv, RunMode mode, runner_callbacks); return; }); - FUZZTEST_INTERNAL_CHECK(result.has_value(), - "No result is set for running fuzz test"); + FUZZTEST_CHECK(result.has_value()) + << "No result is set for running fuzz test"; return *result == EXIT_SUCCESS; } else if (is_running_property_function_in_this_process) { // If `is_running_property_function_in_this_process` holds at this point. We // assume it is for `ReplayInputsIfAvailable` to handle `FUZZTEST_REPLAY` // and `FUZZTEST_MINIMIZE_REPRODUCER`, which Centipede does not support. // This is fine because it does not require coverage instrumentation. - FUZZTEST_INTERNAL_CHECK( - std::getenv("FUZZTEST_REPLAY") || - std::getenv("FUZZTEST_MINIMIZE_REPRODUCER"), - "Both env vars `FUZZTEST_REPLAY` and `FUZZTEST_MINIMIZE_REPRODUCER` " - "are not set when calling the legacy input replaying - this is a " - "FuzzTest bug!"); + FUZZTEST_CHECK(std::getenv("FUZZTEST_REPLAY") || + std::getenv("FUZZTEST_MINIMIZE_REPRODUCER")) + << "Both env vars `FUZZTEST_REPLAY` and `FUZZTEST_MINIMIZE_REPRODUCER` " + "are not set when calling the legacy input replaying - this is a " + "FuzzTest bug!"; fuzzer_impl_.fixture_driver_->RunFuzzTest([&, this]() { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - fuzzer_impl_.ReplayInputsIfAvailable(configuration), - "ReplayInputsIfAvailable failed to handle env vars `FUZZTEST_REPLAY` " - "or `FUZZTEST_MINIMIZE_REPRODUCER`. Please check if they are set " - "properly."); + FUZZTEST_PRECONDITION(fuzzer_impl_.ReplayInputsIfAvailable(configuration)) + << "ReplayInputsIfAvailable failed to handle env vars " + "`FUZZTEST_REPLAY` " + "or `FUZZTEST_MINIMIZE_REPRODUCER`. Please check if they are set " + "properly."; return; }); return true; @@ -942,9 +938,9 @@ bool CentipedeFuzzerAdaptor::Run(int* argc, char*** argv, RunMode mode, const std::string minimize_dir = minimize_dir_chars; const char* corpus_out_dir_chars = std::getenv("FUZZTEST_TESTSUITE_OUT_DIR"); - FUZZTEST_INTERNAL_CHECK(corpus_out_dir_chars != nullptr, - "FUZZTEST_TESTSUITE_OUT_DIR must be specified " - "when minimizing testsuite"); + FUZZTEST_CHECK(corpus_out_dir_chars != nullptr) + << "FUZZTEST_TESTSUITE_OUT_DIR must be specified " + "when minimizing testsuite"; const std::string corpus_out_dir = corpus_out_dir_chars; absl::FPrintF( GetStderr(), @@ -957,32 +953,32 @@ bool CentipedeFuzzerAdaptor::Run(int* argc, char*** argv, RunMode mode, // The first empty path means no output dir. replay_env.corpus_dir = {"", minimize_dir}; replay_env.load_shards_only = true; - FUZZTEST_INTERNAL_CHECK( - RunCentipede(replay_env, configuration.centipede_command) == 0, - "Failed to replaying the testsuite for minimization"); + FUZZTEST_CHECK( + RunCentipede(replay_env, configuration.centipede_command) == 0) + << "Failed to replaying the testsuite for minimization"; absl::FPrintF(GetStderr(), "[.] Imported the corpus from %s.\n", minimize_dir); // 2. Run Centipede distillation on the shard. auto distill_env = env; distill_env.distill = true; - FUZZTEST_INTERNAL_CHECK( - RunCentipede(distill_env, configuration.centipede_command) == 0, - "Failed to minimize the testsuite"); + FUZZTEST_CHECK( + RunCentipede(distill_env, configuration.centipede_command) == 0) + << "Failed to minimize the testsuite"; absl::FPrintF(GetStderr(), "[.] Minimized the corpus using Centipede distillation.\n"); // 3. Replace the shard corpus data with the distillation result. auto distill_workdir = fuzztest::internal::WorkDir(distill_env); - FUZZTEST_INTERNAL_CHECK( + FUZZTEST_CHECK( std::rename( distill_workdir.DistilledCorpusFilePaths().MyShard().c_str(), - distill_workdir.CorpusFilePaths().MyShard().c_str()) == 0, - "Failed to replace the corpus data with the minimized result"); + distill_workdir.CorpusFilePaths().MyShard().c_str()) == 0) + << "Failed to replace the corpus data with the minimized result"; // 4. Export the corpus of the shard. auto export_env = env; export_env.corpus_to_files = corpus_out_dir; - FUZZTEST_INTERNAL_CHECK( - RunCentipede(export_env, configuration.centipede_command) == 0, - "Failed to export the corpus to FUZZTEST_MINIMIZE_TESTSUITE_DIR"); + FUZZTEST_CHECK( + RunCentipede(export_env, configuration.centipede_command) == 0) + << "Failed to export the corpus to FUZZTEST_MINIMIZE_TESTSUITE_DIR"; absl::FPrintF(GetStderr(), "[.] Exported the minimized the corpus to %s.\n", corpus_out_dir); diff --git a/fuzztest/internal/configuration.cc b/fuzztest/internal/configuration.cc index f4f0ffc3c..ebe73042f 100644 --- a/fuzztest/internal/configuration.cc +++ b/fuzztest/internal/configuration.cc @@ -22,12 +22,12 @@ #include #include -#include "absl/log/absl_check.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" #include "absl/time/time.h" +#include "./common/logging.h" namespace fuzztest::internal { @@ -99,14 +99,14 @@ size_t SpaceFor(const std::vector& vec) { template >> size_t WriteIntegral(std::string& out, size_t offset, IntT val) { - ABSL_CHECK_GE(out.size(), offset + SpaceFor(val)); + FUZZTEST_CHECK_GE(out.size(), offset + SpaceFor(val)); std::memcpy(out.data() + offset, &val, SpaceFor(val)); offset += SpaceFor(val); return offset; } size_t WriteString(std::string& out, size_t offset, absl::string_view str) { - ABSL_CHECK_GE(out.size(), offset + SpaceFor(str)); + FUZZTEST_CHECK_GE(out.size(), offset + SpaceFor(str)); offset = WriteIntegral(out, offset, str.size()); std::memcpy(out.data() + offset, str.data(), str.size()); offset += str.size(); @@ -115,7 +115,7 @@ size_t WriteString(std::string& out, size_t offset, absl::string_view str) { size_t WriteOptionalString(std::string& out, size_t offset, const std::optional& str) { - ABSL_CHECK_GE(out.size(), offset + SpaceFor(str)); + FUZZTEST_CHECK_GE(out.size(), offset + SpaceFor(str)); offset = WriteIntegral(out, offset, str.has_value()); if (str.has_value()) { offset = WriteString(out, offset, *str); @@ -125,7 +125,7 @@ size_t WriteOptionalString(std::string& out, size_t offset, size_t WriteVectorOfStrings(std::string& out, size_t offset, const std::vector& vec) { - ABSL_CHECK_GE(out.size(), offset + SpaceFor(vec)); + FUZZTEST_CHECK_GE(out.size(), offset + SpaceFor(vec)); offset = WriteIntegral(out, offset, vec.size()); for (const std::string& str : vec) { offset = WriteString(out, offset, str); @@ -236,7 +236,7 @@ std::string Configuration::Serialize() const { offset = WriteOptionalString(out, offset, centipede_command); offset = WriteOptionalString(out, offset, crashing_input_to_reproduce); offset = WriteOptionalString(out, offset, reproduction_command_template); - ABSL_CHECK_EQ(offset, out.size()); + FUZZTEST_CHECK_EQ(offset, out.size()); return out; } diff --git a/fuzztest/internal/coverage.cc b/fuzztest/internal/coverage.cc index bb647d443..43c25d750 100644 --- a/fuzztest/internal/coverage.cc +++ b/fuzztest/internal/coverage.cc @@ -26,6 +26,7 @@ #include "absl/base/attributes.h" #include "absl/strings/str_format.h" #include "absl/types/span.h" +#include "./common/logging.h" #include "./fuzztest/internal/flag_name.h" #include "./fuzztest/internal/logging.h" #include "./fuzztest/internal/table_of_recent_compares.h" @@ -198,8 +199,8 @@ constexpr size_t kVectorSize = sizeof(Vector); FUZZTEST_INTERNAL_NOSANITIZE bool UpdateVectorized( const uint8_t *execution_data, uint8_t *corpus_data, size_t size, size_t offset_to_align) { - FUZZTEST_INTERNAL_CHECK(size >= kVectorSize, - "size cannot be smaller than block size!"); + FUZZTEST_CHECK(size >= kVectorSize) + << "size cannot be smaller than block size!"; // Avoid collapsing the "greater than" vector until the end. Vector any_greater{}; @@ -290,8 +291,8 @@ bool CorpusCoverage::Update(ExecutionCoverage* execution_coverage) { absl::Span execution_map = execution_coverage->GetCounterMap(); // Note: corpus_map_size_ will be larger than execution_map.size(). // See the constructor for more details. - FUZZTEST_INTERNAL_CHECK(execution_map.size() <= corpus_map_size_, - "Map size mismatch."); + FUZZTEST_CHECK(execution_map.size() <= corpus_map_size_) + << "Map size mismatch."; // Calculate the offset required to align `p` to alignof(Vector). void* p = execution_map.data(); @@ -348,10 +349,8 @@ bool CorpusCoverage::Update(ExecutionCoverage* execution_coverage) { // where [start,end) is the array of 8-bit counters created for the current DSO. extern "C" void __sanitizer_cov_8bit_counters_init(uint8_t* start, uint8_t* stop) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(start != nullptr, - "Invalid counter map address."); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(start < stop, - "Invalid counter map size."); + FUZZTEST_PRECONDITION(start != nullptr) << "Invalid counter map address."; + FUZZTEST_PRECONDITION(start < stop) << "Invalid counter map size."; size_t map_size = stop - start; // For now, we assume single DSO. This means that this call back should get diff --git a/fuzztest/internal/domains/BUILD b/fuzztest/internal/domains/BUILD index 5a1d73875..5e605ddf0 100644 --- a/fuzztest/internal/domains/BUILD +++ b/fuzztest/internal/domains/BUILD @@ -21,6 +21,7 @@ cc_library( hdrs = ["absl_helpers.h"], deps = [ "@abseil-cpp//absl/time", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:logging", ], ) @@ -57,8 +58,6 @@ cc_library( ":absl_helpers", "@abseil-cpp//absl/container:flat_hash_set", "@abseil-cpp//absl/functional:function_ref", - "@abseil-cpp//absl/log:absl_check", - "@abseil-cpp//absl/log:absl_log", "@abseil-cpp//absl/numeric:bits", "@abseil-cpp//absl/numeric:int128", "@abseil-cpp//absl/random", @@ -69,6 +68,7 @@ cc_library( "@abseil-cpp//absl/strings:str_format", "@abseil-cpp//absl/time", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest:fuzzing_bit_gen", "@com_google_fuzztest//fuzztest/internal:any", "@com_google_fuzztest//fuzztest/internal:logging", @@ -89,30 +89,18 @@ cc_library( ], deps = [ ":core_domains_impl", - ":in_grammar_impl", - ":in_regexp_impl", - ":protobuf_domain_impl", - "@abseil-cpp//absl/base:core_headers", - "@abseil-cpp//absl/base:no_destructor", - "@abseil-cpp//absl/container:flat_hash_map", - "@abseil-cpp//absl/container:flat_hash_set", "@abseil-cpp//absl/functional:function_ref", - "@abseil-cpp//absl/random", "@abseil-cpp//absl/random:bit_gen_ref", "@abseil-cpp//absl/random:distributions", "@abseil-cpp//absl/status", - "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", - "@abseil-cpp//absl/synchronization", - "@abseil-cpp//absl/types:span", - "@com_google_fuzztest//fuzztest:domain_core", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:any", "@com_google_fuzztest//fuzztest/internal:logging", "@com_google_fuzztest//fuzztest/internal:meta", "@com_google_fuzztest//fuzztest/internal:printer", "@com_google_fuzztest//fuzztest/internal:serialization", - "@com_google_fuzztest//fuzztest/internal:status", "@com_google_fuzztest//fuzztest/internal:type_support", ], ) @@ -154,6 +142,7 @@ cc_library( "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:logging", "@com_google_fuzztest//fuzztest/internal:serialization", "@com_google_fuzztest//fuzztest/internal:status", @@ -177,6 +166,7 @@ cc_library( "@abseil-cpp//absl/strings:string_view", "@abseil-cpp//absl/synchronization", "@abseil-cpp//absl/types:span", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest:domain_core", "@com_google_fuzztest//fuzztest/internal:any", "@com_google_fuzztest//fuzztest/internal:logging", @@ -199,6 +189,7 @@ cc_library( "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:string_view", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:logging", "@re2", ], diff --git a/fuzztest/internal/domains/absl_helpers.h b/fuzztest/internal/domains/absl_helpers.h index 57eafed0e..efcfe7c60 100644 --- a/fuzztest/internal/domains/absl_helpers.h +++ b/fuzztest/internal/domains/absl_helpers.h @@ -20,6 +20,7 @@ #include #include "absl/time/time.h" +#include "./common/logging.h" #include "./fuzztest/internal/logging.h" namespace fuzztest::internal { @@ -31,8 +32,8 @@ namespace fuzztest::internal { inline absl::Duration MakeDuration(int64_t secs, uint32_t ticks) { // The granularity of a duration is as small as a quarter of a // nanosecond. - FUZZTEST_INTERNAL_CHECK_PRECONDITION(ticks >= 0u && ticks <= 3'999'999'999u, - "Ticks should be in range [0, 4B - 1]!"); + FUZZTEST_PRECONDITION(ticks >= 0u && ticks <= 3'999'999'999u) + << "Ticks should be in range [0, 4B - 1]!"; return absl::Seconds(secs) + (absl::Nanoseconds(1) / 4) * ticks; } @@ -43,13 +44,13 @@ inline std::pair GetSecondsAndTicks(absl::Duration d) { int64_t ticks = (4 * rem) / absl::Nanoseconds(1); if (ticks < 0) { // It is impossible to have both a negative remainder and int64min seconds. - FUZZTEST_INTERNAL_CHECK(secs != std::numeric_limits::min(), - "Seconds should not be int64 min!"); + FUZZTEST_CHECK(secs != std::numeric_limits::min()) + << "Seconds should not be int64 min!"; secs -= 1; ticks += 4'000'000'000; } - FUZZTEST_INTERNAL_CHECK(0 <= ticks && ticks < 4'000'000'000, - "Ticks should be in range [0, 4B - 1]!"); + FUZZTEST_CHECK(0 <= ticks && ticks < 4'000'000'000) + << "Ticks should be in range [0, 4B - 1]!"; return {secs, static_cast(ticks)}; } diff --git a/fuzztest/internal/domains/bit_flag_combination_of_impl.h b/fuzztest/internal/domains/bit_flag_combination_of_impl.h index 3ed7a5242..6ad3debef 100644 --- a/fuzztest/internal/domains/bit_flag_combination_of_impl.h +++ b/fuzztest/internal/domains/bit_flag_combination_of_impl.h @@ -21,6 +21,7 @@ #include "absl/random/bit_gen_ref.h" #include "absl/status/status.h" #include "absl/types/span.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/logging.h" #include "./fuzztest/internal/type_support.h" @@ -35,19 +36,18 @@ class BitFlagCombinationOfImpl explicit BitFlagCombinationOfImpl(absl::Span flags) : flags_(flags.begin(), flags.end()), all_flags_combo_{} { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !flags.empty(), "BitFlagCombinationOf requires a non empty list."); + FUZZTEST_PRECONDITION(!flags.empty()) + << "BitFlagCombinationOf requires a non empty list."; // Make sure they are mutually exclusive metadata, only_shrink and none are // empty. for (int i = 0; i < flags.size(); ++i) { T v1 = flags[i]; - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - v1 != T{}, "BitFlagCombinationOf requires non zero flags."); + FUZZTEST_PRECONDITION(v1 != T{}) + << "BitFlagCombinationOf requires non zero flags."; for (int j = i + 1; j < flags.size(); ++j) { T v2 = flags[j]; - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - BitAnd(v1, v2) == T{}, - "BitFlagCombinationOf requires flags to be mutually exclusive."); + FUZZTEST_PRECONDITION(BitAnd(v1, v2) == T{}) + << "BitFlagCombinationOf requires flags to be mutually exclusive."; } all_flags_combo_ = BitOr(all_flags_combo_, v1); } diff --git a/fuzztest/internal/domains/bit_gen_ref.h b/fuzztest/internal/domains/bit_gen_ref.h index 980985dbc..824d35e88 100644 --- a/fuzztest/internal/domains/bit_gen_ref.h +++ b/fuzztest/internal/domains/bit_gen_ref.h @@ -20,11 +20,10 @@ #include #include -#include "absl/log/absl_check.h" -#include "absl/log/absl_log.h" #include "absl/random/bit_gen_ref.h" #include "absl/status/status.h" #include "absl/strings/str_format.h" +#include "./common/logging.h" #include "./fuzztest/fuzzing_bit_gen.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/printer.h" @@ -52,7 +51,7 @@ class BitGenCorpusValue { : initializer_data_(o.initializer_data_), bitgen_(std::nullopt) {} BitGenCorpusValue& operator=(const BitGenCorpusValue& o) { // The internal URBG should be unused. - ABSL_CHECK(!bitgen_.has_value()); + FUZZTEST_CHECK(!bitgen_.has_value()); initializer_data_ = o.initializer_data_; return *this; } @@ -61,8 +60,8 @@ class BitGenCorpusValue { bitgen_(std::nullopt) {} BitGenCorpusValue& operator=(BitGenCorpusValue&& o) { // The internal URBG should be unused. - ABSL_CHECK(!o.bitgen_.has_value()); - ABSL_CHECK(!bitgen_.has_value()); + FUZZTEST_CHECK(!o.bitgen_.has_value()); + FUZZTEST_CHECK(!bitgen_.has_value()); initializer_data_ = std::move(o.initializer_data_); return *this; } @@ -137,7 +136,7 @@ class BitGenRefDomain value_type GetRandomValue(absl::BitGenRef prng) { // See b/404828355 - ABSL_LOG(FATAL) << "The domain doesn't support GetRandomValue()."; + FUZZTEST_LOG(FATAL) << "The domain doesn't support GetRandomValue()."; } std::optional FromValue(const value_type&) const { diff --git a/fuzztest/internal/domains/container_of_impl.h b/fuzztest/internal/domains/container_of_impl.h index 1db432cf2..d4202b818 100644 --- a/fuzztest/internal/domains/container_of_impl.h +++ b/fuzztest/internal/domains/container_of_impl.h @@ -31,6 +31,7 @@ #include "absl/status/status.h" #include "absl/strings/str_format.h" #include "absl/types/span.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/container_mutation_helpers.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/logging.h" @@ -113,9 +114,9 @@ class ContainerOfImplBase const domain_implementor::MutationMetadata& metadata, bool only_shrink) { permanent_dict_candidate_ = std::nullopt; - FUZZTEST_INTERNAL_CHECK( - min_size() <= val.size() && val.size() <= max_size(), "Size ", - val.size(), " is not between ", min_size(), " and ", max_size()); + FUZZTEST_CHECK(min_size() <= val.size() && val.size() <= max_size()) + << "Size " << val.size() << " is not between " << min_size() << " and " + << max_size(); const bool can_shrink = val.size() > min_size(); const bool can_grow = !only_shrink && val.size() < max_size(); @@ -220,16 +221,16 @@ class ContainerOfImplBase return Self(); } Derived& WithMinSize(size_t s) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !max_size_.has_value() || s <= *max_size_, "Minimal size ", s, - " cannot be larger than maximal size ", *max_size_); + FUZZTEST_PRECONDITION(!max_size_.has_value() || s <= *max_size_) + << "Minimal size " << s << " cannot be larger than maximal size " + << *max_size_; min_size_ = s; return Self(); } Derived& WithMaxSize(size_t s) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - min_size_ <= s, "Maximal size ", s, - " cannot be smaller than minimal size ", min_size_); + FUZZTEST_PRECONDITION(min_size_ <= s) + << "Maximal size " << s << " cannot be smaller than minimal size " + << min_size_; max_size_ = s; return Self(); } @@ -238,9 +239,8 @@ class ContainerOfImplBase "Manual Dictionary now only supports std::vector or " "std::string or std::string_view.\n"); for (const value_type& entry : manual_dict) { - FUZZTEST_INTERNAL_CHECK( - entry.size() <= max_size(), - "At least one dictionary entry is larger than max container size."); + FUZZTEST_CHECK(entry.size() <= max_size()) + << "At least one dictionary entry is larger than max container size."; manual_dict_.AddEntry({std::nullopt, entry}); } return Self(); diff --git a/fuzztest/internal/domains/domain_type_erasure.h b/fuzztest/internal/domains/domain_type_erasure.h index 2dd3b0825..442af9d39 100644 --- a/fuzztest/internal/domains/domain_type_erasure.h +++ b/fuzztest/internal/domains/domain_type_erasure.h @@ -33,6 +33,7 @@ #include "absl/random/bit_gen_ref.h" #include "absl/status/status.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" #include "./fuzztest/internal/any.h" #include "./fuzztest/internal/domains/mutation_metadata.h" #include "./fuzztest/internal/logging.h" @@ -228,9 +229,8 @@ class DomainModel final : public TypedDomainConcept> { printer.PrintFormattedAggregateValue(val.GetAs(), out, mode, prefix, suffix, element_formatter); } else { - FUZZTEST_INTERNAL_CHECK(false, - "PrintFormattedAggregateValue() can only be " - "called on AggregatePrinter!"); + FUZZTEST_LOG(FATAL) << "PrintFormattedAggregateValue() can only be " + "called on AggregatePrinter!"; } } diff --git a/fuzztest/internal/domains/element_of_impl.h b/fuzztest/internal/domains/element_of_impl.h index 38fd28167..0f3783f11 100644 --- a/fuzztest/internal/domains/element_of_impl.h +++ b/fuzztest/internal/domains/element_of_impl.h @@ -24,6 +24,7 @@ #include "absl/random/bit_gen_ref.h" #include "absl/random/distributions.h" #include "absl/time/time.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/logging.h" #include "./fuzztest/internal/serialization.h" @@ -42,8 +43,8 @@ class ElementOfImpl using typename ElementOfImpl::DomainBase::value_type; explicit ElementOfImpl(std::vector values) : values_(values) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !values.empty(), "ElementOf requires a non empty list."); + FUZZTEST_PRECONDITION(!values.empty()) + << "ElementOf requires a non empty list."; } corpus_type Init(absl::BitGenRef prng) { diff --git a/fuzztest/internal/domains/filter_impl.h b/fuzztest/internal/domains/filter_impl.h index a9b3130bc..f37b8f913 100644 --- a/fuzztest/internal/domains/filter_impl.h +++ b/fuzztest/internal/domains/filter_impl.h @@ -22,6 +22,7 @@ #include "absl/random/bit_gen_ref.h" #include "absl/status/status.h" #include "absl/strings/str_format.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/domain.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/logging.h" @@ -95,10 +96,10 @@ class FilterImpl bool res = predicate_(GetValue(v)); if (!res) { ++num_skips_; - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - num_skips_ <= 100 || static_cast(num_skips_) <= - .9 * static_cast(num_values_), - absl::StrFormat(R"( + FUZZTEST_PRECONDITION(num_skips_ <= 100 || + static_cast(num_skips_) <= + .9 * static_cast(num_values_)) + << absl::StrFormat(R"( [!] Ineffective use of Filter() detected! @@ -109,7 +110,7 @@ Please use Filter() only to skip unlikely values. To filter out a significant chunk of the input domain, consider defining a custom domain by construction. See more details in the User Guide. )", - num_skips_, num_values_)); + num_skips_, num_values_); } return res; } diff --git a/fuzztest/internal/domains/in_grammar_impl.h b/fuzztest/internal/domains/in_grammar_impl.h index ac34361ae..edcb72c59 100644 --- a/fuzztest/internal/domains/in_grammar_impl.h +++ b/fuzztest/internal/domains/in_grammar_impl.h @@ -117,9 +117,8 @@ class StringLiteralDomain { static bool IsMutable(const ASTNode& /*val*/) { return false; } static IRObject SerializeCorpus(const ASTNode& astnode) { - FUZZTEST_INTERNAL_CHECK( - CheckASTNodeTypeIdAndChildType(astnode, id), - "Invalid node!"); + FUZZTEST_CHECK(CheckASTNodeTypeIdAndChildType(astnode, id)) + << "Invalid node!"; return WrapASTIntoIRObject(astnode, {}); } @@ -166,9 +165,8 @@ class RegexLiteralDomain { static ASTTypeId TypeId() { return id; } static void ToString(std::string& output, const ASTNode& val) { - FUZZTEST_INTERNAL_CHECK( - CheckASTNodeTypeIdAndChildType(val, id), - "Not a regex literal!"); + FUZZTEST_CHECK(CheckASTNodeTypeIdAndChildType(val, id)) + << "Not a regex literal!"; absl::StrAppend(&output, GetInnerRegexpDomain().GetValue( std::get(val.children))); } @@ -176,9 +174,8 @@ class RegexLiteralDomain { static bool IsMutable(const ASTNode& /*val*/) { return true; } static IRObject SerializeCorpus(const ASTNode& astnode) { - FUZZTEST_INTERNAL_CHECK( - CheckASTNodeTypeIdAndChildType(astnode, id), - "Not a regex literal!"); + FUZZTEST_CHECK(CheckASTNodeTypeIdAndChildType(astnode, id)) + << "Not a regex literal!"; return WrapASTIntoIRObject( astnode, GetInnerRegexpDomain().SerializeCorpus( std::get(astnode.children))); @@ -258,9 +255,9 @@ class VectorDomain { static void Mutate(ASTNode& val, absl::BitGenRef prng, const domain_implementor::MutationMetadata& metadata, bool only_shrink) { - FUZZTEST_INTERNAL_CHECK( - CheckASTNodeTypeIdAndChildType>(val, id), - "Not a vector!"); + FUZZTEST_CHECK( + CheckASTNodeTypeIdAndChildType>(val, id)) + << "Not a vector!"; std::vector& elements = std::get>(val.children); if (only_shrink) { @@ -272,7 +269,7 @@ class VectorDomain { !elements.empty() && ElementT::IsMutable(elements.back()); constexpr bool can_change_element_num = max > min; if (!can_mutate_element && !can_change_element_num) { - FUZZTEST_INTERNAL_CHECK(false, "We shouldn't pick an unmutable node."); + FUZZTEST_LOG(FATAL) << "We shouldn't pick an unmutable node."; return; } if (!can_mutate_element) { @@ -301,9 +298,9 @@ class VectorDomain { static bool IsMutable(const ASTNode& /*val*/) { return true; } static IRObject SerializeCorpus(const ASTNode& astnode) { - FUZZTEST_INTERNAL_CHECK( - CheckASTNodeTypeIdAndChildType>(astnode, id), - "Not a vector!"); + FUZZTEST_CHECK( + CheckASTNodeTypeIdAndChildType>(astnode, id)) + << "Not a vector!"; IRObject expansion_obj; auto& inner_subs = expansion_obj.MutableSubs(); for (auto& node : std::get>(astnode.children)) { @@ -425,11 +422,11 @@ class TupleDomain { static void Mutate(ASTNode& val, absl::BitGenRef prng, const domain_implementor::MutationMetadata& metadata, bool only_shrink) { - FUZZTEST_INTERNAL_CHECK( + FUZZTEST_CHECK( CheckASTNodeTypeIdAndChildType>(val, id) && - std::get>(val.children).size() == - sizeof...(ElementT), - "Tuple elements number doesn't match!"); + std::get>(val.children).size() == + sizeof...(ElementT)) + << "Tuple elements number doesn't match!"; std::vector mutables; ApplyIndex([&](auto... I) { @@ -439,9 +436,8 @@ class TupleDomain { ...); }); - FUZZTEST_INTERNAL_CHECK( - !mutables.empty(), - "If the tuple is immutable it shouldn't be picked for mutation."); + FUZZTEST_CHECK(!mutables.empty()) + << "If the tuple is immutable it shouldn't be picked for mutation."; int choice = mutables[absl::Uniform(prng, 0, mutables.size())]; ApplyIndex([&](auto... I) { @@ -472,9 +468,9 @@ class TupleDomain { } static IRObject SerializeCorpus(const ASTNode& astnode) { - FUZZTEST_INTERNAL_CHECK( - CheckASTNodeTypeIdAndChildType>(astnode, id), - "Invalid node!"); + FUZZTEST_CHECK( + CheckASTNodeTypeIdAndChildType>(astnode, id)) + << "Invalid node!"; IRObject expansion_obj; auto& inner_subs = expansion_obj.MutableSubs(); ApplyIndex([&](auto... I) { @@ -571,8 +567,8 @@ class VariantDomain { : (void)0), ...); - FUZZTEST_INTERNAL_CHECK(is_current_value_mutable || has_alternative, - "Impossible at" + std::to_string(id)); + FUZZTEST_CHECK(is_current_value_mutable || has_alternative) + << "Impossible at" << id; if (only_shrink) { if (is_current_value_mutable) { MutateCurrentValue(val, prng, metadata, only_shrink); @@ -594,9 +590,8 @@ class VariantDomain { } static void ToString(std::string& output, const ASTNode& val) { - FUZZTEST_INTERNAL_CHECK( - std::get>(val.children).size() == 1, - "This is not a variant ast node."); + FUZZTEST_CHECK(std::get>(val.children).size() == 1) + << "This is not a variant ast node."; auto child = std::get>(val.children).front(); ((ElementT::TypeId() == child.type_id ? (ElementT::ToString(output, child)) : (void)0), @@ -618,9 +613,9 @@ class VariantDomain { } static IRObject SerializeCorpus(const ASTNode& astnode) { - FUZZTEST_INTERNAL_CHECK( - CheckASTNodeTypeIdAndChildType>(astnode, id), - "Invalid node!"); + FUZZTEST_CHECK( + CheckASTNodeTypeIdAndChildType>(astnode, id)) + << "Invalid node!"; ASTTypeId child_id = std::get>(astnode.children).front().type_id; @@ -690,7 +685,7 @@ class VariantDomain { } static void SwitchToAlternative(ASTNode& val, absl::BitGenRef prng) { constexpr int n_alternative = sizeof...(ElementT); - FUZZTEST_INTERNAL_CHECK(n_alternative > 1, "No alternative to switch!"); + FUZZTEST_CHECK(n_alternative > 1) << "No alternative to switch!"; int child_type_id = std::get>(val.children).front().type_id; int current_choice = 0; @@ -751,7 +746,7 @@ class InGrammarImpl } std::optional FromValue(const value_type& /*v*/) const { - FUZZTEST_INTERNAL_CHECK(false, "Parsing is not implemented yet!"); + FUZZTEST_CHECK(false) << "Parsing is not implemented yet!"; return std::nullopt; } @@ -790,8 +785,8 @@ class InGrammarImpl size_t src_index = absl::Uniform(prng, dst_index + 1, candidates.size()); - FUZZTEST_INTERNAL_CHECK(src_index < candidates.size(), "Out of bound!"); - FUZZTEST_INTERNAL_CHECK(dst_index < candidates.size(), "Out of bound!"); + FUZZTEST_CHECK(src_index < candidates.size()) << "Out of bound!"; + FUZZTEST_CHECK(dst_index < candidates.size()) << "Out of bound!"; if (candidates[dst_index]->NodeCount() < candidates[src_index]->NodeCount()) { std::swap(dst_index, src_index); diff --git a/fuzztest/internal/domains/in_range_impl.h b/fuzztest/internal/domains/in_range_impl.h index 8b6cff5b3..0d77a5032 100644 --- a/fuzztest/internal/domains/in_range_impl.h +++ b/fuzztest/internal/domains/in_range_impl.h @@ -29,6 +29,7 @@ #include "absl/status/status.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/domains/special_values.h" #include "./fuzztest/internal/domains/value_mutation_helpers.h" @@ -53,15 +54,13 @@ class InRangeImpl : public domain_implementor::DomainBase> { IntegerDictionary, bool>; explicit InRangeImpl(T min, T max) : min_(min), max_(max) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - min <= max, "min must be less than or equal to max!"); + FUZZTEST_PRECONDITION(min <= max) + << "min must be less than or equal to max!"; if constexpr (!T_is_integer) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !(min == std::numeric_limits::lowest() && - max == std::numeric_limits::max()), - "Consider using the Finite() domain instead."); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(std::isfinite(max - min), - "Range is too large!"); + FUZZTEST_PRECONDITION(!(min == std::numeric_limits::lowest() && + max == std::numeric_limits::max())) + << "Consider using the Finite() domain instead."; + FUZZTEST_PRECONDITION(std::isfinite(max - min)) << "Range is too large!"; } if constexpr (T_is_integer) { // Find the longest common prefix diff --git a/fuzztest/internal/domains/in_regexp_impl.cc b/fuzztest/internal/domains/in_regexp_impl.cc index 81d8141a6..ae97e62c3 100644 --- a/fuzztest/internal/domains/in_regexp_impl.cc +++ b/fuzztest/internal/domains/in_regexp_impl.cc @@ -28,6 +28,7 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/types/span.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/domains/regexp_dfa.h" #include "./fuzztest/internal/logging.h" @@ -44,8 +45,7 @@ RegexpDFA::Path InRegexpImpl::Init(absl::BitGenRef prng) { if (auto seed = MaybeGetRandomSeed(prng)) return *seed; absl::StatusOr path = dfa_.StringToPath(dfa_.GenerateString(prng)); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(path.ok(), - "Init should generate valid paths"); + FUZZTEST_PRECONDITION(path.ok()) << "Init should generate valid paths"; return *path; } @@ -102,7 +102,7 @@ StringPrinter InRegexpImpl::GetPrinter() const { return StringPrinter{}; } InRegexpImpl::value_type InRegexpImpl::GetValue(const corpus_type& v) const { absl::StatusOr val = dfa_.PathToString(v); - FUZZTEST_INTERNAL_CHECK(val.ok(), "Corpus is invalid!"); + FUZZTEST_CHECK(val.ok()) << "Corpus is invalid!"; return *val; } @@ -150,9 +150,9 @@ absl::Status InRegexpImpl::ValidateCorpusValue( void InRegexpImpl::ValidatePathRoundtrip(const RegexpDFA::Path& path) const { absl::StatusOr str = dfa_.PathToString(path); - FUZZTEST_INTERNAL_CHECK(str.ok(), "Invalid path in the DFA!"); + FUZZTEST_CHECK(str.ok()) << "Invalid path in the DFA!"; absl::StatusOr new_path = dfa_.StringToPath(*str); - FUZZTEST_INTERNAL_CHECK(new_path.ok(), "Invalid path in the DFA!"); + FUZZTEST_CHECK(new_path.ok()) << "Invalid path in the DFA!"; } bool InRegexpImpl::ShrinkByRemoveLoop(absl::BitGenRef prng, diff --git a/fuzztest/internal/domains/optional_of_impl.h b/fuzztest/internal/domains/optional_of_impl.h index e80b93d9f..812a92eb7 100644 --- a/fuzztest/internal/domains/optional_of_impl.h +++ b/fuzztest/internal/domains/optional_of_impl.h @@ -27,6 +27,7 @@ #include "absl/status/status.h" #include "absl/strings/str_format.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/domain.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/domains/serialization_helpers.h" @@ -98,12 +99,12 @@ class OptionalOfImpl value_type GetValue(const corpus_type& v) const { if (v.index() == 0) { - FUZZTEST_INTERNAL_CHECK(policy_ != OptionalPolicy::kWithoutNull, - "Value cannot be null!"); + FUZZTEST_CHECK(policy_ != OptionalPolicy::kWithoutNull) + << "Value cannot be null!"; return value_type(); } - FUZZTEST_INTERNAL_CHECK(policy_ != OptionalPolicy::kAlwaysNull, - "Value cannot be non-null!"); + FUZZTEST_CHECK(policy_ != OptionalPolicy::kAlwaysNull) + << "Value cannot be non-null!"; return value_type(inner_.GetValue(std::get<1>(v))); } diff --git a/fuzztest/internal/domains/overlap_of_impl.h b/fuzztest/internal/domains/overlap_of_impl.h index 92ed0b9b2..1e074cf1b 100644 --- a/fuzztest/internal/domains/overlap_of_impl.h +++ b/fuzztest/internal/domains/overlap_of_impl.h @@ -25,6 +25,7 @@ #include "absl/random/distributions.h" #include "absl/status/status.h" #include "absl/strings/str_format.h" +#include "./common/logging.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/domains/serialization_helpers.h" #include "./fuzztest/internal/logging.h" @@ -88,9 +89,9 @@ class OverlapOfImpl Switch(mutation_index, [&](auto I) { auto& domain = std::get(domains_); auto inner_corpus = domain.FromValue(*orig_value); - FUZZTEST_INTERNAL_CHECK(inner_corpus.has_value(), - "Mutate() called on a user value that is not " - "valid in all overlapping domains"); + FUZZTEST_CHECK(inner_corpus.has_value()) + << "Mutate() called on a user value that is not " + "valid in all overlapping domains"; domain.Mutate(*inner_corpus, prng, metadata, only_shrink); mutant_corpus = corpus_type(std::in_place_index, *std::move(inner_corpus)); @@ -103,8 +104,8 @@ class OverlapOfImpl only_shrink); }); } - FUZZTEST_INTERNAL_CHECK(mutant_corpus.has_value(), - "mutant corpus value is missing"); + FUZZTEST_CHECK(mutant_corpus.has_value()) + << "mutant corpus value is missing"; const bool valid = ValidateCorpusValueForOtherDomains(*mutant_corpus).ok(); MaybeReportOnValidationResult(valid); @@ -169,9 +170,9 @@ class OverlapOfImpl return Switch(*serialization_domain_index_, [&](auto I) { auto& domain = std::get(domains_); const auto inner_corpus = domain.FromValue(user_value); - FUZZTEST_INTERNAL_CHECK(inner_corpus.has_value(), - "Mutate() called on a user value that is not " - "valid in all overlapping domains"); + FUZZTEST_CHECK(inner_corpus.has_value()) + << "Mutate() called on a user value that is not " + "valid in all overlapping domains"; return domain.SerializeCorpus(*inner_corpus); }); } @@ -199,10 +200,8 @@ class OverlapOfImpl size_t num_validation_failures_ = 0; OverlapOfImpl& WithSerializationDomain(size_t index) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - index < kNumDomains, - absl::StrFormat("Serialization domain index must be less than %d", - kNumDomains)); + FUZZTEST_PRECONDITION(index < kNumDomains) + << "Serialization domain index must be less than " << kNumDomains; serialization_domain_index_ = index; return *this; } @@ -235,18 +234,19 @@ class OverlapOfImpl ++num_validation_attempts_; if (!succeeded) { ++num_validation_failures_; - FUZZTEST_INTERNAL_CHECK_PRECONDITION( + FUZZTEST_PRECONDITION( num_validation_attempts_ <= 100 || - static_cast(num_validation_failures_) <= - .9 * static_cast(num_validation_attempts_), - absl::StrFormat(R"( + static_cast(num_validation_failures_) <= + .9 * static_cast(num_validation_attempts_)) + << absl::StrFormat(R"( [!] Ineffective use of overlapping domains detected! Values were not valid on all of the overlapping domains on more than 90%% of the samples. %d out of %d have failed. )", - num_validation_failures_, num_validation_attempts_)); + num_validation_failures_, + num_validation_attempts_); } } }; diff --git a/fuzztest/internal/domains/protobuf_domain_impl.h b/fuzztest/internal/domains/protobuf_domain_impl.h index 0a7127470..be0e9b05e 100644 --- a/fuzztest/internal/domains/protobuf_domain_impl.h +++ b/fuzztest/internal/domains/protobuf_domain_impl.h @@ -40,6 +40,7 @@ #include "absl/strings/string_view.h" #include "absl/synchronization/mutex.h" #include "absl/types/span.h" +#include "./common/logging.h" #include "./fuzztest/domain_core.h" #include "./fuzztest/internal/any.h" #include "./fuzztest/internal/domains/arbitrary_impl.h" @@ -284,39 +285,36 @@ class ProtoPolicy { } OptionalPolicy GetOptionalPolicy(const FieldDescriptor* field) const { - FUZZTEST_INTERNAL_CHECK( - !field->is_required() && !field->is_repeated(), - "GetOptionalPolicy should apply to optional fields only!"); + FUZZTEST_CHECK(!field->is_required() && !field->is_repeated()) + << "GetOptionalPolicy should apply to optional fields only!"; std::optional result = GetPolicyValue(optional_policies_, field); - FUZZTEST_INTERNAL_CHECK(result.has_value(), "optional policy is not set!"); + FUZZTEST_CHECK(result.has_value()) << "optional policy is not set!"; return *result; } std::optional GetMinRepeatedFieldSize( const FieldDescriptor* field) const { - FUZZTEST_INTERNAL_CHECK( - field->is_repeated(), - "GetMinRepeatedFieldSize should apply to repeated fields only!"); + FUZZTEST_CHECK(field->is_repeated()) + << "GetMinRepeatedFieldSize should apply to repeated fields only!"; auto min = GetPolicyValue(min_repeated_fields_sizes_, field); auto max = GetPolicyValue(max_repeated_fields_sizes_, field); if (min.has_value() && max.has_value()) { - FUZZTEST_INTERNAL_CHECK(*min <= *max, "Repeated field ", - field->full_name(), " size range is not valid!"); + FUZZTEST_CHECK(*min <= *max) << "Repeated field " << field->full_name() + << " size range is not valid!"; } return min; } std::optional GetMaxRepeatedFieldSize( const FieldDescriptor* field) const { - FUZZTEST_INTERNAL_CHECK( - field->is_repeated(), - "GetMaxRepeatedFieldSize should apply to repeated fields only!"); + FUZZTEST_CHECK(field->is_repeated()) + << "GetMaxRepeatedFieldSize should apply to repeated fields only!"; auto min = GetPolicyValue(min_repeated_fields_sizes_, field); auto max = GetPolicyValue(max_repeated_fields_sizes_, field); if (min.has_value() && max.has_value()) { - FUZZTEST_INTERNAL_CHECK(*min <= *max, "Repeated field ", - field->full_name(), " size range is not valid!"); + FUZZTEST_CHECK(*min <= *max) << "Repeated field " << field->full_name() + << " size range is not valid!"; } return max; } @@ -344,13 +342,13 @@ class ProtoPolicy { auto domain = filter_to_values[i].value; auto obj = domain.GetValue(domain.Init(gen)); auto* descriptor = obj->GetDescriptor(); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - descriptor->full_name() == field->message_type()->full_name(), - "Input domain does not match the expected message type. The " - "domain produced a message of type `", - descriptor->full_name(), - "` but the field needs a message of type `", - field->message_type()->full_name(), "`."); + FUZZTEST_PRECONDITION(descriptor->full_name() == + field->message_type()->full_name()) + << "Input domain does not match the expected message type. The " + "domain produced a message of type `" + << descriptor->full_name() + << "` but the field needs a message of type `" + << field->message_type()->full_name() << "`."; } return filter_to_values[i].value; } @@ -414,8 +412,8 @@ class PrototypePtr { : prototype_factory_(std::move(prototype_factory)), prototype_(nullptr) {} PrototypePtr(const Prototype* prototype) : prototype_factory_(), prototype_(prototype) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(prototype != nullptr, - "Prototype should not be nullptr"); + FUZZTEST_PRECONDITION(prototype != nullptr) + << "Prototype should not be nullptr"; } PrototypePtr& operator=(const PrototypePtr& other) = default; @@ -471,10 +469,10 @@ class ProtobufDomainUntypedImpl corpus_type Init(absl::BitGenRef prng) { if (auto seed = this->MaybeGetRandomSeed(prng)) return *seed; const auto* descriptor = prototype_.Get()->GetDescriptor(); - FUZZTEST_INTERNAL_CHECK( - !IsCustomizedRecursivelyOnly() || !IsInfinitelyRecursive(descriptor), - absl::StrCat("Cannot set recursive fields for ", - descriptor->full_name(), " by default.")); + FUZZTEST_CHECK(!IsCustomizedRecursivelyOnly() || + !IsInfinitelyRecursive(descriptor)) + << "Cannot set recursive fields for " << descriptor->full_name() + << " by default."; corpus_type val; absl::flat_hash_map oneof_to_field; @@ -593,7 +591,7 @@ class ProtobufDomainUntypedImpl for (auto& [number, inner] : v) { if (IsMetadataEntry(number)) continue; auto* field = GetField(number); - FUZZTEST_INTERNAL_CHECK(field, "Field not found by number: ", number); + FUZZTEST_CHECK(field) << "Field not found by number: " << number; IRObject& pair = subs.emplace_back(); auto& pair_subs = pair.MutableSubs(); pair_subs.reserve(2); @@ -1061,9 +1059,9 @@ class ProtobufDomainUntypedImpl auto& domain = self.GetSubDomain(field); auto value = domain.GetValue(data); if (!value.has_value()) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !field->is_required(), "required field '", - std::string(field->full_name()), "' cannot have null values."); + FUZZTEST_PRECONDITION(!field->is_required()) + << "required field '" << std::string(field->full_name()) + << "' cannot have null values."; message.GetReflection()->ClearField(&message, field); return; } @@ -1269,10 +1267,9 @@ class ProtobufDomainUntypedImpl template void ApplyDomain(const FieldDescriptor* field) { if constexpr (!std::is_constructible_v) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - (std::is_constructible_v), - "Input domain does not match field `", field->full_name(), - "` type."); + FUZZTEST_PRECONDITION((std::is_constructible_v)) + << "Input domain does not match field `" << field->full_name() + << "` type."; } else { if constexpr (std::is_same_v) { // Verify that the type matches. @@ -1285,22 +1282,22 @@ class ProtobufDomainUntypedImpl domain.Mutate(val, gen, {}, false); descriptor = GetDescriptor(val); } - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !descriptor || - descriptor->full_name() == field->message_type()->full_name(), - "Input domain does not match the expected message type. The " - "domain produced a message of type `", - descriptor->full_name(), - "` but the field needs a message of type `", - field->message_type()->full_name(), "`."); + FUZZTEST_PRECONDITION(!descriptor || + descriptor->full_name() == + field->message_type()->full_name()) + << "Input domain does not match the expected message type. The " + "domain produced a message of type `" + << descriptor->full_name() + << "` but the field needs a message of type `" + << field->message_type()->full_name() << "`."; } absl::MutexLock l(&self.mutex_); auto res = self.domains_.try_emplace(field->number(), std::in_place_type, std::forward(domain)); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(res.second, "Domain for field `", - field->full_name(), - "` has been set multiple times."); + FUZZTEST_PRECONDITION(res.second) + << "Domain for field `" << field->full_name() + << "` has been set multiple times."; } } @@ -1337,9 +1334,8 @@ class ProtobufDomainUntypedImpl auto GetField(absl::string_view field_name) const { auto* field = GetFieldWithoutCheck(field_name); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(field != nullptr, - "Invalid field name '", - std::string(field_name), "'."); + FUZZTEST_PRECONDITION(field != nullptr) + << "Invalid field name '" << std::string(field_name) << "'."; return field; } @@ -1395,11 +1391,10 @@ class ProtobufDomainUntypedImpl void WithOneofField(absl::string_view field_name, OptionalPolicy policy) { const FieldDescriptor* field = GetField(field_name); if (!field->containing_oneof()) return; - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - policy != OptionalPolicy::kWithoutNull || - field->containing_oneof()->field_count() <= 1, - "Cannot always set oneof field ", field_name, - " (try using WithOneofAlwaysSet)."); + FUZZTEST_PRECONDITION(policy != OptionalPolicy::kWithoutNull || + field->containing_oneof()->field_count() <= 1) + << "Cannot always set oneof field " << field_name + << " (try using WithOneofAlwaysSet)."; if (policy == OptionalPolicy::kAlwaysNull) { MarkOneofFieldAsUnset(field); } @@ -1416,15 +1411,13 @@ class ProtobufDomainUntypedImpl void SetOneofAlwaysSet(absl::string_view oneof_name) { const std::string name(oneof_name); auto* oneof = prototype_.Get()->GetDescriptor()->FindOneofByName(name); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(oneof != nullptr, - "Invalid oneof name '", name, "'."); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !always_set_oneofs_.contains(oneof->index()), "oneof '", name, - "' is AlwaysSet before."); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !uncustomizable_oneofs_.contains(oneof->index()), - "WithOneofAlwaysSet(\"", name, - "\") should be called before customizing sub-fields."); + FUZZTEST_PRECONDITION(oneof != nullptr) + << "Invalid oneof name '" << name << "'."; + FUZZTEST_PRECONDITION(!always_set_oneofs_.contains(oneof->index())) + << "oneof '" << name << "' is AlwaysSet before."; + FUZZTEST_PRECONDITION(!uncustomizable_oneofs_.contains(oneof->index())) + << "WithOneofAlwaysSet(\"" << name + << "\") should be called before customizing sub-fields."; always_set_oneofs_.insert(oneof->index()); } @@ -1478,11 +1471,10 @@ class ProtobufDomainUntypedImpl template auto VisitSingular(const FieldDescriptor* field) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - false, - "Customizing repeated field size is not applicable to non-repeated " - "field ", - field->full_name(), "."); + FUZZTEST_PRECONDITION(false) << "Customizing repeated field size is not " + "applicable to non-repeated " + "field " + << field->full_name() << "."; } template @@ -1550,10 +1542,9 @@ class ProtobufDomainUntypedImpl } OptionalPolicy GetOneofFieldPolicy(const FieldDescriptor* field) const { - FUZZTEST_INTERNAL_CHECK( - field->containing_oneof(), - "GetOneofFieldPolicy should apply to oneof fields only! ", - field->full_name()); + FUZZTEST_CHECK(field->containing_oneof()) + "GetOneofFieldPolicy should apply to oneof fields only! " + << field->full_name(); auto field_policy = policy_.GetOptionalPolicy(field); // Field being unset via a policy overwrites the oneof policy. if (field_policy == OptionalPolicy::kAlwaysNull) return field_policy; @@ -1568,11 +1559,11 @@ class ProtobufDomainUntypedImpl } void CheckIfPolicyCanBeUpdated() const { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - customized_fields_.empty(), - "All singular modifiers (i.e., .With_Field_()) should come after " - "plural modifiers (i.e., .With_Fields_()). Consider reordering .With_ " - "modifiers."); + FUZZTEST_PRECONDITION(customized_fields_.empty()) + << "All singular modifiers (i.e., .With_Field_()) should come after " + "plural modifiers (i.e., .With_Fields_()). Consider reordering " + ".With_ " + "modifiers."; } // Get the existing domain for `field`, if exists. // Otherwise, create the appropriate `Arbitrary<>` domain for the field and @@ -1730,7 +1721,7 @@ class ProtobufDomainUntypedImpl // Returns true if there are subprotos in the `descriptor` that form an // infinite recursion. bool IsInfinitelyRecursive(const Descriptor* descriptor) const { - FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error."); + FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error."; absl::flat_hash_set parents; return IsProtoRecursive(/*field=*/nullptr, parents, RecursionType::kInfinitelyRecursive, descriptor); @@ -1741,14 +1732,14 @@ class ProtobufDomainUntypedImpl // because all Fi-s have to be set (e.g., Fi is a required field, or is // customized using `WithFieldsAlwaysSet`). bool IsInfinitelyRecursive(const FieldDescriptor* field) const { - FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error."); + FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error."; absl::flat_hash_set parents; return IsProtoRecursive(field, parents, RecursionType::kInfinitelyRecursive); } bool IsFieldFinitelyRecursive(const FieldDescriptor* field) { - FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error."); + FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error."; if (!field->message_type()) return false; ABSL_CONST_INIT static absl::Mutex mutex(absl::kConstInit); static absl::NoDestructor< @@ -1801,7 +1792,7 @@ class ProtobufDomainUntypedImpl } bool MustBeSet(const FieldDescriptor* field) const { - FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error."); + FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error."; if (IsRequired(field)) { return true; } else if (field->containing_oneof()) { @@ -1812,13 +1803,12 @@ class ProtobufDomainUntypedImpl return policy_.GetMinRepeatedFieldSize(field).has_value() && *policy_.GetMinRepeatedFieldSize(field) > 0; } - FUZZTEST_INTERNAL_CHECK(false, - "Field is not optional, repeated, or required"); + FUZZTEST_CHECK(false) << "Field is not optional, repeated, or required"; return false; } bool MustBeUnset(const FieldDescriptor* field) const { - FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error."); + FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error."; if (field->message_type() && IsInfinitelyRecursive(field)) { absl::FPrintF( GetStderr(), @@ -1836,8 +1826,7 @@ class ProtobufDomainUntypedImpl return policy_.GetMaxRepeatedFieldSize(field).has_value() && *policy_.GetMaxRepeatedFieldSize(field) == 0; } - FUZZTEST_INTERNAL_CHECK(false, - "Field is not optional, repeated, or required"); + FUZZTEST_CHECK(false) << "Field is not optional, repeated, or required"; return false; } @@ -1851,8 +1840,8 @@ class ProtobufDomainUntypedImpl parents.insert(field); descriptor = field->message_type(); } else { - FUZZTEST_INTERNAL_CHECK(descriptor, - "one of field or descriptor must be non-null!"); + FUZZTEST_CHECK(descriptor) + << "one of field or descriptor must be non-null!"; } for (int i = 0; i < descriptor->oneof_decl_count(); ++i) { const auto* oneof = descriptor->oneof_decl(i); @@ -2314,10 +2303,10 @@ class ProtobufDomainImpl private: void FailIfIsOneof(absl::string_view field) { const FieldDescriptor* descriptor = inner_.GetField(field); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !descriptor->containing_oneof(), "Cannot customize oneof field ", field, - " with WithOptionalField (try using " - "WithOneofAlwaysSet or WithOptionalUnset)."); + FUZZTEST_PRECONDITION(!descriptor->containing_oneof()) + << "Cannot customize oneof field " << field + << " with WithOptionalField (try using " + "WithOneofAlwaysSet or WithOptionalUnset)."; } template diff --git a/fuzztest/internal/domains/regexp_dfa.cc b/fuzztest/internal/domains/regexp_dfa.cc index ff6fa7040..acca7e1e5 100644 --- a/fuzztest/internal/domains/regexp_dfa.cc +++ b/fuzztest/internal/domains/regexp_dfa.cc @@ -33,6 +33,7 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" #include "./fuzztest/internal/logging.h" #include "re2/prog.h" #include "re2/regexp.h" @@ -57,9 +58,8 @@ std::string RegexpDFA::GenerateString(absl::BitGenRef prng) { result.insert(result.end(), fragment.begin(), fragment.end()); state = &states_[next_id]; if (state->is_end_state()) { - FUZZTEST_INTERNAL_CHECK( - fragment.back() == kEndOfString, - "The last character leading to the end state should be EOS!"); + FUZZTEST_CHECK(fragment.back() == kEndOfString) + << "The last character leading to the end state should be EOS!"; result.pop_back(); break; } @@ -73,8 +73,8 @@ RegexpDFA::Path RegexpDFA::FindPath( Path path; int cur_state_id = from_state_id; State* cur_state = &states_[cur_state_id]; - FUZZTEST_INTERNAL_CHECK(!cur_state->is_end_state(), - "Cannot start a DFA path from an end state!"); + FUZZTEST_CHECK(!cur_state->is_end_state()) + << "Cannot start a DFA path from an end state!"; while (true) { // Pick a random next state. int offset = cur_state->edge_weight_distribution(prng); @@ -146,7 +146,7 @@ RegexpDFA::Path RegexpDFA::FindPathWithinLengthDFS(int from_state_id, candidate_lens.push_back(len); } } - FUZZTEST_INTERNAL_CHECK(!candidate_lens.empty(), "Cannot find a path!"); + FUZZTEST_CHECK(!candidate_lens.empty()) << "Cannot find a path!"; int state_id = to_state_id; Path result; @@ -156,8 +156,8 @@ RegexpDFA::Path RegexpDFA::FindPathWithinLengthDFS(int from_state_id, result.push_back(*(last_edges_and_counters[state_id][len].edge)); state_id = result.back().from_state_id; } - FUZZTEST_INTERNAL_CHECK(state_id == from_state_id, - "Cannot find a path from from_state"); + FUZZTEST_CHECK(state_id == from_state_id) + << "Cannot find a path from from_state"; std::reverse(result.begin(), result.end()); return result; } @@ -209,9 +209,8 @@ absl::StatusOr RegexpDFA::PathToString( const std::vector& fragment = transition.chars_to_match; result.insert(result.end(), fragment.begin(), fragment.end()); if (next_state_id == end_state_id_) { - FUZZTEST_INTERNAL_CHECK( - fragment.back() == kEndOfString, - "The last character leading to the end state should be EOS!"); + FUZZTEST_CHECK(fragment.back() == kEndOfString) + << "The last character leading to the end state should be EOS!"; result.pop_back(); } } @@ -230,7 +229,7 @@ std::optional RegexpDFA::NextState( const std::vector& chars) { const size_t compare_size = std::min(transition.chars_to_match.size(), chars.size() - cur_index); - FUZZTEST_INTERNAL_CHECK(compare_size != 0, "Nothing to compare!"); + FUZZTEST_CHECK(compare_size != 0) << "Nothing to compare!"; for (size_t i = 0; i < compare_size; ++i) { if (transition.chars_to_match[i] == chars[cur_index + i]) continue; return transition.chars_to_match[i] < chars[cur_index + i]; @@ -262,10 +261,9 @@ std::unique_ptr RegexpDFA::CompileRegexp(absl::string_view regexp) { re2::Regexp::Parse(full_text_regexp, re2::Regexp::LikePerl, nullptr); // Is the regexp valid? - FUZZTEST_INTERNAL_CHECK_PRECONDITION(re != nullptr, - "Invalid RE2 regular expression."); + FUZZTEST_PRECONDITION(re != nullptr) << "Invalid RE2 regular expression."; re2::Prog* prog = re->CompileToProg(0); - FUZZTEST_INTERNAL_CHECK(prog != nullptr, "RE2 compilation failed!"); + FUZZTEST_CHECK(prog != nullptr) << "RE2 compilation failed!"; re->Decref(); return std::unique_ptr(prog); } @@ -279,14 +277,13 @@ void RegexpDFA::BuildEntireDFA(std::unique_ptr compiled_regexp) { // Full match has no effect on re2::Prog::BuildEntireDFA. int state_n = compiled_regexp->BuildEntireDFA( re2::Prog::kFirstMatch, [&](const int* next, bool match) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - next != nullptr, - "The memory budget for building the state machine (DFA) for the " - "given regular expression has been exhausted. " - "You might try to reduce the number of states by using more " - "specific character classes (e.g., [[:alpha:]] instead of `.`, " - "i.e., any character) in your regular expression, or wait until " - "the issue is fixed."); + FUZZTEST_PRECONDITION(next != nullptr) + << "The memory budget for building the state machine (DFA) for the " + "given regular expression has been exhausted. " + "You might try to reduce the number of states by using more " + "specific character classes (e.g., [[:alpha:]] instead of `.`, " + "i.e., any character) in your regular expression, or wait until " + "the issue is fixed."; transition_table.emplace_back( next, next + compiled_regexp->bytemap_range() + 1); @@ -328,8 +325,8 @@ void RegexpDFA::BuildEntireDFA(std::unique_ptr compiled_regexp) { return a.chars_to_match.front() < b.chars_to_match.front(); }); if (end_vec[i]) end_state_id_ = i; - FUZZTEST_INTERNAL_CHECK((!end_vec[i] || state.next.empty()), - "An end state must have no outgoing edges!"); + FUZZTEST_CHECK((!end_vec[i] || state.next.empty())) + << "An end state must have no outgoing edges!"; } } @@ -365,9 +362,8 @@ void RegexpDFA::ComputeEdgeWeights() { edge_to_unsafe_nodes.push_back(j); } } - FUZZTEST_INTERNAL_CHECK( - state_id == end_state_id_ || !edge_to_safe_nodes.empty(), - "A non-end node must have at least one safe edge"); + FUZZTEST_CHECK(state_id == end_state_id_ || !edge_to_safe_nodes.empty()) + << "A non-end node must have at least one safe edge"; double probability_to_safe_node = edge_to_unsafe_nodes.empty() ? 1 : kProbToSafeNode; @@ -402,9 +398,8 @@ void RegexpDFA::CompressStates() { State& state = states_[i]; if (state.next.size() != 1) continue; const auto& [chars_to_match, next_state_id] = state.next[0]; - FUZZTEST_INTERNAL_CHECK( - next_state_id != i, - "A self-loop state should have at least two outgoing edges."); + FUZZTEST_CHECK(next_state_id != i) + << "A self-loop state should have at least two outgoing edges."; for (size_t j = 0; j < states_.size(); ++j) { for (auto& [next_chars_to_match, state_id] : states_[j].next) { if (state_id == i) { diff --git a/fuzztest/internal/fixture_driver.h b/fuzztest/internal/fixture_driver.h index 43286e308..e489e9f59 100644 --- a/fuzztest/internal/fixture_driver.h +++ b/fuzztest/internal/fixture_driver.h @@ -260,10 +260,9 @@ class FixtureDriver*target_function_)( @@ -277,10 +276,10 @@ class FixtureDriver) { static_assert(std::is_same_v, std::vector>>); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - fixture_ != nullptr, - "fixture is nullptr. Did you forget to instantiate it in one of the " - "SetUp methods?"); + FUZZTEST_PRECONDITION(fixture_ != nullptr) + << "fixture is nullptr. Did you forget to instantiate it in one of " + "the " + "SetUp methods?"; return this->GetSeedsFromUserValues( std::invoke(this->seed_provider(), fixture_.get())); } else if constexpr (std::is_invocable_v) { diff --git a/fuzztest/internal/fixture_driver_test.cc b/fuzztest/internal/fixture_driver_test.cc index b296e657d..799506174 100644 --- a/fuzztest/internal/fixture_driver_test.cc +++ b/fuzztest/internal/fixture_driver_test.cc @@ -22,6 +22,7 @@ #include "gtest/gtest.h" #include "absl/functional/any_invocable.h" #include "absl/types/span.h" +#include "./common/logging.h" #include "./fuzztest/domain_core.h" #include "./fuzztest/internal/any.h" #include "./fuzztest/internal/logging.h" @@ -273,8 +274,7 @@ std::vector UnpackGenericValues( std::vector values; values.reserve(generic_values.size()); for (const auto& generic_value : generic_values) { - FUZZTEST_INTERNAL_CHECK(generic_value.Has(), - "Generic value of a wrong type."); + FUZZTEST_CHECK(generic_value.Has()) << "Generic value of a wrong type."; values.push_back(generic_value.GetAs()); } return values; diff --git a/fuzztest/internal/io.cc b/fuzztest/internal/io.cc index 760c830cd..70ba1c79a 100644 --- a/fuzztest/internal/io.cc +++ b/fuzztest/internal/io.cc @@ -37,6 +37,7 @@ #include "absl/types/span.h" #include "./common/blob_file.h" #include "./common/defs.h" +#include "./common/logging.h" #include "./common/remote_file.h" #include "./fuzztest/internal/logging.h" @@ -47,27 +48,27 @@ namespace fuzztest::internal { // TODO(lszekeres): Return absl::Status instead of bool for these. bool WriteFile(absl::string_view path, absl::string_view contents) { - FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS"); + FUZZTEST_LOG(FATAL)( << "Filesystem API not supported in iOS/MacOS"; } std::optional ReadFile(absl::string_view path) { - FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS"); + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } bool IsDirectory(absl::string_view path) { - FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS"); + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } bool CreateDirectory(absl::string_view path) { - FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS"); + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } std::vector ListDirectory(absl::string_view path) { - FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS"); + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } std::vector ListDirectoryRecursively(absl::string_view path) { - FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS"); + FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS"; } #else @@ -214,12 +215,10 @@ void ForEachSerializedInput(absl::Span file_paths, int total_invalid_inputs = 0; const absl::Time start_time = absl::Now(); for (const std::string& file_path : file_paths) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - fuzztest::internal::RemotePathExists(file_path), "File path ", - file_path, " does not exist."); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !fuzztest::internal::RemotePathIsDirectory(file_path), "File path ", - file_path, " is a directory."); + FUZZTEST_PRECONDITION(fuzztest::internal::RemotePathExists(file_path)) + << "File path " << file_path << " does not exist."; + FUZZTEST_PRECONDITION(!fuzztest::internal::RemotePathIsDirectory(file_path)) + << "File path " << file_path << " is a directory."; int loaded_inputs_from_file = 0; int invalid_inputs_from_file = 0; // The reader cannot be reused for multiple files because of the way it @@ -273,9 +272,9 @@ void ForEachSerializedInput(absl::Span file_paths, std::string contents; const absl::Status get_contents_status = fuzztest::internal::RemoteFileGetContents(file_path, contents); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - get_contents_status.ok(), "RemoteFileGetContents failed on ", file_path, - ", status: ", get_contents_status.message()); + FUZZTEST_PRECONDITION(get_contents_status.ok()) + << "RemoteFileGetContents failed on " << file_path + << ", status: " << get_contents_status.message(); absl::Status result = consume(file_path, std::nullopt, std::move(contents)); if (result.ok()) { ++total_loaded_inputs; diff --git a/fuzztest/internal/io_test.cc b/fuzztest/internal/io_test.cc index be07851e3..5eb7c176a 100644 --- a/fuzztest/internal/io_test.cc +++ b/fuzztest/internal/io_test.cc @@ -31,7 +31,6 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#include "absl/log/check.h" #include "absl/status/status.h" #include "absl/strings/str_cat.h" #include "absl/time/clock.h" @@ -200,14 +199,14 @@ TEST(ForEachSerializedInputTest, ReadsInputsFromSerializedFilesAndBlobFiles) { TestWrite(serialized_file, "Input1"); std::unique_ptr writer = fuzztest::internal::DefaultBlobFileWriterFactory(); - CHECK(writer->Open(blob_file, "w").ok()); - CHECK( + FUZZTEST_CHECK(writer->Open(blob_file, "w").ok()); + FUZZTEST_CHECK( writer->Write(fuzztest::internal::AsByteSpan(absl::string_view("Input2"))) .ok()); - CHECK( + FUZZTEST_CHECK( writer->Write(fuzztest::internal::AsByteSpan(absl::string_view("Input3"))) .ok()); - CHECK(writer->Close().ok()); + FUZZTEST_CHECK(writer->Close().ok()); using InputInFile = std::tuple, std::string>; std::vector inputs; @@ -229,14 +228,14 @@ TEST(ForEachSerializedInputTest, IgnoresUnconsumedInputs) { const std::string file = tmp_dir.path() / "file"; std::unique_ptr writer = fuzztest::internal::DefaultBlobFileWriterFactory(); - CHECK(writer->Open(file, "w").ok()); - CHECK( + FUZZTEST_CHECK(writer->Open(file, "w").ok()); + FUZZTEST_CHECK( writer->Write(fuzztest::internal::AsByteSpan(absl::string_view("Ignore"))) .ok()); - CHECK( + FUZZTEST_CHECK( writer->Write(fuzztest::internal::AsByteSpan(absl::string_view("Accept"))) .ok()); - CHECK(writer->Close().ok()); + FUZZTEST_CHECK(writer->Close().ok()); using InputInFile = std::tuple, std::string>; std::vector inputs; diff --git a/fuzztest/internal/logging.cc b/fuzztest/internal/logging.cc index 4521afefe..1418360d1 100644 --- a/fuzztest/internal/logging.cc +++ b/fuzztest/internal/logging.cc @@ -21,6 +21,7 @@ #include "absl/base/const_init.h" #include "absl/base/thread_annotations.h" #include "absl/synchronization/mutex.h" +#include "./common/logging.h" #if defined(__linux__) #include @@ -47,10 +48,10 @@ FILE* stdout_file_ = stdout; // Never accessed concurrently. void Silence(int fd) { FILE* tmp = fopen("/dev/null", "w"); - FUZZTEST_INTERNAL_CHECK(tmp, "fopen() error:", strerror(errno)); - FUZZTEST_INTERNAL_CHECK(dup2(fileno(tmp), fd) != -1, - "dup2() error:", strerror(errno)); - FUZZTEST_INTERNAL_CHECK(fclose(tmp) == 0, "fclose() error:", strerror(errno)); + FUZZTEST_CHECK(tmp) << "fopen() error: " << strerror(errno); + FUZZTEST_CHECK(dup2(fileno(tmp), fd) != -1) << "dup2() error: ", + strerror(errno); + FUZZTEST_CHECK(fclose(tmp) == 0) << "fclose() error: " << strerror(errno); } // Only accepts 1 or 2 (stdout or stderr). @@ -59,12 +60,12 @@ void Silence(int fd) { // If it's a stderr, silence it after duping it as the global stderr, which // will be used internally to log and be used when restoring the stderr. void DupAndSilence(int fd) { - FUZZTEST_INTERNAL_CHECK(fd == STDOUT_FILENO || fd == STDERR_FILENO, - "DupAndSilence only accepts stderr or stdout."); + FUZZTEST_CHECK(fd == STDOUT_FILENO || fd == STDERR_FILENO) + << "DupAndSilence only accepts stderr or stdout."; int new_fd = dup(fd); - FUZZTEST_INTERNAL_CHECK(new_fd != -1, "dup() error:", strerror(errno)); + FUZZTEST_CHECK(new_fd != -1) << "dup() error:" << strerror(errno); FILE* new_output_file = fdopen(new_fd, "w"); - FUZZTEST_INTERNAL_CHECK(new_output_file, "fdopen error:", strerror(errno)); + FUZZTEST_CHECK(new_output_file) << "fdopen error:" << strerror(errno); if (new_output_file) { if (fd == STDOUT_FILENO) { stdout_file_ = new_output_file; @@ -90,21 +91,21 @@ void RestoreTargetStdoutAndStderr() { FILE* silenced_stderr = stderr_file_; stderr_file_ = stderr; stderr_file_guard_.Unlock(); - FUZZTEST_INTERNAL_CHECK(silenced_stderr != stderr, - "Error, calling RestoreStderr without calling" - "DupandSilenceStderr first."); - FUZZTEST_INTERNAL_CHECK(dup2(fileno(silenced_stderr), STDERR_FILENO) != -1, - "dup2 error:", strerror(errno)); - FUZZTEST_INTERNAL_CHECK(fclose(silenced_stderr) == 0, - "close() error:", strerror(errno)); - - FUZZTEST_INTERNAL_CHECK(stdout_file_ != stdout, - "Error, calling RestoreStdout without calling" - "DupandSilenceStdout first."); - FUZZTEST_INTERNAL_CHECK(dup2(fileno(stdout_file_), STDOUT_FILENO) != -1, - "dup2() error:", strerror(errno)); - FUZZTEST_INTERNAL_CHECK(fclose(stdout_file_) == 0, - "close() error:", strerror(errno)); + FUZZTEST_CHECK(silenced_stderr != stderr) + << "Error, calling RestoreStderr without calling" + "DupandSilenceStderr first."; + FUZZTEST_CHECK(dup2(fileno(silenced_stderr), STDERR_FILENO) != -1) + << "dup2 error:" << strerror(errno); + FUZZTEST_CHECK(fclose(silenced_stderr) == 0) + << "close() error:" << strerror(errno); + + FUZZTEST_CHECK(stdout_file_ != stdout) + << "Error, calling RestoreStdout without calling" + "DupandSilenceStdout first."; + FUZZTEST_CHECK(dup2(fileno(stdout_file_), STDOUT_FILENO) != -1) + << "dup2() error:" << strerror(errno); + FUZZTEST_CHECK(fclose(stdout_file_) == 0) + << "close() error:" << strerror(errno); stdout_file_ = stdout; } @@ -130,11 +131,6 @@ FILE* GetStderr() { return stderr_file_; } -void Abort(const char* file, int line, const std::string& message) { - fprintf(GetStderr(), "%s:%d: %s\n", file, line, message.c_str()); - std::abort(); -} - const std::string* volatile test_abort_message = nullptr; void AbortInTest(const std::string& message) { // When we are within a test, we set the message here and call abort(). diff --git a/fuzztest/internal/logging.h b/fuzztest/internal/logging.h index b7b8d4a1c..94c9b534f 100644 --- a/fuzztest/internal/logging.h +++ b/fuzztest/internal/logging.h @@ -20,6 +20,7 @@ #include "absl/strings/str_cat.h" +// TODO(b/422182911): Remove this library. namespace fuzztest::internal { // Returns the current FILE pointing to the original stderr. @@ -36,21 +37,6 @@ void RestoreTargetStdoutAndStderr(); // Check if FUZZTEST_SILENCE_TARGET env set. bool IsSilenceTargetEnabled(); -[[noreturn]] void Abort(const char* file, int line, const std::string& message); - -#define FUZZTEST_INTERNAL_CHECK_PRECONDITION(P, ...) \ - ((P) ? (void)0 \ - : ::fuzztest::internal::Abort( \ - __FILE__, __LINE__, \ - absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__))) - -#define FUZZTEST_INTERNAL_CHECK(cond, ...) \ - ((cond) ? (void)0 \ - : ::fuzztest::internal::Abort( \ - __FILE__, __LINE__, \ - absl::StrCat("Internal error! Check (", #cond, \ - ") failed: ", __VA_ARGS__))) - // This Abort function will inject `message` into the signal handler's output // along with the file, line and test name of the currently running test. // Meant for failures related to test setup and not the code under test itself. diff --git a/fuzztest/internal/register_fuzzing_mocks.cc b/fuzztest/internal/register_fuzzing_mocks.cc index 1a51cead8..6bb05df37 100644 --- a/fuzztest/internal/register_fuzzing_mocks.cc +++ b/fuzztest/internal/register_fuzzing_mocks.cc @@ -26,7 +26,6 @@ #include "absl/base/fast_type_id.h" #include "absl/functional/function_ref.h" -#include "absl/log/absl_check.h" #include "absl/random/bernoulli_distribution.h" #include "absl/random/beta_distribution.h" #include "absl/random/distributions.h" @@ -36,6 +35,7 @@ #include "absl/random/poisson_distribution.h" #include "absl/random/zipf_distribution.h" #include "absl/types/span.h" +#include "./common/logging.h" namespace fuzztest::internal { namespace { @@ -103,7 +103,7 @@ struct DataStreamConsumer { // Returns a value in the closed-closed range [min, max]. template T ConsumeValueInRange(T min, T max) { - ABSL_CHECK_LE(min, max); + FUZZTEST_CHECK_LE(min, max); if (min == max) return min; diff --git a/fuzztest/internal/runtime.cc b/fuzztest/internal/runtime.cc index 6bb21fed5..9db208f12 100644 --- a/fuzztest/internal/runtime.cc +++ b/fuzztest/internal/runtime.cc @@ -40,7 +40,6 @@ #include "absl/functional/bind_front.h" #include "absl/functional/function_ref.h" -#include "absl/log/absl_check.h" #include "absl/random/bit_gen_ref.h" #include "absl/random/discrete_distribution.h" #include "absl/random/random.h" @@ -58,6 +57,7 @@ #include "absl/time/time.h" #include "absl/types/span.h" #include "./common/bazel.h" +#include "./common/logging.h" #include "./fuzztest/internal/configuration.h" #include "./fuzztest/internal/corpus_database.h" #include "./fuzztest/internal/coverage.h" @@ -107,7 +107,7 @@ std::string GetReproductionCommand(const Configuration* configuration, absl::string_view test_name) { const bool is_reproducer_in_corpus_db = configuration && configuration->crashing_input_to_reproduce; - ABSL_CHECK(!reproducer_path.empty() || is_reproducer_in_corpus_db); + FUZZTEST_CHECK(!reproducer_path.empty() || is_reproducer_in_corpus_db); if (!configuration || !configuration->reproduction_command_template) { absl::string_view reproducer = is_reproducer_in_corpus_db ? *configuration->crashing_input_to_reproduce @@ -121,8 +121,8 @@ std::string GetReproductionCommand(const Configuration* configuration, } const std::string command_template = *configuration->reproduction_command_template; - ABSL_CHECK(absl::StrContains(command_template, kTestFilterPlaceholder)); - ABSL_CHECK(absl::StrContains(command_template, kExtraArgsPlaceholder)); + FUZZTEST_CHECK(absl::StrContains(command_template, kTestFilterPlaceholder)); + FUZZTEST_CHECK(absl::StrContains(command_template, kExtraArgsPlaceholder)); if (is_reproducer_in_corpus_db) { const std::string corpus_db = configuration->corpus_database; std::vector extra_args = {absl::StrCat( @@ -218,9 +218,8 @@ void PrintReproducerIfRequested(RawSink out, const FuzzTest& test, Basename(reproducer_path)); break; default: - FUZZTEST_INTERNAL_CHECK(false, - "unsupported reproducer output location type " - "to print reproduction command for"); + FUZZTEST_CHECK(false) << "unsupported reproducer output location type " + "to print reproduction command for"; } } absl::Format( @@ -258,9 +257,9 @@ std::string Runtime::DumpReproducer() const { "- not writing the reproducer file.\n"); return ""; } - FUZZTEST_INTERNAL_CHECK(!out_location.dir_path.empty(), - "Reproducer output directory must not be empty if " - "not reporting to controller."); + FUZZTEST_CHECK(!out_location.dir_path.empty()) + << "Reproducer output directory must not be empty if " + "not reporting to controller."; const std::string content = current_args_->domain.SerializeCorpus(current_args_->corpus_value) .ToString(); @@ -474,7 +473,7 @@ void Runtime::CheckWatchdogLimits() { void Runtime::SetCurrentTest(const FuzzTest* test, const Configuration* configuration) { - ABSL_CHECK((test != nullptr) == (configuration != nullptr)); + FUZZTEST_CHECK((test != nullptr) == (configuration != nullptr)); current_test_ = test; current_configuration_ = configuration; if (configuration == nullptr) return; @@ -484,11 +483,9 @@ void Runtime::SetCurrentTest(const FuzzTest* test, fuzztest::internal::VerifyBazelHasEnoughTimeToRunTest( creation_time_, test_time_limit, test_counter_, configuration->fuzz_tests.size()); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - has_enough_time.ok(), - absl::StrCat("Not enough time for running the fuzz test ", - test->full_name(), " for ", test_time_limit, ": ", - has_enough_time)); + FUZZTEST_PRECONDITION(has_enough_time.ok()) + << "Not enough time for running the fuzz test " << test->full_name() + << " for " << test_time_limit << ": " << has_enough_time; } ++test_counter_; } @@ -678,8 +675,8 @@ FuzzTestFuzzerImpl::FuzzTestFuzzerImpl( corpus_coverage_(execution_coverage_ != nullptr ? execution_coverage_->GetCounterMap().size() : 0) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(fixture_driver_ != nullptr, - "Invalid fixture driver!"); + FUZZTEST_PRECONDITION(fixture_driver_ != nullptr) + << "Invalid fixture driver!"; stats_.start_time = absl::Now(); const char* corpus_out_dir_chars = getenv("FUZZTEST_TESTSUITE_OUT_DIR"); if (corpus_out_dir_chars) corpus_out_dir_ = corpus_out_dir_chars; @@ -807,12 +804,11 @@ std::optional FuzzTestFuzzerImpl::ReadReproducerToMinimize() { std::optional reproducer; ForEachInput({std::string(file)}, [&](absl::string_view, std::optional, Input input) { - FUZZTEST_INTERNAL_CHECK(!reproducer.has_value(), - "Multiple inputs found in ", file); + FUZZTEST_CHECK(!reproducer.has_value()) + << "Multiple inputs found in " << file; reproducer = std::move(input.args); }); - FUZZTEST_INTERNAL_CHECK(reproducer.has_value(), - "Failed to read minimizer file!"); + FUZZTEST_CHECK(reproducer.has_value()) << "Failed to read minimizer file!"; return *reproducer; } @@ -1066,9 +1062,8 @@ bool FuzzTestFuzzerImpl::RunInUnitTestMode(const Configuration& configuration) { auto duration = absl::Seconds(1); const auto fuzz_for = absl::NullSafeStringView(getenv("FUZZTEST_FUZZ_FOR")); if (!fuzz_for.empty()) { - FUZZTEST_INTERNAL_CHECK( - absl::ParseDuration(fuzz_for, &duration), - "Could not parse duration in FUZZTEST_FUZZ_FOR=", fuzz_for); + FUZZTEST_CHECK(absl::ParseDuration(fuzz_for, &duration)) + << "Could not parse duration in FUZZTEST_FUZZ_FOR=" << fuzz_for; } const auto time_limit = stats_.start_time + duration; Input mutation{params_domain_.Init(prng)}; @@ -1158,9 +1153,8 @@ void FuzzTestFuzzerImpl::MinimizeNonFatalFailureLocally(absl::BitGenRef prng) { constexpr int kMaxTriedWithoutFailure = 10000; while (tries_without_failure < kMaxTriedWithoutFailure && absl::Now() < deadline) { - FUZZTEST_INTERNAL_CHECK( - minimal_non_fatal_counterexample_.has_value(), - "Caller didn't populate minimal_non_fatal_counterexample_"); + FUZZTEST_CHECK(minimal_non_fatal_counterexample_.has_value()) + << "Caller didn't populate minimal_non_fatal_counterexample_"; auto copy = *minimal_non_fatal_counterexample_; // Mutate a random number of times, in case one is not enough to // reach another failure, but prefer a low number of mutations (thus Zipf). @@ -1238,9 +1232,9 @@ bool FuzzTestFuzzerImpl::RunInFuzzingMode(int* /*argc*/, char*** /*argv*/, corpus_database.GetCoverageInputsIfAny(test_.full_name())); InitializeCorpus(prng); - FUZZTEST_INTERNAL_CHECK(!corpus_.empty(), - "No seed input coverage registered. Test function " - "might be uninstrumented?"); + FUZZTEST_CHECK(!corpus_.empty()) + << "No seed input coverage registered. Test function " + "might be uninstrumented?"; constexpr size_t kRunsPerInit = 32000; size_t next_init = kRunsPerInit; @@ -1305,8 +1299,8 @@ bool FuzzTestFuzzerImpl::RunInFuzzingMode(int* /*argc*/, char*** /*argv*/, return {params_domain_.Init(prng)}; } else { size_t idx = static_cast(corpus_distribution_(prng)); - FUZZTEST_INTERNAL_CHECK(0 <= idx && idx < corpus_.size(), - "Corpus input weights are outdated!\n"); + FUZZTEST_CHECK(0 <= idx && idx < corpus_.size()) + << "Corpus input weights are outdated!\n"; return corpus_[idx]; } }(); diff --git a/fuzztest/internal/seed_seq.cc b/fuzztest/internal/seed_seq.cc index 1bf485c1e..2f8896b2c 100644 --- a/fuzztest/internal/seed_seq.cc +++ b/fuzztest/internal/seed_seq.cc @@ -29,6 +29,7 @@ #include "absl/strings/escaping.h" #include "absl/strings/string_view.h" #include "absl/types/span.h" +#include "./common/logging.h" #include "./fuzztest/internal/logging.h" namespace fuzztest::internal { @@ -51,9 +52,9 @@ std::vector GetFromEnvOrMakeSeedMaterial(absl::string_view env_var) { } std::optional> seed_material = DecodeSeedMaterial(encoded_seed_material); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - seed_material.has_value(), - "Failed to decode seed material from the environment variable ", env_var); + FUZZTEST_PRECONDITION(seed_material.has_value()) + << "Failed to decode seed material from the environment variable " + << env_var; return *std::move(seed_material); } diff --git a/fuzztest/internal/subprocess.cc b/fuzztest/internal/subprocess.cc index 1dbf7e870..54e0aff0a 100644 --- a/fuzztest/internal/subprocess.cc +++ b/fuzztest/internal/subprocess.cc @@ -45,7 +45,7 @@ #include "absl/time/clock.h" #include "absl/time/time.h" #include "absl/types/span.h" -#include "./fuzztest/internal/logging.h" +#include "./common/logging.h" #if !defined(_MSC_VER) // Needed to pass the current environment to posix_spawn, which needs an @@ -68,7 +68,7 @@ bool TerminationStatus::Signaled() const { return WIFSIGNALED(status_); } std::variant TerminationStatus::Status() const { if (Exited()) return static_cast(WEXITSTATUS(status_)); - FUZZTEST_INTERNAL_CHECK(Signaled(), "!Exited && !Signaled"); + FUZZTEST_CHECK(Signaled()) << "!Exited && !Signaled"; return static_cast(WTERMSIG(status_)); } @@ -108,29 +108,28 @@ class SubProcess { void SubProcess::CreatePipes() { for (int channel : {kStdOutIdx, kStdErrIdx}) { int pipe_fds[2]; - FUZZTEST_INTERNAL_CHECK(pipe(pipe_fds) == 0, - "Cannot create pipe: ", strerror(errno)); + FUZZTEST_CHECK(pipe(pipe_fds) == 0) << "Cannot create pipe: ", + strerror(errno); parent_pipe_[channel] = pipe_fds[0]; child_pipe_[channel] = pipe_fds[1]; - FUZZTEST_INTERNAL_CHECK( - fcntl(parent_pipe_[channel], F_SETFL, O_NONBLOCK) != -1, - "Cannot make pipe non-blocking: ", strerror(errno)); + FUZZTEST_CHECK(fcntl(parent_pipe_[channel], F_SETFL, O_NONBLOCK) != -1) + << "Cannot make pipe non-blocking: " << strerror(errno); } } void SubProcess::CloseChildPipes() { for (int channel : {kStdOutIdx, kStdErrIdx}) { - FUZZTEST_INTERNAL_CHECK(close(child_pipe_[channel]) != -1, - "Cannot close pipe: ", strerror(errno)); + FUZZTEST_CHECK(close(child_pipe_[channel]) != -1) + << "Cannot close pipe: " << strerror(errno); } } void SubProcess::CloseParentPipes() { for (int channel : {kStdOutIdx, kStdErrIdx}) { - FUZZTEST_INTERNAL_CHECK(close(parent_pipe_[channel]) != -1, - "Cannot close pipe: ", strerror(errno)); + FUZZTEST_CHECK(close(parent_pipe_[channel]) != -1) + << "Cannot close pipe: " << strerror(errno); } } @@ -141,28 +140,24 @@ posix_spawn_file_actions_t SubProcess::CreateChildFileActions() { int err; err = posix_spawn_file_actions_init(&actions); - FUZZTEST_INTERNAL_CHECK(err == 0, - "Cannot initialize file actions: ", strerror(err)); + FUZZTEST_CHECK(err == 0) << "Cannot initialize file actions: " + << strerror(err); // Close stdin. err = posix_spawn_file_actions_addclose(&actions, STDIN_FILENO); - FUZZTEST_INTERNAL_CHECK(err == 0, - "Cannot add close() action: ", strerror(err)); + FUZZTEST_CHECK(err == 0) << "Cannot add close() action: " << strerror(err); for (int channel : {kStdOutIdx, kStdErrIdx}) { // Close parent-side pipes. err = posix_spawn_file_actions_addclose(&actions, parent_pipe_[channel]); - FUZZTEST_INTERNAL_CHECK(err == 0, - "Cannot add close() action: ", strerror(err)); + FUZZTEST_CHECK(err == 0) << "Cannot add close() action: " << strerror(err); // Replace stdout/stderr file descriptors with the pipes. int fd = channel == kStdOutIdx ? STDOUT_FILENO : STDERR_FILENO; err = posix_spawn_file_actions_adddup2(&actions, child_pipe_[channel], fd); - FUZZTEST_INTERNAL_CHECK(err == 0, - "Cannot add dup2() action: ", strerror(err)); + FUZZTEST_CHECK(err == 0) << "Cannot add dup2() action: " << strerror(err); err = posix_spawn_file_actions_addclose(&actions, child_pipe_[channel]); - FUZZTEST_INTERNAL_CHECK(err == 0, - "Cannot add close() action: ", strerror(err)); + FUZZTEST_CHECK(err == 0) << "Cannot add close() action: " << strerror(err); } return actions; @@ -198,16 +193,15 @@ pid_t SubProcess::StartChild( int err; err = posix_spawnp(&child_pid, argv[0], &actions, nullptr, argv.data(), environment.has_value() ? envp.data() : environ); - FUZZTEST_INTERNAL_CHECK(err == 0, - "Cannot spawn child process: ", strerror(err)); + FUZZTEST_CHECK(err == 0) << "Cannot spawn child process: ", strerror(err); // Free up the used parameters. for (char* p : argv) free(p); for (char* p : envp) free(p); err = posix_spawn_file_actions_destroy(&actions); - FUZZTEST_INTERNAL_CHECK(err == 0, - "Cannot destroy file actions: ", strerror(err)); + FUZZTEST_CHECK(err == 0) + "Cannot destroy file actions: " << strerror(err); return child_pid; } @@ -235,9 +229,9 @@ void SubProcess::ReadChildOutput( while (fd_remain > 0) { int ret = poll(pfd, fd_count, -1); if ((ret == -1) && !ShouldRetry(errno)) { - FUZZTEST_INTERNAL_CHECK(false, "Cannot poll(): ", strerror(errno)); + FUZZTEST_CHECK(false) << "Cannot poll(): " << strerror(errno); } else if (ret == 0) { - FUZZTEST_INTERNAL_CHECK(false, "Impossible timeout: ", strerror(errno)); + FUZZTEST_CHECK(false) << "Impossible timeout: " << strerror(errno); } else if (ret > 0) { for (int channel : {kStdOutIdx, kStdErrIdx}) { // According to the poll() spec, use -1 for ignored entries. @@ -274,7 +268,7 @@ int Wait(pid_t pid) { } else if (ret == pid && (WIFEXITED(status) || WIFSIGNALED(status))) { return status; } else { - FUZZTEST_INTERNAL_CHECK(false, "wait() error: ", strerror(errno)); + FUZZTEST_CHECK(false) << "wait() error: " << strerror(errno); } } } @@ -291,8 +285,8 @@ int WaitWithStopChecker(pid_t pid, absl::FunctionRef should_stop) { continue; } else if (ret == 0) { // Still running. if (should_stop()) { - FUZZTEST_INTERNAL_CHECK(kill(pid, SIGTERM) == 0, - "Cannot kill(): ", strerror(errno)); + FUZZTEST_CHECK(kill(pid, SIGTERM) == 0) + << "Cannot kill(): " << strerror(errno); return Wait(pid); } else { absl::SleepFor(sleep_duration); @@ -301,7 +295,7 @@ int WaitWithStopChecker(pid_t pid, absl::FunctionRef should_stop) { } else if (ret == pid && (WIFEXITED(status) || WIFSIGNALED(status))) { return status; } else { - FUZZTEST_INTERNAL_CHECK(false, "wait() error: ", strerror(errno)); + FUZZTEST_CHECK(false) "wait() error: " << strerror(errno); } } } @@ -336,15 +330,13 @@ TerminationStatus RunCommandWithCallbacks( const std::optional>& environment) { #if defined(_MSC_VER) - FUZZTEST_INTERNAL_CHECK(false, - "Subprocess library not implemented on Windows yet."); + FUZZTEST_CHECK(false) << "Subprocess library not implemented on Windows yet."; #elif defined(__ANDROID_MIN_SDK_VERSION__) && __ANDROID_MIN_SDK_VERSION__ < 28 - FUZZTEST_INTERNAL_CHECK( - false, - "Subprocess library not implemented on older Android NDK versions yet"); + FUZZTEST_CHECK(false) + << "Subprocess library not implemented on older Android NDK versions yet"; #elif defined(TARGET_OS_TV) && TARGET_OS_TV - FUZZTEST_INTERNAL_CHECK( - false, "Subprocess library not implemented on Apple tvOS yet"); + FUZZTEST_INTERNAL_CHECK(false) + << "Subprocess library not implemented on Apple tvOS yet"; #else SubProcess proc; return proc.Run(command_line, on_stdout_output, on_stderr_output, should_stop, diff --git a/fuzztest/llvm_fuzzer_wrapper.cc b/fuzztest/llvm_fuzzer_wrapper.cc index 49c3235f0..c187773e8 100644 --- a/fuzztest/llvm_fuzzer_wrapper.cc +++ b/fuzztest/llvm_fuzzer_wrapper.cc @@ -12,17 +12,16 @@ #include "absl/base/thread_annotations.h" #include "absl/flags/declare.h" #include "absl/flags/flag.h" -#include "absl/log/absl_check.h" #include "absl/random/bit_gen_ref.h" #include "absl/random/random.h" #include "absl/synchronization/mutex.h" +#include "./common/logging.h" #include "./fuzztest/fuzztest.h" #include "./fuzztest/fuzztest_macros.h" #include "./fuzztest/internal/domains/arbitrary_impl.h" #include "./fuzztest/internal/domains/container_of_impl.h" #include "./fuzztest/internal/domains/domain_base.h" #include "./fuzztest/internal/io.h" -#include "./fuzztest/internal/logging.h" ABSL_DECLARE_FLAG(std::string, llvm_fuzzer_wrapper_dict_file); ABSL_DECLARE_FLAG(std::string, llvm_fuzzer_wrapper_corpus_dir); @@ -75,7 +74,7 @@ std::vector> ReadByteArrayDictionaryFromFile() { for (const fuzztest::internal::FilePathAndData& file : files) { absl::StatusOr> parsed_entries = fuzztest::ParseDictionary(file.data); - ABSL_CHECK(parsed_entries.status().ok()) + FUZZTEST_CHECK(parsed_entries.status().ok()) << "Could not parse dictionary file " << file.path << ": " << parsed_entries.status(); for (const std::string& parsed_entry : *parsed_entries) { @@ -104,45 +103,38 @@ class LLVMFuzzerMutateMetadataManager { public: void Activate(MutationMetadata mutation_metadata) { absl::MutexLock lock(&mu_); - FUZZTEST_INTERNAL_CHECK( - !mutation_metadata_.has_value(), - "MutationMetadata is already active before calling Activate()!"); - FUZZTEST_INTERNAL_CHECK( - acquire_count_ == 0, - "MutationMetadata still has readers before being calling Activate()!"); + FUZZTEST_CHECK(!mutation_metadata_.has_value()) + << "MutationMetadata is already active before calling Activate()!"; + FUZZTEST_CHECK(acquire_count_ == 0) << "MutationMetadata still has readers " + "before being calling Activate()!"; mutation_metadata_ = std::move(mutation_metadata); } void Deactivate() { absl::MutexLock lock(&mu_); - FUZZTEST_INTERNAL_CHECK( - mutation_metadata_.has_value(), - "MutationMetadata is not active before calling Deactivate()!"); - FUZZTEST_INTERNAL_CHECK( - acquire_count_ == 0, - "MutationMetadata still has readers before calling Deactivate()!"); + FUZZTEST_CHECK(mutation_metadata_.has_value()) + << "MutationMetadata is not active before calling Deactivate()!"; + FUZZTEST_CHECK(acquire_count_ == 0) + << "MutationMetadata still has readers before calling Deactivate()!"; mutation_metadata_ = std::nullopt; } const MutationMetadata& Acquire() { absl::MutexLock lock(&mu_); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - mutation_metadata_.has_value(), - "Cannot acquire unavailable mutation metadata, likely due to the " - "fuzzer calling LLVMFuzzerMutate() outside of " - "LLVMFuzzerCustomMutator() invocation, which is not allowed."); + FUZZTEST_PRECONDITION(mutation_metadata_.has_value()) + << "Cannot acquire unavailable mutation metadata, likely due to the " + "fuzzer calling LLVMFuzzerMutate() outside of " + "LLVMFuzzerCustomMutator() invocation, which is not allowed."; ++acquire_count_; return *mutation_metadata_; } void Release() { absl::MutexLock lock(&mu_); - FUZZTEST_INTERNAL_CHECK( - mutation_metadata_.has_value(), - "MutationMetadata is not active before calling Release()!"); - FUZZTEST_INTERNAL_CHECK( - acquire_count_ > 0, - "MutationMetadata has no readers before calling Release()!"); + FUZZTEST_CHECK(mutation_metadata_.has_value()) + << "MutationMetadata is not active before calling Release()!"; + FUZZTEST_CHECK(acquire_count_ > 0) + << "MutationMetadata has no readers before calling Release()!"; --acquire_count_; } diff --git a/grammar_codegen/BUILD b/grammar_codegen/BUILD index 8b6b140f6..f7155bd33 100644 --- a/grammar_codegen/BUILD +++ b/grammar_codegen/BUILD @@ -29,9 +29,11 @@ cc_library( features = ["-use_header_modules"], # Incompatible with -fexceptions. deps = [ ":grammar_info", + "@abseil-cpp//absl/log:absl_check", + "@abseil-cpp//absl/log:absl_log", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", - "@com_google_fuzztest//fuzztest/internal:logging", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//grammar_codegen/generated_antlr_parser", ], ) @@ -46,6 +48,7 @@ cc_library( "@abseil-cpp//absl/container:flat_hash_set", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//fuzztest/internal:logging", ], ) diff --git a/grammar_codegen/antlr_frontend.cc b/grammar_codegen/antlr_frontend.cc index cabb68b56..4174fdfd1 100644 --- a/grammar_codegen/antlr_frontend.cc +++ b/grammar_codegen/antlr_frontend.cc @@ -25,9 +25,9 @@ #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" #include "./grammar_codegen/generated_antlr_parser/ANTLRv4Lexer.h" #include "./grammar_codegen/grammar_info.h" -#include "./fuzztest/internal/logging.h" namespace fuzztest::internal::grammar { @@ -56,9 +56,9 @@ std::string EscapeString(absl::string_view text) { // Add '^' to the char set if it is a NOT set. std::string ConstructCharSetString(absl::string_view raw_str, bool is_not_set = false) { - FUZZTEST_INTERNAL_CHECK( - raw_str.size() > 2 && raw_str.front() == '[' && raw_str.back() == ']', - "Passed argument is not a range string: `" + std::string(raw_str) + "`"); + FUZZTEST_CHECK(raw_str.size() > 2 && raw_str.front() == '[' && + raw_str.back() == ']') + << "Passed argument is not a range string: `" << raw_str << "`"; std::string result(raw_str); if (is_not_set) { result = absl::StrFormat("[^%s]", result.substr(1, result.size() - 2)); @@ -104,7 +104,7 @@ Block GrammarInfoBuilder::ConstructBlock( if (lexer_atom_ctx->terminal() && lexer_atom_ctx->terminal()->TOKEN_REF()) { auto k = block.element.emplace( NonTerminal{lexer_atom_ctx->getText()}); - FUZZTEST_INTERNAL_CHECK(!k.name.empty(), "Empty name!"); + FUZZTEST_CHECK(!k.name.empty()) << "Empty name!"; } else { auto& terminal = block.element.emplace(); std::string text = lexer_atom_ctx->getText(); @@ -123,16 +123,16 @@ Block GrammarInfoBuilder::ConstructBlock( terminal.content = ConstructCharSetString(set_element_p->getText(), true); } else { - FUZZTEST_INTERNAL_CHECK(false, "Not lexer char set!"); + FUZZTEST_CHECK(false) << "Not lexer char set!"; } } else { - FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!"); + FUZZTEST_CHECK(false) << "Unhandled case!"; } } else if (lexer_atom_ctx->DOT()) { terminal.type = TerminalType::kCharSet; terminal.content = EscapeString(lexer_atom_ctx->DOT()->getText()); } else { - FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!"); + FUZZTEST_CHECK(false) << "Unhandled case!"; } } return block; @@ -152,7 +152,7 @@ ProductionRule GrammarInfoBuilder::ConstructProductionRule( } else if (element->lexerAtom() != NULL) { block = ConstructBlock(element->lexerAtom()); } else { - FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!"); + FUZZTEST_CHECK(false) << "Unhandled case!"; } if (element->ebnfSuffix()) { block.range = ParseRange(element->ebnfSuffix()->getText()); @@ -175,13 +175,14 @@ GrammarRule GrammarInfoBuilder::ConstructGrammarRule( } Range GrammarInfoBuilder::ParseRange(absl::string_view s) { - return (s == "?") ? Range::kOptional - : (s == "+" || s == "+?") ? Range::kNonEmpty - : (s == "*" || s == "*?") - ? Range::kUnlimited - : (FUZZTEST_INTERNAL_CHECK(false, - absl::StrCat("Unhandled case: ", s)), - Range::kNoRange); + if (s == "?") { + return Range::kOptional; + } else if (s == "+" || s == "*?") { + return Range::kNonEmpty; + } else if (s == "*" || s == "*?") { + return Range::kUnlimited; + } + FUZZTEST_CHECK(false) << "Unhandled case: " << s; } Block GrammarInfoBuilder::ConstructBlock( @@ -209,7 +210,7 @@ Block GrammarInfoBuilder::ConstructBlock(ANTLRv4Parser::AtomContext* atom_ctx) { ChangeStringQuote(node_name); terminal_node.content = node_name; } else { - FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!"); + FUZZTEST_CHECK(false) << "Unhandled case!"; } return constructed_block; } @@ -231,15 +232,14 @@ Block GrammarInfoBuilder::ConstructBlock( } else if (labeled_element->block()) { constructed_block = ConstructBlock(labeled_element->block()); } else { - FUZZTEST_INTERNAL_CHECK(false, "Impossible case!"); + FUZZTEST_CHECK(false) << "Impossible case!"; } } else { - FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!"); + FUZZTEST_CHECK(false) << "Unhandled case!"; } if (element->ebnfSuffix()) { - FUZZTEST_INTERNAL_CHECK(!suffix.has_value(), - "It should have only one suffix."); + FUZZTEST_CHECK(!suffix.has_value()) << "It should have only one suffix."; suffix = element->ebnfSuffix()->getText(); } @@ -272,7 +272,7 @@ GrammarRule GrammarInfoBuilder::ConstructGrammarRule( auto labeledAlt_vec = pctx->ruleBlock()->ruleAltList()->labeledAlt(); for (auto labeled_alt : pctx->ruleBlock()->ruleAltList()->labeledAlt()) { auto ctx = labeled_alt->alternative(); - FUZZTEST_INTERNAL_CHECK(ctx != nullptr, "Unhandeled case!"); + FUZZTEST_CHECK(ctx != nullptr) << "Unhandeled case!"; grammar_rule.productions.production_rules.push_back( ConstructProductionRule(ctx)); } @@ -282,8 +282,7 @@ GrammarRule GrammarInfoBuilder::ConstructGrammarRule( Grammar GrammarInfoBuilder::BuildGrammarInfo( const std::vector& input_grammar_specs, std::optional grammar_name, bool insert_space_between_blocks) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(!input_grammar_specs.empty(), - "No input files!"); + FUZZTEST_PRECONDITION(!input_grammar_specs.empty()) << "No input files!"; insert_space_between_blocks_ = insert_space_between_blocks; @@ -297,18 +296,18 @@ Grammar GrammarInfoBuilder::BuildGrammarInfo( antlr4::tree::ParseTree* tree = parser.grammarSpec(); antlr4::tree::ParseTreeWalker::DEFAULT.walk(this, tree); } catch (antlr4::ParseCancellationException) { - FUZZTEST_INTERNAL_CHECK(false, "Cannot parse the grammar files!"); + FUZZTEST_CHECK(false) << "Cannot parse the grammar files!"; } catch (...) { // The ParseCancellationException might miss some errors. So we need to // catch everything here. - FUZZTEST_INTERNAL_CHECK(false, "Unknown errors!"); + FUZZTEST_CHECK(false) << "Unknown errors!"; } } if (grammar_name.has_value()) { grammar_name_ = *grammar_name; } - FUZZTEST_INTERNAL_CHECK(!grammar_name_.empty() && !rules_.empty(), - "Wrong grammar file!"); + FUZZTEST_CHECK(!grammar_name_.empty() && !rules_.empty()) + << "Wrong grammar file!"; return Grammar{std::move(grammar_name_), std::move(rules_)}; } diff --git a/grammar_codegen/backend.cc b/grammar_codegen/backend.cc index c3dae475c..532318fd2 100644 --- a/grammar_codegen/backend.cc +++ b/grammar_codegen/backend.cc @@ -24,6 +24,7 @@ #include "absl/strings/str_format.h" #include "absl/strings/str_join.h" #include "absl/strings/string_view.h" +#include "./common/logging.h" #include "./grammar_codegen/grammar_info.h" #include "./fuzztest/internal/logging.h" @@ -45,11 +46,9 @@ void SwitchBlockToNewNonTerminal(Block& block, std::string symbol_name) { std::string CreateIRNodeNameForClass(absl::string_view symbol_name) { static int counter = 0; - FUZZTEST_INTERNAL_CHECK( - symbol_name.size() > 4 && - symbol_name.substr(symbol_name.size() - 4) == "Node", - std::string("Not a valid symbol class name: ") + " " + - std::string(symbol_name)); + FUZZTEST_CHECK(symbol_name.size() > 4 && + symbol_name.substr(symbol_name.size() - 4) == "Node") + << "Not a valid symbol class name: " << symbol_name; return absl::StrFormat( "%sSubNode%d", symbol_name.substr(0, symbol_name.size() - 4), counter++); } @@ -284,18 +283,16 @@ std::string CodeGenerator::BuildBaseTypeForGrammarRule( std::string class_name = GetClassNameForSymbol(rule.symbol_name); const std::vector& prod_rules = rule.productions.production_rules; - FUZZTEST_INTERNAL_CHECK(!prod_rules.empty(), "No expansion!"); + FUZZTEST_CHECK(!prod_rules.empty()) << "No expansion!"; if (prod_rules.size() > 1) { // This is a variant. std::vector production_child_types; for (const ProductionRule& prod_rule : prod_rules) { - FUZZTEST_INTERNAL_CHECK(prod_rule.blocks.size() == 1, - "Incorrect preprocess."); + FUZZTEST_CHECK(prod_rule.blocks.size() == 1) << "Incorrect preprocess."; auto block = prod_rule.blocks[0]; - FUZZTEST_INTERNAL_CHECK( - block.range == Range::kNoRange && - block.element.index() != BlockType::kSubProductions, - "Incorrect preprocess."); + FUZZTEST_CHECK(block.range == Range::kNoRange && + block.element.index() != BlockType::kSubProductions) + << "Incorrect preprocess."; production_child_types.push_back(GetClassName(block)); } return absl::StrFormat("VariantDomain", class_name, @@ -312,10 +309,9 @@ std::string CodeGenerator::BuildBaseTypeForGrammarRule( std::vector production_child_types; auto blocks = prod_rules[0].blocks; for (const auto& block : blocks) { - FUZZTEST_INTERNAL_CHECK( - block.range == Range::kNoRange && - block.element.index() != BlockType::kSubProductions, - "Incorrect preprocess."); + FUZZTEST_CHECK(block.range == Range::kNoRange && + block.element.index() != BlockType::kSubProductions) + << "Incorrect preprocess."; production_child_types.push_back(GetClassName(block)); } return absl::StrFormat("TupleDomain", class_name, @@ -390,7 +386,7 @@ bool CodeGenerator::TryMarkBlockAsSafe(Block& block) { return is_safe; } default: - FUZZTEST_INTERNAL_CHECK(false, "The execution should never reach here!"); + FUZZTEST_LOG(FATAL) << "unreachable"; } } @@ -422,9 +418,8 @@ void CodeGenerator::CalculateFallBackIndex(std::vector& rules) { } while (has_change); for (size_t i = 0; i < safe_rule_indexes.size(); ++i) { - FUZZTEST_INTERNAL_CHECK( - safe_rule_indexes[i], - absl::StrCat("Some node is not safe: ", rules[i].symbol_name)); + FUZZTEST_CHECK(safe_rule_indexes[i]) + << "Some node is not safe: " << rules[i].symbol_name; } // Ensure that every sub-block is marked safe. For example, a grammar rule @@ -453,13 +448,13 @@ std::string CodeGenerator::GetClassName(const Block& block) { return GetClassNameForSymbol( std::get(block.element).name); default: - FUZZTEST_INTERNAL_CHECK(false, "A sub-block doesn't have a name!"); + FUZZTEST_LOG(FATAL) << "A sub-block doesn't have a name!"; } return ""; } std::string CodeGenerator::GetClassNameForSymbol(std::string id) { - FUZZTEST_INTERNAL_CHECK(!id.empty(), "Empty node name!"); + FUZZTEST_CHECK(!id.empty()) << "Empty node name!"; id[0] = toupper(id[0]); if (std::isdigit(id.back())) { return id; diff --git a/tools/BUILD b/tools/BUILD index 4587e7aaa..e441ce5a0 100644 --- a/tools/BUILD +++ b/tools/BUILD @@ -29,7 +29,7 @@ cc_binary( deps = [ "@abseil-cpp//absl/flags:flag", "@abseil-cpp//absl/flags:parse", - "@com_google_fuzztest//fuzztest/internal:logging", + "@com_google_fuzztest//common:logging", "@com_google_fuzztest//grammar_codegen:code_generation", ], ) diff --git a/tools/grammar_domain_code_generator.cc b/tools/grammar_domain_code_generator.cc index 66ba9bc66..0e0377e29 100644 --- a/tools/grammar_domain_code_generator.cc +++ b/tools/grammar_domain_code_generator.cc @@ -27,8 +27,8 @@ #include "absl/flags/flag.h" #include "absl/flags/parse.h" +#include "./common/logging.h" #include "./grammar_codegen/code_generation.h" -#include "./fuzztest/internal/logging.h" ABSL_FLAG(std::string, output_header_file_path, "", "Required. The path of the generated grammar header file."); @@ -62,19 +62,16 @@ int main(int argc, char** argv) { absl::ParseCommandLine(argc, argv); std::string output_file_path = absl::GetFlag(FLAGS_output_header_file_path); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !output_file_path.empty(), - "You must specify output file with --output_header_file_path"); + FUZZTEST_PRECONDITION(!output_file_path.empty()) + << "You must specify output file with --output_header_file_path"; std::ofstream output_file(output_file_path); - FUZZTEST_INTERNAL_CHECK_PRECONDITION(output_file.is_open(), - "Cannot open output file!"); + FUZZTEST_PRECONDITION(output_file.is_open()) << "Cannot open output file!"; std::vector input_files = absl::GetFlag(FLAGS_input_grammar_files); - FUZZTEST_INTERNAL_CHECK_PRECONDITION( - !input_files.empty(), - "You must provide the list of input files, separated by ','"); + FUZZTEST_PRECONDITION(!input_files.empty()) + << "You must provide the list of input files, separated by ','"; std::optional grammar_name = std::nullopt; if (!absl::GetFlag(FLAGS_top_level_rule).empty()) { @@ -83,8 +80,8 @@ int main(int argc, char** argv) { std::vector input_grammar_specs; for (const std::string& input_file : input_files) { - FUZZTEST_INTERNAL_CHECK_PRECONDITION(std::filesystem::exists(input_file), - input_file.c_str(), " not exist!"); + FUZZTEST_PRECONDITION(std::filesystem::exists(input_file)) + << input_file.c_str() << " not exist!"; input_grammar_specs.push_back(GetContents(input_file)); } output_file << fuzztest::internal::grammar::GenerateGrammarHeader(