Implement tracking of BUILD.gn files used to define target, toolchain or

tools/gn/header_checker_unittest.cc

 // Copyright 2014 The Chromium 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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/config.h"
 #include "tools/gn/header_checker.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/target.h"
 #include "tools/gn/test_with_scope.h"
 
 namespace {
 
 class HeaderCheckerTest : public testing::Test {
  public:
   HeaderCheckerTest()
-      : a_(setup_.settings(), Label(SourceDir("//a/"), "a")),
-        b_(setup_.settings(), Label(SourceDir("//b/"), "b")),
-        c_(setup_.settings(), Label(SourceDir("//c/"), "c")),
-        d_(setup_.settings(), Label(SourceDir("//d/"), "d")) {
+      : a_(setup_.settings(), Label(SourceDir("//a/"), "a"), {}),
+        b_(setup_.settings(), Label(SourceDir("//b/"), "b"), {}),
+        c_(setup_.settings(), Label(SourceDir("//c/"), "c"), {}),
+        d_(setup_.settings(), Label(SourceDir("//d/"), "d"), {}) {
     a_.set_output_type(Target::SOURCE_SET);
     b_.set_output_type(Target::SOURCE_SET);
     c_.set_output_type(Target::SOURCE_SET);
     d_.set_output_type(Target::SOURCE_SET);
 
     Err err;
     a_.SetToolchain(setup_.toolchain(), &err);
     b_.SetToolchain(setup_.toolchain(), &err);
     c_.SetToolchain(setup_.toolchain(), &err);
     d_.SetToolchain(setup_.toolchain(), &err);
@@ skipping 35 matching lines @@
 
 }  // namespace
 
 TEST_F(HeaderCheckerTest, IsDependencyOf) {
   scoped_refptr<HeaderChecker> checker(
       new HeaderChecker(setup_.build_settings(), targets_));
 
   // Add a target P ("private") that privately depends on C, and hook up the
   // chain so that A -> P -> C. A will depend on C via two different paths.
   Err err;
-  Target p(setup_.settings(), Label(SourceDir("//p/"), "p"));
+  Target p(setup_.settings(), Label(SourceDir("//p/"), "p"), {});
   p.set_output_type(Target::SOURCE_SET);
   p.SetToolchain(setup_.toolchain(), &err);
   EXPECT_FALSE(err.has_error());
   p.private_deps().push_back(LabelTargetPair(&c_));
   p.visibility().SetPublic();
   p.OnResolved(&err);
 
   a_.public_deps().push_back(LabelTargetPair(&p));
 
   // A does not depend on itself.
@@ skipping 69 matching lines @@
   // Add a public and private header on C.
   SourceFile c_public("//c_public.h");
   SourceFile c_private("//c_private.h");
   c_.sources().push_back(c_private);
   c_.public_headers().push_back(c_public);
   c_.set_all_headers_public(false);
 
   // Create another toolchain.
   Settings other_settings(setup_.build_settings(), "other/");
   Toolchain other_toolchain(&other_settings,
-                            Label(SourceDir("//toolchain/"), "other"));
+                            Label(SourceDir("//toolchain/"), "other"), {});
   TestWithScope::SetupToolchain(&other_toolchain);
   other_settings.set_toolchain_label(other_toolchain.label());
   other_settings.set_default_toolchain_label(setup_.toolchain()->label());
 
   // Add a target in the other toolchain with a header in it that is not
   // connected to any targets in the main toolchain.
-  Target otc(&other_settings, Label(SourceDir("//p/"), "otc",
-             other_toolchain.label().dir(), other_toolchain.label().name()));
+  Target otc(&other_settings,
+             Label(SourceDir("//p/"), "otc", other_toolchain.label().dir(),
+                   other_toolchain.label().name()),
+             {});
   otc.set_output_type(Target::SOURCE_SET);
   Err err;
   EXPECT_TRUE(otc.SetToolchain(&other_toolchain, &err));
   otc.visibility().SetPublic();
   targets_.push_back(&otc);
 
   SourceFile otc_header("//otc_header.h");
   otc.sources().push_back(otc_header);
   EXPECT_TRUE(otc.OnResolved(&err));
 
@@ skipping 28 matching lines @@
   err = Err();
   EXPECT_TRUE(checker->CheckInclude(&a_, input_file, otc_header, range, &err));
   EXPECT_FALSE(err.has_error());
 }
 
 // A public chain of dependencies should always be identified first, even if
 // it is longer than a private one.
 TEST_F(HeaderCheckerTest, PublicFirst) {
   // Now make a A -> Z -> D private dependency chain (one shorter than the
   // public one to get to D).
-  Target z(setup_.settings(), Label(SourceDir("//a/"), "a"));
+  Target z(setup_.settings(), Label(SourceDir("//a/"), "a"), {});
   z.set_output_type(Target::SOURCE_SET);
   Err err;
   EXPECT_TRUE(z.SetToolchain(setup_.toolchain(), &err));
   z.private_deps().push_back(LabelTargetPair(&d_));
   EXPECT_TRUE(z.OnResolved(&err));
   targets_.push_back(&z);
 
   a_.private_deps().push_back(LabelTargetPair(&z));
 
   // Check that D can be found from A, but since it's private, it will be
@@ skipping 45 matching lines @@
   EXPECT_TRUE(err.has_error());
 
   // Add an allow_circular_includes_from on A that lists B.
   a_.allow_circular_includes_from().insert(b_.label());
 
   // Now the include from B to A should be allowed.
   err = Err();
   EXPECT_TRUE(checker->CheckInclude(&b_, input_file, a_public, range, &err));
   EXPECT_FALSE(err.has_error());
 }