// Copyright 2026 The GN Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <string>
#include <string_view>
#include <vector>

#include "base/command_line.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "gn/commands.h"
#include "gn/filesystem_utils.h"
#include "gn/input_file.h"
#include "gn/location.h"
#include "gn/setup.h"
#include "gn/standard_out.h"
#include "gn/switches.h"
#include "gn/target.h"
#include "gn/test_with_scheduler.h"
#include "gn/test_with_scope.h"
#include "util/test/test.h"

using SuggestTest = TestWithScheduler;

struct TestProject {
  base::ScopedTempDir in_temp_dir;
  base::ScopedTempDir build_temp_dir;
  base::FilePath in_path;
  base::FilePath build_path;
  Setup setup;

  TestProject(std::map<SourceFile, std::string> files) {
    EXPECT_TRUE(in_temp_dir.CreateUniqueTempDir());
    in_path = base::MakeAbsoluteFilePath(in_temp_dir.GetPath());
    EXPECT_TRUE(build_temp_dir.CreateUniqueTempDir());
    build_path = base::MakeAbsoluteFilePath(build_temp_dir.GetPath());

    files.try_emplace(SourceFile("//.gn"),
                      "buildconfig = \"//BUILDCONFIG.gn\"\n");
    files.try_emplace(SourceFile("//BUILDCONFIG.gn"), R"(
set_default_toolchain("//toolchain:default")
set_defaults("executable") {
  include_dirs = [ "//" ]
}
set_defaults("source_set") {
  include_dirs = [ "//" ]
}
)");
    files.try_emplace(SourceFile("//toolchain/BUILD.gn"), R"(
toolchain("default") {
  tool("cxx") {
    command = "cxx"
    outputs = [ "{{source_out_dir}}/{{source_file_part}}.o" ]
  }
  tool("link") {
    command = "link"
    outputs = [ "{{root_out_dir}}/{{target_output_name}}{{output_extension}}" ]
  }
  tool("stamp") {
    command = "stamp"
  }
}
)");

    for (const auto& [file, content] : files) {
      base::FilePath full_path = in_path.AppendASCII(file.value().substr(2));
      base::CreateDirectory(full_path.DirName());
      WriteFile(full_path, content, nullptr);
    }

    base::CommandLine cmdline(base::CommandLine::NO_PROGRAM);
    cmdline.AppendSwitchPath(switches::kRoot, in_path);
    EXPECT_TRUE(setup.DoSetup(FilePathToUTF8(build_path), true, cmdline));
    EXPECT_TRUE(setup.Run());
  }

  TestProject(std::string build_gn)
      : TestProject(std::map<SourceFile, std::string>{
            {SourceFile("//BUILD.gn"), std::move(build_gn)}}) {}

  std::vector<const Target*> targets() {
    return setup.builder().GetAllResolvedTargets();
  }

  const Label& default_toolchain() {
    return setup.loader()->default_toolchain_label();
  }

  std::string Read(const SourceFile& file) const {
    std::string content;
    base::FilePath full_path = in_path.AppendASCII(file.value().substr(2));
    base::ReadFileToString(full_path, &content);
    return content;
  }
};

TEST_F(SuggestTest, ResolveModuleName) {
  TestWithScope setup_scope;
  SourceDir current_dir("//");
  Label default_toolchain(SourceDir("//toolchain/"), "default");
  Err err;

  Target target(setup_scope.settings(), Label(SourceDir("//foo/"), "bar"));
  target.set_module_name("my_module");

  std::vector<const Target*> all_targets = {&target};

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, default_toolchain,
        "my_module");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected = {
        {&target, commands::ApiScope::kPublic}};
    EXPECT_EQ(expected, results);
    EXPECT_TRUE(ok);
  }

  // Test resolving module name "my_module_Private"
  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, default_toolchain,
        "my_module_Private");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected = {
        {&target, commands::ApiScope::kPrivate}};
    EXPECT_EQ(expected, results);
    EXPECT_TRUE(ok);
  }
}

TEST_F(SuggestTest, ResolveTargetName) {
  TestWithScope setup_scope;
  SourceDir current_dir("//");
  Label default_toolchain = setup_scope.toolchain()->label();
  Err err;

  Target target(
      setup_scope.settings(),
      Label(SourceDir("//"), "hello", setup_scope.toolchain()->label().dir(),
            setup_scope.toolchain()->label().name()));
  Target target_gcc(
      setup_scope.settings(),
      Label(SourceDir("//"), "hello", SourceDir("//build/toolchain/"), "gcc"));
  std::vector<const Target*> all_targets = {&target, &target_gcc};

  // Test resolving "//:hello"
  auto [results_label, ok_label] = commands::ResolveSuggestionToTarget(
      setup_scope.build_settings(), all_targets,
      setup_scope.toolchain()->label(), "//:hello");

  std::vector<std::pair<const Target*, commands::ApiScope>> expected_label = {
      {&target, commands::ApiScope::kPublic}};
  EXPECT_EQ(expected_label, results_label);
  EXPECT_TRUE(ok_label);

  // Test resolving "//:hello(//build/toolchain:gcc)"
  auto [results_toolchain, ok_toolchain] = commands::ResolveSuggestionToTarget(
      setup_scope.build_settings(), all_targets, default_toolchain,
      "//:hello(//build/toolchain:gcc)");

  std::vector<std::pair<const Target*, commands::ApiScope>> expected_toolchain =
      {{&target_gcc, commands::ApiScope::kPublic}};
  EXPECT_EQ(expected_toolchain, results_toolchain);
  EXPECT_TRUE(ok_toolchain);
}

TEST_F(SuggestTest, ResolveFileName) {
  TestWithScope setup_scope;
  SourceDir current_dir("//");
  Label default_toolchain = setup_scope.toolchain()->label();
  Label current_toolchain(SourceDir("//build/toolchain/"), "gcc");
  Label secondary_toolchain(SourceDir("//build/toolchain/"), "clang");
  Err err;

  // Follow standard practice to create temporary directories in tests.
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath root_dir = temp_dir.GetPath();
  setup_scope.build_settings()->SetRootPath(root_dir);

  base::WriteFile(root_dir.AppendASCII("public.h"), "", 0);
  base::WriteFile(root_dir.AppendASCII("private.h"), "", 0);
  base::WriteFile(root_dir.AppendASCII("implicit_public.h"), "", 0);
  base::WriteFile(root_dir.AppendASCII("no_target.h"), "", 0);
  base::WriteFile(root_dir.AppendASCII("simple.h"), "", 0);
  base::WriteFile(root_dir.AppendASCII("default_toolchain.h"), "", 0);
  base::WriteFile(root_dir.AppendASCII("secondary_toolchain.h"), "", 0);
  base::FilePath inc_dir = root_dir.AppendASCII("include_dir");
  ASSERT_TRUE(base::CreateDirectory(inc_dir));
  base::WriteFile(inc_dir.AppendASCII("my_header.h"), "", 0);

  Target explicit_target(
      setup_scope.settings(),
      Label(SourceDir("//"), "explicit", current_toolchain.dir(),
            current_toolchain.name()));
  explicit_target.set_all_headers_public(false);
  explicit_target.sources().push_back(SourceFile("//private.h"));
  explicit_target.public_headers().push_back(SourceFile("//public.h"));
  explicit_target.public_headers().push_back(
      SourceFile("//nonexistent_file.h"));

  Target implicit_target(
      setup_scope.settings(),
      Label(SourceDir("//"), "implicit", default_toolchain.dir(),
            default_toolchain.name()));
  implicit_target.set_all_headers_public(true);
  implicit_target.sources().push_back(SourceFile("//implicit_public.h"));
  implicit_target.sources().push_back(SourceFile("//private.cc"));

  Target simple_default(
      setup_scope.settings(),
      Label(SourceDir("//"), "simple", default_toolchain.dir(),
            default_toolchain.name()));
  simple_default.public_headers().push_back(SourceFile("//public.h"));
  simple_default.public_headers().push_back(
      SourceFile("//default_toolchain.h"));

  Target simple_secondary(
      setup_scope.settings(),
      Label(SourceDir("//"), "simple", secondary_toolchain.dir(),
            secondary_toolchain.name()));
  simple_secondary.public_headers().push_back(SourceFile("//public.h"));
  simple_secondary.public_headers().push_back(
      SourceFile("//default_toolchain.h"));
  simple_secondary.public_headers().push_back(
      SourceFile("//secondary_toolchain.h"));

  Target generated(setup_scope.settings(),
                   Label(SourceDir("//"), "generated", current_toolchain.dir(),
                         current_toolchain.name()));
  generated.set_output_type(Target::ACTION);
  generated.SetToolchain(setup_scope.toolchain());
  generated.action_values().outputs() =
      SubstitutionList::MakeForTest("//out/Debug/generated_file.h");
  Err resolve_err;
  ASSERT_TRUE(generated.OnResolvedWithoutChecks(&resolve_err));

  Target included_target(
      setup_scope.settings(),
      Label(SourceDir("//"), "included_target", current_toolchain.dir(),
            current_toolchain.name()));
  included_target.set_output_type(Target::SOURCE_SET);
  included_target.SetToolchain(setup_scope.toolchain());
  included_target.set_all_headers_public(true);
  included_target.sources().push_back(SourceFile("//include_dir/my_header.h"));
  ASSERT_TRUE(included_target.OnResolvedWithoutChecks(&resolve_err));

  Target consumer(setup_scope.settings(),
                  Label(SourceDir("//"), "consumer", current_toolchain.dir(),
                        current_toolchain.name()));
  consumer.set_output_type(Target::SOURCE_SET);
  consumer.SetToolchain(setup_scope.toolchain());
  consumer.set_all_headers_public(true);
  consumer.public_headers().push_back(
      SourceFile("//out/Debug/generated_file.h"));
  consumer.config_values().include_dirs().push_back(
      SourceDir("//include_dir/"));
  ASSERT_TRUE(consumer.OnResolvedWithoutChecks(&resolve_err));

  std::vector<const Target*> all_targets = {&explicit_target, &implicit_target,
                                            &simple_default,  &simple_secondary,
                                            &generated,       &included_target};

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "//public.h");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected = {
        {&explicit_target, commands::ApiScope::kPublic}};
    EXPECT_TRUE(ok);
    EXPECT_EQ(expected, results);
  }

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "../../private.h");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected = {
        {&explicit_target, commands::ApiScope::kPrivate}};
    EXPECT_TRUE(ok);
    EXPECT_EQ(expected, results);
  }

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "//implicit_public.h");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected = {
        {&implicit_target, commands::ApiScope::kPublic}};
    EXPECT_TRUE(ok);
    EXPECT_EQ(expected, results);
  }

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "nonexistent_file.h");
    EXPECT_FALSE(ok);
  }

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "//out/Debug/generated_file.h");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected = {
        {&generated, commands::ApiScope::kPublic}};
    EXPECT_TRUE(ok);
    EXPECT_EQ(expected, results);
  }

  all_targets.push_back(&consumer);
  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "//out/Debug/generated_file.h");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected = {
        {&consumer, commands::ApiScope::kPublic}};
    EXPECT_TRUE(ok);
    EXPECT_EQ(expected, results);
  }

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "//no_target.h");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected_targets;
    EXPECT_TRUE(ok);
    EXPECT_EQ(expected_targets, results);
  }

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "//default_toolchain.h");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected_targets =
        {
            {&simple_secondary, commands::ApiScope::kPublic},
            {&simple_default, commands::ApiScope::kPublic},
    };
    EXPECT_TRUE(ok);
    EXPECT_EQ(expected_targets, results);
  }

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "//secondary_toolchain.h");
    std::vector<std::pair<const Target*, commands::ApiScope>> expected_targets =
        {{{&simple_secondary, commands::ApiScope::kPublic}}};
    EXPECT_TRUE(ok);
    EXPECT_EQ(expected_targets, results);
  }

  {
    auto [results, ok] = commands::ResolveSuggestionToTarget(
        setup_scope.build_settings(), all_targets, current_toolchain,
        "my_header.h", &consumer);
    EXPECT_TRUE(ok);
    std::vector<std::pair<const Target*, commands::ApiScope>> expected_targets =
        {{{&included_target, commands::ApiScope::kPublic}}};
    EXPECT_EQ(expected_targets, results);
  }
}

TEST_F(SuggestTest, OutputSuggestions) {
  TestWithScope setup_scope;
  Label default_toolchain = setup_scope.toolchain()->label();

  InputFile build_file(SourceFile("//BUILD.gn"));
  Location dummy_loc(&build_file, 1, 1);
  std::vector<const Target*> all_targets;

  auto set_visibility = [&](Target* target, std::string_view pattern) {
    Value visibility_value(nullptr, Value::LIST);
    visibility_value.list_value().push_back(
        Value(nullptr, std::string(pattern)));
    Err err;
    EXPECT_TRUE(
        target->visibility().Set(SourceDir("//"), "", visibility_value, &err));
  };

  auto create_target = [&](std::string_view name, Target::OutputType type,
                           auto fn) {
    auto target = std::make_unique<Target>(
        setup_scope.settings(),
        Label(SourceDir("//"), name, default_toolchain.dir(),
              default_toolchain.name()));
    target->set_output_type(type);
    target->SetToolchain(setup_scope.toolchain());
    target->set_user_friendly_location(dummy_loc);
    if (type == Target::SOURCE_SET) {
      Target::ModuleType module_type;
      module_type.set(Target::HAS_MODULEMAP);
      target->set_module_type(module_type);
      target->set_module_name(std::string(name));
      target->public_headers().push_back(
          SourceFile("//" + std::string(name) + ".h"));
    }
    fn(target.get());
    Err err;
    EXPECT_TRUE(target->OnResolvedWithoutChecks(&err));
    all_targets.push_back(target.get());
    return target;
  };

  auto includer = create_target("includer", Target::GROUP, [](Target*) {});

  auto run_suggest = [&](std::string_view want) {
    std::string output;
    auto collect = [&](std::string_view s, TextDecoration, HtmlEscaping) {
      output.append(s);
    };
    commands::OutputSuggestions(all_targets, setup_scope.build_settings(),
                                default_toolchain, "//:includer", want,
                                collect);
    return output;
  };

  auto visible = create_target("visible", Target::SOURCE_SET,
                               [&](Target* t) { t->visibility().SetPublic(); });
  auto visible_group =
      create_target("visible_group", Target::GROUP, [&](Target* t) {
        t->public_deps().push_back(LabelTargetPair(visible.get()));
        t->visibility().SetPublic();
      });
  // Prefer the real target over the group that exposes it.
  EXPECT_EQ(
      "Suggestion: Add public_deps = [ \":visible\" ] to :includer (defined "
      "at //BUILD.gn:1)\n"
      "  (`gn edit \"add public_deps :visible\" //:includer`)\n",
      run_suggest(visible->module_name()));

  auto invisible =
      create_target("invisible", Target::SOURCE_SET, [&](Target* t) {});
  EXPECT_EQ(
      "Warning: //:invisible is not visible to //:includer\n"
      "Suggestion: Carefully consider whether you want to change the "
      "visibility so that you can depend on it\n"
      "Suggestion: Add public_deps = [ \":invisible\" ] to :includer (defined "
      "at //BUILD.gn:1)\n"
      "  (`gn edit \"add public_deps :invisible\" //:includer`)\n",
      run_suggest(invisible->module_name()));

  auto exposer_invisible =
      create_target("exposer_invisible", Target::GROUP, [&](Target* t) {
        t->private_deps().push_back(LabelTargetPair(invisible.get()));
      });
  EXPECT_EQ(
      "Warning: //:invisible is exposed via the following targets, but none "
      "are visible to //:includer\n"
      "Suggestion: Carefully consider whether you want to change the "
      "visibility so that you can depend on one of them\n"
      "Suggestion: Add one of the following to public_deps in :includer "
      "(defined at //BUILD.gn:1):\n"
      "* :exposer_invisible (`gn edit \"add public_deps :exposer_invisible\" "
      "//:includer`)\n"
      "* :invisible (`gn edit \"add public_deps :invisible\" //:includer`)\n",
      run_suggest(invisible->module_name()));

  auto exposer_visible =
      create_target("exposer_visible", Target::GROUP, [&](Target* t) {
        t->private_deps().push_back(LabelTargetPair(invisible.get()));
        t->visibility().SetPublic();
      });
  EXPECT_EQ(
      "Suggestion: Add public_deps = [ \":exposer_visible\" ] to :includer "
      "(defined at //BUILD.gn:1)\n"
      "  (`gn edit \"add public_deps :exposer_visible\" //:includer`)\n",
      run_suggest(invisible->module_name()));

  auto exposer_visible2 =
      create_target("exposer_visible2", Target::GROUP, [&](Target* t) {
        t->private_deps().push_back(LabelTargetPair(exposer_visible.get()));
        t->visibility().SetPublic();
      });
  EXPECT_EQ(
      "Warning: //:invisible is exposed via multiple targets\n"
      "Suggestion: Clean up the visibility so that only one of the below "
      "targets is visible to //:includer\n"
      "Suggestion: Add one of the following to public_deps in :includer "
      "(defined at //BUILD.gn:1):\n"
      "* :exposer_visible (`gn edit \"add public_deps :exposer_visible\" "
      "//:includer`)\n"
      "* :exposer_visible2 (`gn edit \"add public_deps :exposer_visible2\" "
      "//:includer`)\n",
      run_suggest(invisible->module_name()));

  auto exposer_specific =
      create_target("exposer_specific", Target::GROUP, [&](Target* t) {
        t->private_deps().push_back(LabelTargetPair(exposer_visible.get()));
        set_visibility(t, "//:includer");
      });
  EXPECT_EQ(
      "Suggestion: Add public_deps = [ \":exposer_specific\" ] to :includer "
      "(defined at //BUILD.gn:1)\n"
      "  (`gn edit \"add public_deps :exposer_specific\" //:includer`)\n",
      run_suggest(invisible->module_name()));

  auto cyclic = create_target("cyclic", Target::SOURCE_SET, [&](Target* t) {
    t->public_deps().push_back(LabelTargetPair(includer.get()));
    t->visibility().SetPublic();
  });
  EXPECT_EQ(
      "Warning: //:cyclic depends on //:includer, so adding this dependency "
      "will create a dependency loop:\n"
      "  //:includer ->\n"
      "  //:cyclic ->\n"
      "  //:includer\n"
      "Suggestion: Find the part of the dependency chain where there is no "
      "#include and remove that dependency.\n"
      "Suggestion: Add public_deps = [ \":cyclic\" ] to :includer (defined at "
      "//BUILD.gn:1)\n"
      "  (`gn edit \"add public_deps :cyclic\" //:includer`)\n",
      run_suggest(cyclic->module_name()));

  auto cyclic_circular_includes = create_target(
      "cyclic_circular_includes", Target::STATIC_LIBRARY, [&](Target* t) {
        t->public_deps().push_back(LabelTargetPair(includer.get()));
        t->visibility().SetPublic();
        t->allow_circular_includes_from().insert(includer->label());
      });
  EXPECT_EQ(
      "Warning: //:cyclic_circular_includes depends on //:includer, so adding "
      "this "
      "dependency will create a dependency loop:\n"
      "  //:includer ->\n"
      "  //:cyclic_circular_includes ->\n"
      "  //:includer\n"
      "Suggestion: :cyclic_circular_includes (defined at //BUILD.gn:1) "
      "declares "
      "allow_circular_includes_from, which is bad style. Instead, you should "
      "remove allow_circular_includes_from by doing the following:\n"
      "source_set(\"cyclic_circular_includes_sources\") {\n"
      "  # All attributes from :cyclic_circular_includes except public_deps, "
      "and any link options\n"
      "  # Note that some public_deps may need to be added back based on "
      "#includes of headers.\n"
      "}\n"
      "\n"
      "static_library(\"cyclic_circular_includes\") {\n"
      "  public_deps = [ \":cyclic_circular_includes_sources\" ]\n"
      "  # public_deps, and any link variables from :cyclic_circular_includes\n"
      "}\n"
      "Suggestion: Add public_deps = [ \":cyclic_circular_includes_sources\" ] "
      "to :includer (defined at //BUILD.gn:1)\n"
      "  (`gn edit \"add public_deps :cyclic_circular_includes_sources\" "
      "//:includer`)\n",
      run_suggest(cyclic_circular_includes->module_name()));

  auto private_target =
      create_target("private_target", Target::SOURCE_SET, [&](Target* t) {
        t->set_all_headers_public(false);
        t->sources().push_back(SourceFile("//private_target.h"));
        t->visibility().SetPublic();
      });
  EXPECT_EQ(
      "Warning: \"private_target_Private\" is in the private API of "
      "//:private_target\n"
      "Suggestion: Move \"private_target.h\" from `sources` to `public` "
      "in :private_target (defined at //BUILD.gn:1)\n"
      "  (`gn edit \"move sources public private_target.h\" "
      "//:private_target`)\n"
      "Suggestion: Add public_deps = [ \":private_target\" ] to :includer "
      "(defined at //BUILD.gn:1)\n"
      "  (`gn edit \"add public_deps :private_target\" //:includer`)\n",
      run_suggest("private_target_Private"));
}

TEST_F(SuggestTest, ApplyValidSuggestion) {
  TestProject project({
      {SourceFile("//BUILD.gn"), R"(executable("includer") {
  sources = [ "includer.cc" ]
}

source_set("included") {
  sources = [ "included.h" ]
}
)"},
      {SourceFile("//includer.cc"), ""},
      {SourceFile("//included.h"), ""},
  });

  std::string output;
  auto collect = [&](std::string_view s, TextDecoration, HtmlEscaping) {
    output.append(s);
  };

  commands::SuggestResult result = commands::OutputSuggestions(
      project.targets(), &project.setup.build_settings(),
      project.default_toolchain(), "//includer.cc", "//included.h", collect,
      true, &project.setup);

  EXPECT_EQ(commands::SuggestResult::kSuccess, result);
  EXPECT_EQ(
      "[APPLIED] Suggestion: Add deps = [ \":included\" ] to :includer "
      "(defined at //BUILD.gn:1)\n",
      output);

  std::string expected_build_gn = R"(executable("includer") {
  sources = [ "includer.cc" ]
  deps = [ ":included" ]
}

source_set("included") {
  sources = [ "included.h" ]
}
)";
  EXPECT_EQ(expected_build_gn, project.Read(SourceFile("//BUILD.gn")));
}

TEST_F(SuggestTest, CheckAppliesSuggestions) {
  TestProject project({
      {SourceFile("//BUILD.gn"), R"(
group("all") {
  deps = [
    "//included",
    "//includer",
  ]
}
)"},
      {SourceFile("//includer/BUILD.gn"), R"(executable("includer") {
  sources = [ "includer.cc" ]
}
)"},
      {SourceFile("//included/BUILD.gn"), R"(source_set("included") {
  sources = [ "included.h" ]
}
)"},
      {SourceFile("//includer/includer.cc"),
       "#include \"included/included.h\""},
      {SourceFile("//included/included.h"), ""},
  });

  std::string output;
  auto collect = [&](std::string_view s, TextDecoration, HtmlEscaping) {
    output.append(s);
  };

  EXPECT_TRUE(commands::CheckPublicHeaders(
      &project.setup.build_settings(), project.targets(), project.targets(),
      false, false, false, true, &project.setup, collect));
  EXPECT_EQ(
      "ERROR at //includer/includer.cc:1:11: Include not allowed.\n"
      "#include \"included/included.h\"\n"
      "          ^\n"
      "[APPLIED] Suggestion: Add deps = [ \"//included:included\" ] to "
      ":includer (defined at //includer/BUILD.gn:1)\n",
      output);
  std::string expected_build_gn = R"(executable("includer") {
  sources = [ "includer.cc" ]
  deps = [ "//included" ]
}
)";
  EXPECT_EQ(expected_build_gn, project.Read(SourceFile("//includer/BUILD.gn")));
}