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

tools/gn/builder_unittest.cc

 // Copyright (c) 2013 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 "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/config.h"
 #include "tools/gn/loader.h"
 #include "tools/gn/target.h"
 #include "tools/gn/test_with_scope.h"
@@ skipping 51 matching lines @@
 
   std::vector<SourceFile> files_;
 };
 
 class BuilderTest : public testing::Test {
  public:
   BuilderTest()
       : loader_(new MockLoader),
         builder_(loader_.get()),
         settings_(&build_settings_, std::string()),
-        scope_(&settings_) {
+        scope_(&settings_, {}) {
     build_settings_.SetBuildDir(SourceDir("//out/"));
     settings_.set_toolchain_label(Label(SourceDir("//tc/"), "default"));
     settings_.set_default_toolchain_label(settings_.toolchain_label());
   }
 
   Toolchain* DefineToolchain() {
-    Toolchain* tc = new Toolchain(&settings_, settings_.toolchain_label());
+    Toolchain* tc = new Toolchain(&settings_, settings_.toolchain_label(), {});
     TestWithScope::SetupToolchain(tc);
     builder_.ItemDefined(std::unique_ptr<Item>(tc));
     return tc;
   }
 
  protected:
   scoped_refptr<MockLoader> loader_;
   Builder builder_;
   BuildSettings build_settings_;
   Settings settings_;
   Scope scope_;
 };
 
 }  // namespace
 
 TEST_F(BuilderTest, BasicDeps) {
   SourceDir toolchain_dir = settings_.toolchain_label().dir();
   std::string toolchain_name = settings_.toolchain_label().name();
 
   // Construct a dependency chain: A -> B -> C. Define A first with a
   // forward-reference to B, then C, then B to test the different orders that
   // the dependencies are hooked up.
   Label a_label(SourceDir("//a/"), "a", toolchain_dir, toolchain_name);
   Label b_label(SourceDir("//b/"), "b", toolchain_dir, toolchain_name);
   Label c_label(SourceDir("//c/"), "c", toolchain_dir, toolchain_name);
 
   // The builder will take ownership of the pointers.
-  Target* a = new Target(&settings_, a_label);
+  Target* a = new Target(&settings_, a_label, {});
   a->public_deps().push_back(LabelTargetPair(b_label));
   a->set_output_type(Target::EXECUTABLE);
   builder_.ItemDefined(std::unique_ptr<Item>(a));
 
   // Should have requested that B and the toolchain is loaded.
   EXPECT_TRUE(loader_->HasLoadedTwo(SourceFile("//tc/BUILD.gn"),
                                     SourceFile("//b/BUILD.gn")));
 
   // Define the toolchain.
   DefineToolchain();
@@ skipping 24 matching lines @@
             a_record->all_deps().find(b_record));
   EXPECT_NE(a_record->unresolved_deps().end(),
             a_record->unresolved_deps().find(b_record));
 
   // B should be marked as having A waiting on it.
   EXPECT_EQ(1u, b_record->waiting_on_resolution().size());
   EXPECT_NE(b_record->waiting_on_resolution().end(),
             b_record->waiting_on_resolution().find(a_record));
 
   // Add the C target.
-  Target* c = new Target(&settings_, c_label);
+  Target* c = new Target(&settings_, c_label, {});
   c->set_output_type(Target::STATIC_LIBRARY);
   c->visibility().SetPublic();
   builder_.ItemDefined(std::unique_ptr<Item>(c));
 
   // C only depends on the already-loaded toolchain so we shouldn't have
   // requested anything else.
   EXPECT_TRUE(loader_->HasLoadedNone());
 
   // Add the B target.
-  Target* b = new Target(&settings_, b_label);
+  Target* b = new Target(&settings_, b_label, {});
   a->public_deps().push_back(LabelTargetPair(c_label));
   b->set_output_type(Target::SHARED_LIBRARY);
   b->visibility().SetPublic();
   builder_.ItemDefined(std::unique_ptr<Item>(b));
 
   // B depends only on the already-loaded C and toolchain so we shouldn't have
   // requested anything else.
   EXPECT_TRUE(loader_->HasLoadedNone());
 
   // All targets should now be resolved.
@@ skipping 12 matching lines @@
 }
 
 // Tests that the "should generate" flag is set and propagated properly.
 TEST_F(BuilderTest, ShouldGenerate) {
   DefineToolchain();
 
   // Define a secondary toolchain.
   Settings settings2(&build_settings_, "secondary/");
   Label toolchain_label2(SourceDir("//tc/"), "secondary");
   settings2.set_toolchain_label(toolchain_label2);
-  Toolchain* tc2 = new Toolchain(&settings2, toolchain_label2);
+  Toolchain* tc2 = new Toolchain(&settings2, toolchain_label2, {});
   TestWithScope::SetupToolchain(tc2);
   builder_.ItemDefined(std::unique_ptr<Item>(tc2));
 
   // Construct a dependency chain: A -> B. A is in the default toolchain, B
   // is not.
   Label a_label(SourceDir("//foo/"), "a",
                 settings_.toolchain_label().dir(), "a");
   Label b_label(SourceDir("//foo/"), "b",
                 toolchain_label2.dir(), toolchain_label2.name());
 
   // First define B.
-  Target* b = new Target(&settings2, b_label);
+  Target* b = new Target(&settings2, b_label, {});
   b->visibility().SetPublic();
   b->set_output_type(Target::EXECUTABLE);
   builder_.ItemDefined(std::unique_ptr<Item>(b));
 
   // B should not be marked generated by default.
   BuilderRecord* b_record = builder_.GetRecord(b_label);
   EXPECT_FALSE(b_record->should_generate());
 
   // Define A with a dependency on B.
-  Target* a = new Target(&settings_, a_label);
+  Target* a = new Target(&settings_, a_label, {});
   a->public_deps().push_back(LabelTargetPair(b_label));
   a->set_output_type(Target::EXECUTABLE);
   builder_.ItemDefined(std::unique_ptr<Item>(a));
 
   // A should have the generate bit set since it's in the default toolchain.
   BuilderRecord* a_record = builder_.GetRecord(a_label);
   EXPECT_TRUE(a_record->should_generate());
 
   // It should have gotten pushed to B.
   EXPECT_TRUE(b_record->should_generate());
 }
 
 // Tests that configs applied to a config get loaded (bug 536844).
 TEST_F(BuilderTest, ConfigLoad) {
   SourceDir toolchain_dir = settings_.toolchain_label().dir();
   std::string toolchain_name = settings_.toolchain_label().name();
 
   // Construct a dependency chain: A -> B -> C. Define A first with a
   // forward-reference to B, then C, then B to test the different orders that
   // the dependencies are hooked up.
   Label a_label(SourceDir("//a/"), "a", toolchain_dir, toolchain_name);
   Label b_label(SourceDir("//b/"), "b", toolchain_dir, toolchain_name);
   Label c_label(SourceDir("//c/"), "c", toolchain_dir, toolchain_name);
 
   // The builder will take ownership of the pointers.
-  Config* a = new Config(&settings_, a_label);
+  Config* a = new Config(&settings_, a_label, {});
   a->configs().push_back(LabelConfigPair(b_label));
   builder_.ItemDefined(std::unique_ptr<Item>(a));
 
   // Should have requested that B is loaded.
   EXPECT_TRUE(loader_->HasLoadedOne(SourceFile("//b/BUILD.gn")));
 }