src/test/java/com/google/devtools/build/lib/skyframe/BuiltinsInjectionTest.java - bazel - Git at Google

 // Copyright 2020 The Bazel Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package com.google.devtools.build.lib.skyframe;

 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;

 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
 import com.google.devtools.build.lib.analysis.AnalysisEnvironment;
 import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider;
 import com.google.devtools.build.lib.analysis.ConfiguredTarget;
 import com.google.devtools.build.lib.analysis.RuleContext;
 import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
 import com.google.devtools.build.lib.analysis.util.MockRule;
 import com.google.devtools.build.lib.analysis.util.MockRuleDefaults;
 import com.google.devtools.build.lib.events.Event;
 import com.google.devtools.build.lib.events.EventHandler;
 import com.google.devtools.build.lib.packages.semantics.BuildLanguageOptions;
 import com.google.devtools.build.lib.testutil.TestRuleClassProvider;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import net.starlark.java.eval.EvalException;
 import net.starlark.java.eval.FlagGuardedValue;
 import net.starlark.java.eval.Mutability;
 import net.starlark.java.eval.Starlark;
 import net.starlark.java.eval.StarlarkList;
 import net.starlark.java.eval.StarlarkThread;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;

 /**
  * Tests for Starlark builtin injection.
  *
  * <p>Essentially these are integration tests between {@link StarlarkBuiltinsFunction}, {@link
  * BzlLoadFunction}, and the rest of package loading.
  */
 @RunWith(JUnit4.class)
 public class BuiltinsInjectionTest extends BuildViewTestCase {

   /** A simple dummy rule that doesn't do anything. */
   private static final MockRule OVERRIDABLE_RULE = () -> MockRule.define("overridable_rule");

   /**
    * A dummy native rule that reads from exported_to_java the symbol "builtins_defined_symbol", and
    * prints its value to the event handler.
    */
   private static final MockRule SANDWICH_RULE =
       () -> MockRule.factory(SandwichFactory.class).define("sandwich_rule");

   // Must be public due to reflective construction of rule factories.
   /** Factory for SANDWICH_RULE. (Javadoc'd to pacify linter.) */
   public static class SandwichFactory extends MockRuleDefaults.DefaultConfiguredTargetFactory {
     @Override
     public ConfiguredTarget create(RuleContext ruleContext)
         throws InterruptedException, RuleErrorException, ActionConflictException {
       AnalysisEnvironment env = ruleContext.getAnalysisEnvironment();

       Object value = env.getStarlarkDefinedBuiltins().get("builtins_defined_symbol");

       env.getEventHandler().handle(Event.info("builtins_defined_symbol :: " + value.toString()));
       return super.create(ruleContext);
     }
   }

   /**
    * A dummy rule that dispatches to {@code @_builtins}-defined code. It looks up the function
    * listed as "builtins_defined_logic" in exported_to_java, and calls it twice on an initially
    * empty list. It prints both return values and the final value of the list.
    */
   private static final MockRule SANDWICH_LOGIC_RULE =
       () -> MockRule.factory(SandwichLogicFactory.class).define("sandwich_logic_rule");

   // Must be public due to reflective construction of rule factories.
   /** Factory for SANDWICH_LOGIC_RULE. (Javadoc'd to pacify linter.) */
   public static class SandwichLogicFactory extends MockRuleDefaults.DefaultConfiguredTargetFactory {
     @Override
     public ConfiguredTarget create(RuleContext ruleContext)
         throws InterruptedException, RuleErrorException, ActionConflictException {
       AnalysisEnvironment env = ruleContext.getAnalysisEnvironment();
       StarlarkThread thread = ruleContext.getStarlarkThread();
       Mutability mu = thread.mutability();

       Object func = env.getStarlarkDefinedBuiltins().get("builtins_defined_logic");
       Object arg = StarlarkList.newList(mu);
       Object return1;
       Object return2;
       try {
         return1 = Starlark.call(thread, func, ImmutableList.of(arg), ImmutableMap.of());
         return2 = Starlark.call(thread, func, ImmutableList.of(arg), ImmutableMap.of());
       } catch (EvalException e) {
         throw new AssertionError("Failure during Starlark evaluation", e);
       }

       EventHandler handler = env.getEventHandler();
       handler.handle(Event.info("builtins_defined_logic call 1 :: " + return1.toString()));
       handler.handle(Event.info("builtins_defined_logic call 2 :: " + return2.toString()));
       handler.handle(Event.info("final list value :: " + arg.toString()));
       return super.create(ruleContext);
     }
   }

   @Override
   protected Iterable<String> getDefaultsForConfiguration() {
     // Override BuildViewTestCase's behavior of setting all sorts of extra options that don't exist
     // on our minimal rule class provider.
     // We do need the host platform. Set it to something trivial.
     return ImmutableList.of("--host_platform=//minimal_buildenv/platforms:default_host");
   }

   @Override
   protected void initializeMockClient() throws IOException {
     // Don't let the AnalysisMock sneak in any WORKSPACE file content, which may depend on
     // repository rules that our minimal rule class provider doesn't have.
     analysisMock.setupMockClient(mockToolsConfig, ImmutableList.of());
     // Provide a trivial platform definition.
     mockToolsConfig.create(
         "minimal_buildenv/platforms/BUILD", //
         "platform(name = 'default_host')");
   }

   @Override
   protected ConfiguredRuleClassProvider createRuleClassProvider() {
     // Set up a bare-bones ConfiguredRuleClassProvider. Aside from being minimalistic, this heads
     // off the possibility that we somehow grow an implicit dependency on production builtins code,
     // which would break since we're overwriting --experimental_builtins_bzl_path.
     ConfiguredRuleClassProvider.Builder builder = new ConfiguredRuleClassProvider.Builder();
     TestRuleClassProvider.addMinimalRules(builder);
     // Add some mock symbols to override.
     builder
         .addRuleDefinition(OVERRIDABLE_RULE)
         .addRuleDefinition(SANDWICH_RULE)
         .addRuleDefinition(SANDWICH_LOGIC_RULE)
         .addStarlarkAccessibleTopLevels("overridable_symbol", "original_value")
         .addStarlarkAccessibleTopLevels(
             "flag_guarded_symbol",
             // For this mock symbol, we reuse the same flag that guards the production
             // _builtins_dummy symbol.
             FlagGuardedValue.onlyWhenExperimentalFlagIsTrue(
                 BuildLanguageOptions.EXPERIMENTAL_BUILTINS_DUMMY, "original value"));
     return builder.build();
   }

   @Before
   public void setUp() throws Exception {
     setBuildLanguageOptions("--experimental_builtins_bzl_path=tools/builtins_staging");
   }

   /**
    * Writes an exports.bzl file with the given content, in the builtins location.
    *
    * <p>See {@link StarlarkBuiltinsFunction#EXPORTS_ENTRYPOINT} for the significance of exports.bzl.
    */
   private void writeExportsBzl(String... lines) throws Exception {
     scratch.file("tools/builtins_staging/exports.bzl", lines);
   }

   /**
    * Writes a pkg/dummy.bzl file that prints a marker phrase when it finishes evaluating, and an
    * accompanying BUILD file that loads it.
    */
   private void writePkgBzl(String... lines) throws Exception {
     scratch.file("pkg/BUILD", "load(':dummy.bzl', 'dummy_symbol')");
     scratch.file("pkg/dummy");
     List<String> modifiedLines = new ArrayList<>(Arrays.asList(lines));
     modifiedLines.add("dummy_symbol = None");
     // The marker phrase might not be needed, but I don't entirely trust BuildViewTestCase.
     modifiedLines.add("print('dummy.bzl evaluation completed')");
     scratch.file("pkg/dummy.bzl", modifiedLines.toArray(lines));
   }

   /** Builds {@code //pkg} and asserts success, including that the marker print() event occurs. */
   private void buildAndAssertSuccess() throws Exception {
     Object result = getConfiguredTarget("//pkg:BUILD");
     assertContainsEvent("dummy.bzl evaluation completed");
     // On error, getConfiguredTarget sometimes returns null without emitting events; see b/26382502.
     // Though in that case it seems unlikely the above assertion would've passed.
     assertThat(result).isNotNull();
   }

   /** Builds {@code //pkg:dummy} and asserts on the absence of the marker print() event. */
   private void buildAndAssertFailure() throws Exception {
     reporter.removeHandler(failFastHandler);
     Object result = getConfiguredTarget("//pkg:BUILD");
     assertDoesNotContainEvent("dummy.bzl evaluation completed");
     assertWithMessage("Loading of //pkg succeeded unexpectedly").that(result).isNull();
   }

   @Test
   public void basicFunctionality() throws Exception {
     writeExportsBzl(
         "exported_toplevels = {'overridable_symbol': 'new_value'}",
         "exported_rules = {'overridable_rule': 'new_rule'}",
         "exported_to_java = {}");
     writePkgBzl(
         "print('overridable_symbol :: ' + str(overridable_symbol))",
         "print('overridable_rule :: ' + str(native.overridable_rule))");

     buildAndAssertSuccess();
     assertContainsEvent("overridable_symbol :: new_value");
     assertContainsEvent("overridable_rule :: new_rule");
   }

   @Test
   public void builtinsCanLoadFromBuiltins() throws Exception {
     // Define a few files that we can load with different kinds of label syntax. In each case,
     // access the `_internal` symbol to demonstrate that we're being loaded as a builtins bzl.
     scratch.file(
         "tools/builtins_staging/absolute.bzl", //
         "_internal",
         "a = 'A'");
     scratch.file(
         "tools/builtins_staging/repo_relative.bzl", //
         "_internal",
         "b = 'B'");
     scratch.file(
         "tools/builtins_staging/subdir/pkg_relative1.bzl", //
         // Do a relative load within a load, to show it's relative to the (pseudo) package, i.e. the
         // root, and not relative to the file. That is, we specify 'subdir/pkg_relative2.bzl', not
         // just 'pkg_relative2.bzl'.
         "load('subdir/pkg_relative2.bzl', 'c2')",
         "_internal",
         "c = c2");
     scratch.file(
         "tools/builtins_staging/subdir/pkg_relative2.bzl", //
         "_internal",
         "c2 = 'C'");

     // Also create a file in the main repo whose package path coincides with a file in the builtins
     // pseudo-repo, to show that we get the right one.
     scratch.file("BUILD");
     scratch.file("repo_relative.bzl");

     writeExportsBzl(
         "load('@_builtins//:absolute.bzl', 'a')",
         "load('//:repo_relative.bzl', 'b')", // default repo is @_builtins, not main repo
         "load('subdir/pkg_relative1.bzl', 'c')", // relative to (pseudo) package, which is repo root
         "exported_toplevels = {'overridable_symbol': a + b + c}",
         "exported_rules = {}",
         "exported_to_java = {}");
     writePkgBzl("print('overridable_symbol :: ' + str(overridable_symbol))");

     buildAndAssertSuccess();
     assertContainsEvent("overridable_symbol :: ABC");
   }

   @Test
   public void otherBzlsCannotLoadFromBuiltins() throws Exception {
     writeExportsBzl(
         "exported_toplevels = {}", //
         "exported_rules = {}",
         "exported_to_java = {}");
     writePkgBzl("load('@_builtins//:exports.bzl', 'exported_toplevels')");

     buildAndAssertFailure();
     assertContainsEvent("The repository '@_builtins' could not be resolved");
   }

   @Test
   public void builtinsCannotLoadFromNonBuiltins() throws Exception {
     scratch.file("BUILD");
     scratch.file(
         "a_user_written.bzl", //
         "toplevels = {'overridable_symbol': 'new_value'}");
     writeExportsBzl(
         // Use @// syntax to specify the main repo. Otherwise, the load would be relative to the
         // @_builtins pseudo-repo.
         "load('@//:a_user_written.bzl', 'toplevels')",
         "exported_toplevels = toplevels",
         "exported_rules = {}",
         "exported_to_java = {}");
     writePkgBzl();

     buildAndAssertFailure();
     assertContainsEvent(
         "in load statement: .bzl files in @_builtins cannot load from outside of @_builtins");
   }

   @Test
   public void builtinsCannotLoadWithMisplacedColon() throws Exception {
     scratch.file(
         "tools/builtins_staging/subdir/helper.bzl", //
         "toplevels = {'overridable_symbol': 'new_value'}");
     writeExportsBzl(
         "load('//subdir:helper.bzl', 'toplevels')", // Should've been loaded as //:subdir/helper.bzl
         "exported_toplevels = toplevels",
         "exported_rules = {}",
         "exported_to_java = {}");
     writePkgBzl();

     buildAndAssertFailure();
     assertContainsEvent("@_builtins cannot have subpackages");
   }

   @Test
   public void errorInEvaluatingBuiltinsDependency() throws Exception {
     // Test case with a Starlark error in the @_builtins pseudo-repo itself.
     scratch.file(
         "tools/builtins_staging/helper.bzl", //
         "toplevels = {'overridable_symbol': 1//0}  # <-- dynamic error");
     writeExportsBzl(
         "load('@_builtins//:helper.bzl', 'toplevels')",
         "exported_toplevels = toplevels",
         "exported_rules = {}",
         "exported_to_java = {}");
     writePkgBzl();

     buildAndAssertFailure();
     assertContainsEvent(
         "File \"/workspace/tools/builtins_staging/helper.bzl\", line 1, column 37, in <toplevel>");
     assertContainsEvent("Error: integer division by zero");

     // We assert only the parts of the message before and after the module name, since the module
     // identified by the message depends on whether or not the test environment has a prelude file.
     Event ev = assertContainsEvent("Internal error while loading Starlark builtins");
     assertThat(ev.getMessage())
         .contains(
             "Failed to load builtins sources: "
                 + "at /workspace/tools/builtins_staging/exports.bzl:1:6: "
                 + "initialization of module 'helper.bzl' (internal) failed");
   }

   @Test
   public void errorInProcessingExports() throws Exception {
     // Test case with an error in the symbols exported by exports.bzl, but no actual Starlark errors
     // in the builtins files themselves.
     writeExportsBzl(
         "exported_toplevels = None", // should be dict
         "exported_rules = {}",
         "exported_to_java = {}");
     writePkgBzl();

     buildAndAssertFailure();

     // We assert only the parts of the message before and after the module name, since the module
     // identified by the message depends on whether or not the test environment has a prelude file.
     Event ev = assertContainsEvent("Internal error while loading Starlark builtins");
     assertThat(ev.getMessage())
         .contains(
             "Failed to apply declared builtins: "
                 + "got NoneType for 'exported_toplevels dict', want dict");
   }

   // TODO(#11437): Remove once disabling is not allowed.
   @Test
   public void injectionDisabledByFlag() throws Exception {
     writeExportsBzl(
         "exported_toplevels = {'overridable_symbol': 'new_value'}",
         "exported_rules = {'overridable_rule': 'new_rule'}",
         "exported_to_java = {}");
     writePkgBzl(
         "print('overridable_symbol :: ' + str(overridable_symbol))",
         "print('overridable_rule :: ' + str(native.overridable_rule))");
     setBuildLanguageOptions("--experimental_builtins_bzl_path=");

     buildAndAssertSuccess();
     assertContainsEvent("overridable_symbol :: original_value");
     assertContainsEvent("overridable_rule :: <built-in rule overridable_rule>");
   }

   // TODO(#11437): Remove once disabling is not allowed.
   @Test
   public void exportsBzlMayBeInErrorWhenInjectionIsDisabled() throws Exception {
     writeExportsBzl( //
         "PARSE ERROR");
     writePkgBzl(
         "print('overridable_symbol :: ' + str(overridable_symbol))",
         "print('overridable_rule :: ' + str(native.overridable_rule))");
     setBuildLanguageOptions("--experimental_builtins_bzl_path=");

     buildAndAssertSuccess();
     assertContainsEvent("overridable_symbol :: original_value");
     assertContainsEvent("overridable_rule :: <built-in rule overridable_rule>");
   }

   // TODO(#11954): Once WORKSPACE- and BUILD-loaded bzls use the exact same environments, we'll want
   // to apply injection to both. This is for uniformity, not because we actually care about builtins
   // injection for WORKSPACE bzls. In the meantime, assert the status quo: WORKSPACE bzls do not use
   // injection.
   @Test
   public void workspaceBzlDoesNotUseInjection() throws Exception {
     writeExportsBzl(
         "exported_toplevels = {'overridable_symbol': 'new_value'}",
         "exported_rules = {'overridable_rule': 'new_rule'}",
         "exported_to_java = {}");
     writePkgBzl();
     scratch.appendFile(
         "WORKSPACE", //
         "load(':foo.bzl', 'dummy_symbol')",
         "print(dummy_symbol)");
     scratch.file("BUILD");
     scratch.file(
         "foo.bzl",
         "dummy_symbol = None",
         "print('overridable_symbol :: ' + str(overridable_symbol))");

     buildAndAssertSuccess();
     // Builtins for WORKSPACE bzls are populated essentially the same as for BUILD bzls, except that
     // injection doesn't apply.
     assertContainsEvent("overridable_symbol :: original_value");
     // We don't assert that the rule isn't injected because the workspace native object doesn't
     // contain our original mock rule. We can test this for WORKSPACE files at the top-level though.
   }

   // TODO(#11437): Add tests of the _internal symbol's usage within builtins bzls.

   // TODO(#11437): Add test cases for BUILD file injection, and WORKSPACE file non-injection, when
   // we add injection support to PackageFunction.

   @Test
   public void overriddenSymbolsAreStillFlagGuarded() throws Exception {
     // Implementation note: This works not because of any special handling in the builtins logic,
     // but rather because flag guarding is implemented at name resolution time, before builtins
     // injection is applied.
     writeExportsBzl(
         "exported_toplevels = {'flag_guarded_symbol': 'overridden value'}",
         "exported_rules = {}",
         "exported_to_java = {}");
     writePkgBzl("flag_guarded_symbol");

     buildAndAssertFailure();
     assertContainsEvent("flag_guarded_symbol is experimental");
   }

   // TODO(#11437): Once we allow access to native symbols via _internal, verify that flag guarding
   // works correctly within builtins.

   @Test
   public void nativeRulesCanUseSymbolsFromBuiltins() throws Exception {
     writeExportsBzl(
         "exported_toplevels = {}",
         "exported_rules = {}",
         "exported_to_java = {'builtins_defined_symbol': 'value_from_builtins'}");
     scratch.file(
         "pkg/BUILD", //
         "sandwich_rule(name = 'sandwich')");

     getConfiguredTarget("//pkg:sandwich");
     assertContainsEvent("builtins_defined_symbol :: value_from_builtins");
   }

   // TODO(#11437): Verify whether this works for native-defined aspects as well.

   @Test
   public void nativeRulesCanCallFunctionsDefinedInBuiltins() throws Exception {
     writeExportsBzl(
         // The driver rule calls this helper twice with a list.
         "def func(arg):",
         "  print('got arg %s' % arg)",
         "  arg.append('blah')",
         "  return len(arg)",
         "exported_toplevels = {}",
         "exported_rules = {}",
         "exported_to_java = {'builtins_defined_logic': func}");
     scratch.file(
         "pkg/BUILD", //
         "sandwich_logic_rule(name = 'sandwich_logic')");

     getConfiguredTarget("//pkg:sandwich_logic");
     assertContainsEvent("got arg []");
     assertContainsEvent("builtins_defined_logic call 1 :: 1");
     assertContainsEvent("got arg [\"blah\"]");
     assertContainsEvent("builtins_defined_logic call 2 :: 2");
     assertContainsEvent("final list value :: [\"blah\", \"blah\"]");
   }

   /**
    * Tests for injection, under inlining of {@link BzlLoadFunction}.
    *
    * <p>See {@link BzlLoadFunction#computeInline} for an explanation of inlining.
    */
   @RunWith(JUnit4.class)
   public static class BuiltinsInjectionTestWithInlining extends BuiltinsInjectionTest {

     @Override
     protected boolean usesInliningBzlLoadFunction() {
       return true;
     }
   }
 }
	// Copyright 2020 The Bazel Authors. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package com.google.devtools.build.lib.skyframe;

	import static com.google.common.truth.Truth.assertThat;
	import static com.google.common.truth.Truth.assertWithMessage;

	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableMap;
	import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
	import com.google.devtools.build.lib.analysis.AnalysisEnvironment;
	import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider;
	import com.google.devtools.build.lib.analysis.ConfiguredTarget;
	import com.google.devtools.build.lib.analysis.RuleContext;
	import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
	import com.google.devtools.build.lib.analysis.util.MockRule;
	import com.google.devtools.build.lib.analysis.util.MockRuleDefaults;
	import com.google.devtools.build.lib.events.Event;
	import com.google.devtools.build.lib.events.EventHandler;
	import com.google.devtools.build.lib.packages.semantics.BuildLanguageOptions;
	import com.google.devtools.build.lib.testutil.TestRuleClassProvider;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;
	import net.starlark.java.eval.EvalException;
	import net.starlark.java.eval.FlagGuardedValue;
	import net.starlark.java.eval.Mutability;
	import net.starlark.java.eval.Starlark;
	import net.starlark.java.eval.StarlarkList;
	import net.starlark.java.eval.StarlarkThread;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.JUnit4;

	/**
	* Tests for Starlark builtin injection.
	*
	* <p>Essentially these are integration tests between {@link StarlarkBuiltinsFunction}, {@link
	* BzlLoadFunction}, and the rest of package loading.
	*/
	@RunWith(JUnit4.class)
	public class BuiltinsInjectionTest extends BuildViewTestCase {

	/** A simple dummy rule that doesn't do anything. */
	private static final MockRule OVERRIDABLE_RULE = () -> MockRule.define("overridable_rule");

	/**
	* A dummy native rule that reads from exported_to_java the symbol "builtins_defined_symbol", and
	* prints its value to the event handler.
	*/
	private static final MockRule SANDWICH_RULE =
	() -> MockRule.factory(SandwichFactory.class).define("sandwich_rule");

	// Must be public due to reflective construction of rule factories.
	/** Factory for SANDWICH_RULE. (Javadoc'd to pacify linter.) */
	public static class SandwichFactory extends MockRuleDefaults.DefaultConfiguredTargetFactory {
	@Override
	public ConfiguredTarget create(RuleContext ruleContext)
	throws InterruptedException, RuleErrorException, ActionConflictException {
	AnalysisEnvironment env = ruleContext.getAnalysisEnvironment();

	Object value = env.getStarlarkDefinedBuiltins().get("builtins_defined_symbol");

	env.getEventHandler().handle(Event.info("builtins_defined_symbol :: " + value.toString()));
	return super.create(ruleContext);
	}
	}

	/**
	* A dummy rule that dispatches to {@code @_builtins}-defined code. It looks up the function
	* listed as "builtins_defined_logic" in exported_to_java, and calls it twice on an initially
	* empty list. It prints both return values and the final value of the list.
	*/
	private static final MockRule SANDWICH_LOGIC_RULE =
	() -> MockRule.factory(SandwichLogicFactory.class).define("sandwich_logic_rule");

	// Must be public due to reflective construction of rule factories.
	/** Factory for SANDWICH_LOGIC_RULE. (Javadoc'd to pacify linter.) */
	public static class SandwichLogicFactory extends MockRuleDefaults.DefaultConfiguredTargetFactory {
	@Override
	public ConfiguredTarget create(RuleContext ruleContext)
	throws InterruptedException, RuleErrorException, ActionConflictException {
	AnalysisEnvironment env = ruleContext.getAnalysisEnvironment();
	StarlarkThread thread = ruleContext.getStarlarkThread();
	Mutability mu = thread.mutability();

	Object func = env.getStarlarkDefinedBuiltins().get("builtins_defined_logic");
	Object arg = StarlarkList.newList(mu);
	Object return1;
	Object return2;
	try {
	return1 = Starlark.call(thread, func, ImmutableList.of(arg), ImmutableMap.of());
	return2 = Starlark.call(thread, func, ImmutableList.of(arg), ImmutableMap.of());
	} catch (EvalException e) {
	throw new AssertionError("Failure during Starlark evaluation", e);
	}

	EventHandler handler = env.getEventHandler();
	handler.handle(Event.info("builtins_defined_logic call 1 :: " + return1.toString()));
	handler.handle(Event.info("builtins_defined_logic call 2 :: " + return2.toString()));
	handler.handle(Event.info("final list value :: " + arg.toString()));
	return super.create(ruleContext);
	}
	}

	@Override
	protected Iterable<String> getDefaultsForConfiguration() {
	// Override BuildViewTestCase's behavior of setting all sorts of extra options that don't exist
	// on our minimal rule class provider.
	// We do need the host platform. Set it to something trivial.
	return ImmutableList.of("--host_platform=//minimal_buildenv/platforms:default_host");
	}

	@Override
	protected void initializeMockClient() throws IOException {
	// Don't let the AnalysisMock sneak in any WORKSPACE file content, which may depend on
	// repository rules that our minimal rule class provider doesn't have.
	analysisMock.setupMockClient(mockToolsConfig, ImmutableList.of());
	// Provide a trivial platform definition.
	mockToolsConfig.create(
	"minimal_buildenv/platforms/BUILD", //
	"platform(name = 'default_host')");
	}

	@Override
	protected ConfiguredRuleClassProvider createRuleClassProvider() {
	// Set up a bare-bones ConfiguredRuleClassProvider. Aside from being minimalistic, this heads
	// off the possibility that we somehow grow an implicit dependency on production builtins code,
	// which would break since we're overwriting --experimental_builtins_bzl_path.
	ConfiguredRuleClassProvider.Builder builder = new ConfiguredRuleClassProvider.Builder();
	TestRuleClassProvider.addMinimalRules(builder);
	// Add some mock symbols to override.
	builder
	.addRuleDefinition(OVERRIDABLE_RULE)
	.addRuleDefinition(SANDWICH_RULE)
	.addRuleDefinition(SANDWICH_LOGIC_RULE)
	.addStarlarkAccessibleTopLevels("overridable_symbol", "original_value")
	.addStarlarkAccessibleTopLevels(
	"flag_guarded_symbol",
	// For this mock symbol, we reuse the same flag that guards the production
	// _builtins_dummy symbol.
	FlagGuardedValue.onlyWhenExperimentalFlagIsTrue(
	BuildLanguageOptions.EXPERIMENTAL_BUILTINS_DUMMY, "original value"));
	return builder.build();
	}

	@Before
	public void setUp() throws Exception {
	setBuildLanguageOptions("--experimental_builtins_bzl_path=tools/builtins_staging");
	}

	/**
	* Writes an exports.bzl file with the given content, in the builtins location.
	*
	* <p>See {@link StarlarkBuiltinsFunction#EXPORTS_ENTRYPOINT} for the significance of exports.bzl.
	*/
	private void writeExportsBzl(String... lines) throws Exception {
	scratch.file("tools/builtins_staging/exports.bzl", lines);
	}

	/**
	* Writes a pkg/dummy.bzl file that prints a marker phrase when it finishes evaluating, and an
	* accompanying BUILD file that loads it.
	*/
	private void writePkgBzl(String... lines) throws Exception {
	scratch.file("pkg/BUILD", "load(':dummy.bzl', 'dummy_symbol')");
	scratch.file("pkg/dummy");
	List<String> modifiedLines = new ArrayList<>(Arrays.asList(lines));
	modifiedLines.add("dummy_symbol = None");
	// The marker phrase might not be needed, but I don't entirely trust BuildViewTestCase.
	modifiedLines.add("print('dummy.bzl evaluation completed')");
	scratch.file("pkg/dummy.bzl", modifiedLines.toArray(lines));
	}

	/** Builds {@code //pkg} and asserts success, including that the marker print() event occurs. */
	private void buildAndAssertSuccess() throws Exception {
	Object result = getConfiguredTarget("//pkg:BUILD");
	assertContainsEvent("dummy.bzl evaluation completed");
	// On error, getConfiguredTarget sometimes returns null without emitting events; see b/26382502.
	// Though in that case it seems unlikely the above assertion would've passed.
	assertThat(result).isNotNull();
	}

	/** Builds {@code //pkg:dummy} and asserts on the absence of the marker print() event. */
	private void buildAndAssertFailure() throws Exception {
	reporter.removeHandler(failFastHandler);
	Object result = getConfiguredTarget("//pkg:BUILD");
	assertDoesNotContainEvent("dummy.bzl evaluation completed");
	assertWithMessage("Loading of //pkg succeeded unexpectedly").that(result).isNull();
	}

	@Test
	public void basicFunctionality() throws Exception {
	writeExportsBzl(
	"exported_toplevels = {'overridable_symbol': 'new_value'}",
	"exported_rules = {'overridable_rule': 'new_rule'}",
	"exported_to_java = {}");
	writePkgBzl(
	"print('overridable_symbol :: ' + str(overridable_symbol))",
	"print('overridable_rule :: ' + str(native.overridable_rule))");

	buildAndAssertSuccess();
	assertContainsEvent("overridable_symbol :: new_value");
	assertContainsEvent("overridable_rule :: new_rule");
	}

	@Test
	public void builtinsCanLoadFromBuiltins() throws Exception {
	// Define a few files that we can load with different kinds of label syntax. In each case,
	// access the `_internal` symbol to demonstrate that we're being loaded as a builtins bzl.
	scratch.file(
	"tools/builtins_staging/absolute.bzl", //
	"_internal",
	"a = 'A'");
	scratch.file(
	"tools/builtins_staging/repo_relative.bzl", //
	"_internal",
	"b = 'B'");
	scratch.file(
	"tools/builtins_staging/subdir/pkg_relative1.bzl", //
	// Do a relative load within a load, to show it's relative to the (pseudo) package, i.e. the
	// root, and not relative to the file. That is, we specify 'subdir/pkg_relative2.bzl', not
	// just 'pkg_relative2.bzl'.
	"load('subdir/pkg_relative2.bzl', 'c2')",
	"_internal",
	"c = c2");
	scratch.file(
	"tools/builtins_staging/subdir/pkg_relative2.bzl", //
	"_internal",
	"c2 = 'C'");

	// Also create a file in the main repo whose package path coincides with a file in the builtins
	// pseudo-repo, to show that we get the right one.
	scratch.file("BUILD");
	scratch.file("repo_relative.bzl");

	writeExportsBzl(
	"load('@_builtins//:absolute.bzl', 'a')",
	"load('//:repo_relative.bzl', 'b')", // default repo is @_builtins, not main repo
	"load('subdir/pkg_relative1.bzl', 'c')", // relative to (pseudo) package, which is repo root
	"exported_toplevels = {'overridable_symbol': a + b + c}",
	"exported_rules = {}",
	"exported_to_java = {}");
	writePkgBzl("print('overridable_symbol :: ' + str(overridable_symbol))");

	buildAndAssertSuccess();
	assertContainsEvent("overridable_symbol :: ABC");
	}

	@Test
	public void otherBzlsCannotLoadFromBuiltins() throws Exception {
	writeExportsBzl(
	"exported_toplevels = {}", //
	"exported_rules = {}",
	"exported_to_java = {}");
	writePkgBzl("load('@_builtins//:exports.bzl', 'exported_toplevels')");

	buildAndAssertFailure();
	assertContainsEvent("The repository '@_builtins' could not be resolved");
	}

	@Test
	public void builtinsCannotLoadFromNonBuiltins() throws Exception {
	scratch.file("BUILD");
	scratch.file(
	"a_user_written.bzl", //
	"toplevels = {'overridable_symbol': 'new_value'}");
	writeExportsBzl(
	// Use @// syntax to specify the main repo. Otherwise, the load would be relative to the
	// @_builtins pseudo-repo.
	"load('@//:a_user_written.bzl', 'toplevels')",
	"exported_toplevels = toplevels",
	"exported_rules = {}",
	"exported_to_java = {}");
	writePkgBzl();

	buildAndAssertFailure();
	assertContainsEvent(
	"in load statement: .bzl files in @_builtins cannot load from outside of @_builtins");
	}

	@Test
	public void builtinsCannotLoadWithMisplacedColon() throws Exception {
	scratch.file(
	"tools/builtins_staging/subdir/helper.bzl", //
	"toplevels = {'overridable_symbol': 'new_value'}");
	writeExportsBzl(
	"load('//subdir:helper.bzl', 'toplevels')", // Should've been loaded as //:subdir/helper.bzl
	"exported_toplevels = toplevels",
	"exported_rules = {}",
	"exported_to_java = {}");
	writePkgBzl();

	buildAndAssertFailure();
	assertContainsEvent("@_builtins cannot have subpackages");
	}

	@Test
	public void errorInEvaluatingBuiltinsDependency() throws Exception {
	// Test case with a Starlark error in the @_builtins pseudo-repo itself.
	scratch.file(
	"tools/builtins_staging/helper.bzl", //
	"toplevels = {'overridable_symbol': 1//0} # <-- dynamic error");
	writeExportsBzl(
	"load('@_builtins//:helper.bzl', 'toplevels')",
	"exported_toplevels = toplevels",
	"exported_rules = {}",
	"exported_to_java = {}");
	writePkgBzl();

	buildAndAssertFailure();
	assertContainsEvent(
	"File \"/workspace/tools/builtins_staging/helper.bzl\", line 1, column 37, in <toplevel>");
	assertContainsEvent("Error: integer division by zero");

	// We assert only the parts of the message before and after the module name, since the module
	// identified by the message depends on whether or not the test environment has a prelude file.
	Event ev = assertContainsEvent("Internal error while loading Starlark builtins");
	assertThat(ev.getMessage())
	.contains(
	"Failed to load builtins sources: "
	+ "at /workspace/tools/builtins_staging/exports.bzl:1:6: "
	+ "initialization of module 'helper.bzl' (internal) failed");
	}

	@Test
	public void errorInProcessingExports() throws Exception {
	// Test case with an error in the symbols exported by exports.bzl, but no actual Starlark errors
	// in the builtins files themselves.
	writeExportsBzl(
	"exported_toplevels = None", // should be dict
	"exported_rules = {}",
	"exported_to_java = {}");
	writePkgBzl();

	buildAndAssertFailure();

	// We assert only the parts of the message before and after the module name, since the module
	// identified by the message depends on whether or not the test environment has a prelude file.
	Event ev = assertContainsEvent("Internal error while loading Starlark builtins");
	assertThat(ev.getMessage())
	.contains(
	"Failed to apply declared builtins: "
	+ "got NoneType for 'exported_toplevels dict', want dict");
	}

	// TODO(#11437): Remove once disabling is not allowed.
	@Test
	public void injectionDisabledByFlag() throws Exception {
	writeExportsBzl(
	"exported_toplevels = {'overridable_symbol': 'new_value'}",
	"exported_rules = {'overridable_rule': 'new_rule'}",
	"exported_to_java = {}");
	writePkgBzl(
	"print('overridable_symbol :: ' + str(overridable_symbol))",
	"print('overridable_rule :: ' + str(native.overridable_rule))");
	setBuildLanguageOptions("--experimental_builtins_bzl_path=");

	buildAndAssertSuccess();
	assertContainsEvent("overridable_symbol :: original_value");
	assertContainsEvent("overridable_rule :: <built-in rule overridable_rule>");
	}

	// TODO(#11437): Remove once disabling is not allowed.
	@Test
	public void exportsBzlMayBeInErrorWhenInjectionIsDisabled() throws Exception {
	writeExportsBzl( //
	"PARSE ERROR");
	writePkgBzl(
	"print('overridable_symbol :: ' + str(overridable_symbol))",
	"print('overridable_rule :: ' + str(native.overridable_rule))");
	setBuildLanguageOptions("--experimental_builtins_bzl_path=");

	buildAndAssertSuccess();
	assertContainsEvent("overridable_symbol :: original_value");
	assertContainsEvent("overridable_rule :: <built-in rule overridable_rule>");
	}

	// TODO(#11954): Once WORKSPACE- and BUILD-loaded bzls use the exact same environments, we'll want
	// to apply injection to both. This is for uniformity, not because we actually care about builtins
	// injection for WORKSPACE bzls. In the meantime, assert the status quo: WORKSPACE bzls do not use
	// injection.
	@Test
	public void workspaceBzlDoesNotUseInjection() throws Exception {
	writeExportsBzl(
	"exported_toplevels = {'overridable_symbol': 'new_value'}",
	"exported_rules = {'overridable_rule': 'new_rule'}",
	"exported_to_java = {}");
	writePkgBzl();
	scratch.appendFile(
	"WORKSPACE", //
	"load(':foo.bzl', 'dummy_symbol')",
	"print(dummy_symbol)");
	scratch.file("BUILD");
	scratch.file(
	"foo.bzl",
	"dummy_symbol = None",
	"print('overridable_symbol :: ' + str(overridable_symbol))");

	buildAndAssertSuccess();
	// Builtins for WORKSPACE bzls are populated essentially the same as for BUILD bzls, except that
	// injection doesn't apply.
	assertContainsEvent("overridable_symbol :: original_value");
	// We don't assert that the rule isn't injected because the workspace native object doesn't
	// contain our original mock rule. We can test this for WORKSPACE files at the top-level though.
	}

	// TODO(#11437): Add tests of the _internal symbol's usage within builtins bzls.

	// TODO(#11437): Add test cases for BUILD file injection, and WORKSPACE file non-injection, when
	// we add injection support to PackageFunction.

	@Test
	public void overriddenSymbolsAreStillFlagGuarded() throws Exception {
	// Implementation note: This works not because of any special handling in the builtins logic,
	// but rather because flag guarding is implemented at name resolution time, before builtins
	// injection is applied.
	writeExportsBzl(
	"exported_toplevels = {'flag_guarded_symbol': 'overridden value'}",
	"exported_rules = {}",
	"exported_to_java = {}");
	writePkgBzl("flag_guarded_symbol");

	buildAndAssertFailure();
	assertContainsEvent("flag_guarded_symbol is experimental");
	}

	// TODO(#11437): Once we allow access to native symbols via _internal, verify that flag guarding
	// works correctly within builtins.

	@Test
	public void nativeRulesCanUseSymbolsFromBuiltins() throws Exception {
	writeExportsBzl(
	"exported_toplevels = {}",
	"exported_rules = {}",
	"exported_to_java = {'builtins_defined_symbol': 'value_from_builtins'}");
	scratch.file(
	"pkg/BUILD", //
	"sandwich_rule(name = 'sandwich')");

	getConfiguredTarget("//pkg:sandwich");
	assertContainsEvent("builtins_defined_symbol :: value_from_builtins");
	}

	// TODO(#11437): Verify whether this works for native-defined aspects as well.

	@Test
	public void nativeRulesCanCallFunctionsDefinedInBuiltins() throws Exception {
	writeExportsBzl(
	// The driver rule calls this helper twice with a list.
	"def func(arg):",
	" print('got arg %s' % arg)",
	" arg.append('blah')",
	" return len(arg)",
	"exported_toplevels = {}",
	"exported_rules = {}",
	"exported_to_java = {'builtins_defined_logic': func}");
	scratch.file(
	"pkg/BUILD", //
	"sandwich_logic_rule(name = 'sandwich_logic')");

	getConfiguredTarget("//pkg:sandwich_logic");
	assertContainsEvent("got arg []");
	assertContainsEvent("builtins_defined_logic call 1 :: 1");
	assertContainsEvent("got arg [\"blah\"]");
	assertContainsEvent("builtins_defined_logic call 2 :: 2");
	assertContainsEvent("final list value :: [\"blah\", \"blah\"]");
	}

	/**
	* Tests for injection, under inlining of {@link BzlLoadFunction}.
	*
	* <p>See {@link BzlLoadFunction#computeInline} for an explanation of inlining.
	*/
	@RunWith(JUnit4.class)
	public static class BuiltinsInjectionTestWithInlining extends BuiltinsInjectionTest {

	@Override
	protected boolean usesInliningBzlLoadFunction() {
	return true;
	}
	}
	}