// Copyright 2017 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.analysis; import static com.google.common.truth.Truth.assertThat; import static com.google.devtools.build.lib.packages.Attribute.attr; import static com.google.devtools.build.lib.packages.BuildType.LABEL_LIST; import static org.junit.Assert.assertThrows; import com.google.common.collect.ImmutableList; import com.google.devtools.build.lib.analysis.util.BuildViewTestBase.AnalysisFailureRecorder; import com.google.devtools.build.lib.analysis.util.BuildViewTestCase; import com.google.devtools.build.lib.analysis.util.DummyTestFragment; import com.google.devtools.build.lib.analysis.util.MockRule; import com.google.devtools.build.lib.cmdline.Label; import com.google.devtools.build.lib.packages.Attribute; import com.google.devtools.build.lib.packages.Attribute.ComputedDefault; import com.google.devtools.build.lib.packages.AttributeMap; import com.google.devtools.build.lib.packages.BuildType; import com.google.devtools.build.lib.packages.NoSuchTargetException; import com.google.devtools.build.lib.packages.RuleClass.ToolchainResolutionMode; import com.google.devtools.build.lib.packages.Type; import com.google.devtools.build.lib.skyframe.ConfiguredTargetAndData; import com.google.devtools.build.lib.testutil.TestRuleClassProvider; import com.google.devtools.build.lib.util.FileTypeSet; import java.io.IOException; import java.util.Collection; import java.util.Set; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; /** * Integration tests for configurable attributes. */ @RunWith(JUnit4.class) public class ConfigurableAttributesTest extends BuildViewTestCase { private void writeConfigRules() throws Exception { scratch.file( "conditions/BUILD", "config_setting(", " name = 'a',", " values = {'foo': 'a'})", "config_setting(", " name = 'b',", " values = {'foo': 'b'})"); } private void writeHelloRules(boolean includeDefaultCondition) throws IOException { scratch.file("java/hello/BUILD", "java_binary(", " name = 'hello',", " srcs = ['hello.java'],", " deps = select({", " '//conditions:a': [':adep'],", " '//conditions:b': [':bdep'],", includeDefaultCondition ? " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': [':defaultdep']," : "", " }))", "", "java_library(", " name = 'adep',", " srcs = ['adep.java'])", "java_library(", " name = 'bdep',", " srcs = ['bdep.java'])", "java_library(", " name = 'defaultdep',", " srcs = ['defaultdep.java'])"); } private static final String ADEP_INPUT = "bin java/hello/libadep.jar"; private static final String BDEP_INPUT = "bin java/hello/libbdep.jar"; private static final String CDEP_INPUT = "bin java/hello/libcdep.jar"; private static final String DEFAULTDEP_INPUT = "bin java/hello/libdefaultdep.jar"; /** * Checks that, given the specified configuration parameters, the input rule *has* the expected * attribute values and *doesn't have* the unexpected attribute values. */ private void checkRule( String ruleLabel, String attributeName, Collection options, Iterable expected, Iterable notExpected) throws Exception { useConfiguration(options.toArray(new String[options.size()])); ConfiguredTarget binary = getConfiguredTarget(ruleLabel); assertThat(binary).isNotNull(); Set actualDeps = artifactsToStrings(getPrerequisiteArtifacts(binary, attributeName)); expected.forEach(expectedInput -> assertThat(actualDeps).contains(expectedInput)); notExpected.forEach(unexpectedInput -> assertThat(actualDeps).doesNotContain(unexpectedInput)); } private void checkRule(String ruleLabel, String option, Iterable expected, Iterable notExpected) throws Exception { checkRule(ruleLabel, ImmutableList.of(option), expected, notExpected); } private void checkRule( String ruleLabel, Collection options, Iterable expected, Iterable notExpected) throws Exception { checkRule(ruleLabel, "deps", options, expected, notExpected); } private static final MockRule RULE_WITH_OUTPUT_ATTR = () -> MockRule.define("rule_with_output_attr", attr("out", BuildType.OUTPUT)); private static final MockRule RULE_WITH_COMPUTED_DEFAULT = () -> MockRule.define( "rule_with_computed_default", attr("string_attr", Type.STRING), attr("$computed_attr", Type.STRING).value( new ComputedDefault("string_attr") { @Override public Object getDefault(AttributeMap rule) { return rule.get("string_attr", Type.STRING) + "2"; } })); private static final MockRule RULE_WITH_BOOLEAN_ATTR = () -> MockRule.define("rule_with_boolean_attr", attr("boolean_attr", Type.BOOLEAN)); private static final MockRule RULE_WITH_ALLOWED_VALUES = () -> MockRule.define( "rule_with_allowed_values", attr("one_two", Type.STRING) .allowedValues(new Attribute.AllowedValueSet("one", "two"))); private static final MockRule RULE_WITH_LABEL_DEFAULT = () -> MockRule.define( "rule_with_label_default", (builder, env) -> builder.add( attr("dep", BuildType.LABEL) .value(Label.parseCanonicalUnchecked("//foo:default")) .allowedFileTypes(FileTypeSet.ANY_FILE))); private static final MockRule RULE_WITH_NO_PLATFORM = () -> MockRule.define( "rule_with_no_platform", (builder, env) -> builder .add(attr("deps", LABEL_LIST).allowedFileTypes()) .useToolchainResolution(ToolchainResolutionMode.DISABLED)); @Override protected ConfiguredRuleClassProvider createRuleClassProvider() { ConfiguredRuleClassProvider.Builder builder = new ConfiguredRuleClassProvider.Builder() .addRuleDefinition(RULE_WITH_OUTPUT_ATTR) .addRuleDefinition(RULE_WITH_COMPUTED_DEFAULT) .addRuleDefinition(RULE_WITH_BOOLEAN_ATTR) .addRuleDefinition(RULE_WITH_ALLOWED_VALUES) .addRuleDefinition(RULE_WITH_LABEL_DEFAULT) .addRuleDefinition(RULE_WITH_NO_PLATFORM); TestRuleClassProvider.addStandardRules(builder); // Allow use of --foo as a dummy flag builder.addConfigurationFragment(DummyTestFragment.class); return builder.build(); } @Before public void setupStarlarkJavaBinary() throws Exception { setBuildLanguageOptions("--experimental_google_legacy_api"); } @Test public void basicConfigurability() throws Exception { writeHelloRules(/*includeDefaultCondition=*/true); writeConfigRules(); checkRule( "//java/hello:hello", "--foo=a", /*expected:*/ ImmutableList.of(ADEP_INPUT), /*not expected:*/ ImmutableList.of(BDEP_INPUT, DEFAULTDEP_INPUT)); checkRule( "//java/hello:hello", "--foo=b", /*expected:*/ ImmutableList.of(BDEP_INPUT), /*not expected:*/ ImmutableList.of(ADEP_INPUT, DEFAULTDEP_INPUT)); } @Test public void configurabilityDefaults() throws Exception { writeHelloRules(/*includeDefaultCondition=*/true); writeConfigRules(); checkRule( "//java/hello:hello", "--foo=something_random", /*expected:*/ ImmutableList.of(DEFAULTDEP_INPUT), /*not expected:*/ ImmutableList.of(ADEP_INPUT, BDEP_INPUT)); checkRule("//java/hello:hello", "", /*expected:*/ ImmutableList.of(DEFAULTDEP_INPUT), /*not expected:*/ ImmutableList.of(ADEP_INPUT, BDEP_INPUT)); } /** * Duplicate label definitions are fine as long as they're in different selection branches. */ @Test public void depsWithDuplicatesInDifferentBranches() throws Exception { writeConfigRules(); scratch.file("java/hello/BUILD", "java_binary(", " name = 'hello',", " srcs = ['hello.java'],", " deps = select({", " '//conditions:a': [':adep', ':cdep'],", " '//conditions:b': [':bdep', ':cdep'],", " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': [':defaultdep'],", " }))", "", "java_library(", " name = 'adep',", " srcs = ['adep.java'])", "java_library(", " name = 'bdep',", " srcs = ['bdep.java'])", "java_library(", " name = 'cdep',", " srcs = ['cdep.java'])"); checkRule( "//java/hello:hello", "--foo=a", /*expected:*/ ImmutableList.of(ADEP_INPUT, CDEP_INPUT), /*not expected:*/ ImmutableList.of(BDEP_INPUT, DEFAULTDEP_INPUT)); } /** * Duplicate label definitions are *not* fine within the same branch. */ @Test public void depsWithDuplicatesInSameBranch() throws Exception { writeConfigRules(); scratch.file("java/hello/BUILD", "java_binary(", " name = 'hello',", " srcs = ['hello.java'],", " deps = select({", " '//conditions:a': [':adep', ':cdep', ':adep'],", " '//conditions:b': [':bdep', ':cdep'],", " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': [':defaultdep'],", " }))", "", "java_library(", " name = 'adep',", " srcs = ['adep.java'])", "java_library(", " name = 'bdep',", " srcs = ['bdep.java'])", "java_library(", " name = 'cdep',", " srcs = ['cdep.java'])"); reporter.removeHandler(failFastHandler); // Expect errors. useConfiguration("--foo=a"); getConfiguredTarget("//java/hello:hello"); assertContainsEvent( "Label '//java/hello:adep' is duplicated in the 'deps' attribute of rule 'hello'"); } /** * When an attribute includes multiple selects, we don't allow duplicates even across * selects (this saves us from having to do possibly expensive value iteration since the * number of values can grow exponentially with respect to the number of selects). */ @Test public void duplicatesAcrossMultipleSelects() throws Exception { writeConfigRules(); scratch.file( "java/hello/BUILD", "java_binary(", " name = 'hello',", " srcs = select({", " '//conditions:a': ['a.java'],", " '//conditions:b': ['b.java'],", " })", " + select({", " '//conditions:a': ['a.java'],", " '//conditions:b': ['c.java'],", " }))"); reporter.removeHandler(failFastHandler); // Expect errors. useConfiguration("--foo=a"); getConfiguredTarget("//java/hello:hello"); assertContainsEvent( "in srcs attribute of java_binary rule //java/hello:hello: Label '//java/hello:a.java' is" + " duplicated"); } /** * Even with multiple selects, duplicates are allowed within a *single* select as long as * they're in different branches (and thus mutually exclusive). */ @Test public void duplicatesInDifferentBranchesMultipleSelects() throws Exception { writeConfigRules(); scratch.file("java/hello/BUILD", "java_binary(", " name = 'hello',", " srcs = select({", " '//conditions:a': ['a.java'],", " '//conditions:b': ['a.java'],", " })", " + select({", " '//conditions:a': ['b.java'],", " '//conditions:b': ['b.java'],", " }))"); useConfiguration("--foo=a"); getConfiguredTarget("//java/hello:hello"); assertNoEvents(); } /** * With multiple selects, a single select still can't duplicate labels within the same branch. */ @Test public void duplicatesInSameBranchMultipleSelects() throws Exception { writeConfigRules(); scratch.file("java/hello/BUILD", "java_binary(", " name = 'hello',", " srcs = select({", " '//conditions:a': ['a.java', 'a.java'],", " '//conditions:b': ['b.java'],", " })", " + select({", " '//conditions:a': ['c.java'],", " '//conditions:b': ['d.java'],", " }))"); reporter.removeHandler(failFastHandler); // Expect errors. useConfiguration("--foo=a"); getConfiguredTarget("//java/hello:hello"); assertContainsEvent( "Label '//java/hello:a.java' is duplicated in the 'srcs' attribute of rule 'hello'"); } /** * Attributes of type {@link BuildType#OUTPUT} are not configurable. */ @Test public void outputTypeNotConfigurable() throws Exception { writeConfigRules(); scratch.file("foo/BUILD", "rule_with_output_attr(", " name = 'has_an_out',", " out = select({", " '//conditions:a': 'a.out',", " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': 'default.out'})", ")"); reporter.removeHandler(failFastHandler); // Expect errors. getConfiguredTarget("//foo:has_an_out"); assertContainsEvent("attribute \"out\" is not configurable"); } /** * Attributes of type {@link BuildType#OUTPUT_LIST} are not configurable. */ @Test public void outputListTypeNotConfigurable() throws Exception { writeConfigRules(); scratch.file("foo/BUILD", "genrule(", " name = 'generator',", " srcs = [],", " outs = select({", " '//conditions:a': ['a.out'],", " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': ['default.out']})", ")"); reporter.removeHandler(failFastHandler); // Expect errors. getConfiguredTarget("//foo:generator"); assertContainsEvent("attribute \"outs\" is not configurable"); } /** * Tests that computed defaults faithfully reflect the values of the attributes they depend on. */ @Test public void computedDefaults() throws Exception { writeConfigRules(); scratch.file("test/BUILD", "rule_with_computed_default(", " name = 'the_rule',", " string_attr = select({", " '//conditions:a': 'a',", " '//conditions:b': 'b',", " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': 'default',", " }))"); // Configuration a: useConfiguration("--foo=a"); ConfiguredTargetAndData binary = getConfiguredTargetAndData("//test:the_rule"); AttributeMap attributes = getMapperFromConfiguredTargetAndTarget(binary); assertThat(attributes.get("$computed_attr", Type.STRING)).isEqualTo("a2"); // configuration b: useConfiguration("--foo=b"); binary = getConfiguredTargetAndData("//test:the_rule"); attributes = getMapperFromConfiguredTargetAndTarget(binary); assertThat(attributes.get("$computed_attr", Type.STRING)).isEqualTo("b2"); } @Test public void configKeyTypeChecking_Int() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file( "java/foo/BUILD", "java_library(", " name = 'int_key',", " srcs = select({123: ['a.java']})", ")"); assertTargetError( "//java/foo:int_key", "select: got int for dict key, want a Label or label string"); } @Test public void configKeyTypeChecking_Bool() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file( "java/foo/BUILD", "java_library(", " name = 'bool_key',", " srcs = select({True: ['a.java']})", ")"); assertTargetError( "//java/foo:bool_key", "select: got bool for dict key, want a Label or label string"); } @Test public void configKeyTypeChecking_None() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file( "java/foo/BUILD", "java_library(", " name = 'none_key',", " srcs = select({None: ['a.java']})", ")"); assertTargetError( "//java/foo:none_key", "select: got NoneType for dict key, want a Label or label string"); } @Test public void selectWithoutConditionsMakesNoSense() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file( "foo/BUILD", "genrule(", " name = 'nothing',", " srcs = [],", " outs = ['notmuch'],", " cmd = select({})", ")"); assertTargetError( "//foo:nothing", "select({}) with an empty dictionary can never resolve because it includes no conditions " + "to match"); } /** * Tests that config keys must resolve to existent targets. */ @Test public void missingConfigKey() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. // Only create one of two necessary configurability rules: scratch.file( "conditions/BUILD", "config_setting(", " name = 'a',", " values = {'foo': 'a'})"); writeHelloRules(/*includeDefaultCondition=*/true); getConfiguredTarget("//java/hello:hello"); assertContainsEvent("no such target '//conditions:b'"); } /** * Tests that config keys must resolve to config_setting targets. */ @Test public void invalidConfigKey() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file( "conditions/BUILD", "config_setting(", " name = 'a',", " values = {'foo': 'a'})", "rule_with_output_attr(", " name = 'b',", " out = 'b.out')"); writeHelloRules(/*includeDefaultCondition=*/true); assertThat(getConfiguredTarget("//java/hello:hello")).isNull(); assertContainsEvent("//conditions:b is not a valid select() condition for //java/hello:hello"); assertDoesNotContainEvent("//conditions:a"); // This one is legitimate.. } @Test public void configKeyNonexistentTarget() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file("foo/BUILD", "genrule(", " name = 'g',", " outs = ['g.out'],", " cmd = select({':fake': ''})", ")"); assertThat(getConfiguredTarget("//foo:g")).isNull(); assertContainsEvent("//foo:fake is not a valid select() condition for //foo:g"); } @Test public void configKeyNonexistentTarget_otherPackage() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file( "conditions/BUILD", "config_setting(", " name = 'a',", " values = {'foo': 'a'})"); scratch.file("bar/BUILD"); scratch.file( "foo/BUILD", "genrule(", " name = 'g',", " outs = ['g.out'],", // With an invalid target and a real target, validate skyframe error handling. // See http://b/162021059 for details. " cmd = select({'//bar:fake': '', '//conditions:a': ''})", ")"); assertThat(getConfiguredTarget("//foo:g")).isNull(); assertContainsEvent("bar/BUILD: no such target '//bar:fake'"); assertContainsEvent("foo/BUILD:1:8: errors encountered resolving select() keys for //foo:g"); } /** * Tests config keys with multiple requirements. */ @Test public void multiConditionConfigKeys() throws Exception { writeHelloRules(/*includeDefaultCondition=*/true); scratch.file( "conditions/BUILD", "config_setting(", " name = 'a',", " values = {", " 'foo': 'a',", " 'compilation_mode': 'dbg'", " })", "config_setting(", " name = 'b',", " values = {'foo': 'b'})"); checkRule( "//java/hello:hello", "--foo=a", /*expected:*/ ImmutableList.of(DEFAULTDEP_INPUT), /*not expected:*/ ImmutableList.of(ADEP_INPUT, BDEP_INPUT)); checkRule( "//java/hello:hello", ImmutableList.of("--foo=a", "--compilation_mode=dbg"), /*expected:*/ ImmutableList.of(ADEP_INPUT), /*not expected:*/ ImmutableList.of(BDEP_INPUT, DEFAULTDEP_INPUT)); } /** * Tests that changing a config_setting invalidates the rule that uses it. */ @Test public void configKeyInvalidation() throws Exception { writeHelloRules(/*includeDefaultCondition=*/true); writeConfigRules(); // Iteration 1: --test_args=a should apply //conditions:a. useConfiguration("--foo=a"); checkRule( "//java/hello:hello", "--foo=a", /*expected:*/ ImmutableList.of(ADEP_INPUT), /*not expected:*/ ImmutableList.of(BDEP_INPUT, DEFAULTDEP_INPUT)); // Rewrite the condition for //conditions:a. scratch.overwriteFile( "conditions/BUILD", "config_setting(", " name = 'a',", " values = {'foo': 'c'})", "config_setting(", " name = 'b',", " values = {'foo': 'b'})"); // Iteration 2: same exact analysis should now apply the default condition. invalidatePackages(); checkRule( "//java/hello:hello", "--foo=a", /*expected:*/ ImmutableList.of(DEFAULTDEP_INPUT), /*not expected:*/ ImmutableList.of(ADEP_INPUT, BDEP_INPUT)); } /** * Tests that multiple matches are not allowed for conditions where one is not a specialization * of the other. */ @Test public void multipleMatches() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file("conditions/BUILD", "config_setting(", " name = 'dup1',", " values = {'compilation_mode': 'opt'})", "config_setting(", " name = 'dup2',", " values = {'define': 'foo=bar'})"); scratch.file("a/BUILD", "genrule(", " name = 'gen',", " cmd = '',", " outs = ['gen.out'],", " srcs = select({", " '//conditions:dup1': ['a.in'],", " '//conditions:dup2': ['b.in'],", " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': [':default.in'],", " }))"); useConfiguration("-c", "opt", "--define", "foo=bar"); assertThat(getConfiguredTarget("//a:gen")).isNull(); assertContainsEvent( "Illegal ambiguous match on configurable attribute \"srcs\" in //a:gen:\n" + "//conditions:dup1\n" + "//conditions:dup2\n" + "Multiple matches are not allowed unless one is unambiguously more specialized " + "or they resolve to the same value."); } /** * Tests that when multiple conditions match and for every matching pair, one is * a specialization of the other, the most specialized match is chosen. */ @Test public void multipleMatchesConditionAndSubcondition() throws Exception { scratch.file( "conditions/BUILD", "config_setting(", " name = 'generic',", " values = {'compilation_mode': 'opt'})", "config_setting(", " name = 'precise',", " values = {'compilation_mode': 'opt', 'define': 'foo=bar'})", "config_setting(", " name = 'most_precise',", " values = {'compilation_mode': 'opt', 'define': 'foo=bar', 'foo': 'baz'})"); scratch.file("java/a/BUILD", "java_binary(", " name = 'binary',", " srcs = ['binary.java'],", " deps = select({", " '//conditions:generic': [':generic'],", " '//conditions:precise': [':precise'],", " '//conditions:most_precise': [':most_precise'],", " }))", "java_library(", " name = 'generic',", " srcs = ['generic.java'])", "java_library(", " name = 'precise',", " srcs = ['precise.java'])", "java_library(", " name = 'most_precise',", " srcs = ['most_precise.java'])"); checkRule( "//java/a:binary", ImmutableList.of("-c", "opt", "--define", "foo=bar", "--foo", "baz"), /*expected:*/ ImmutableList.of("bin java/a/libmost_precise.jar"), /*not expected:*/ ImmutableList.of( "bin java/a/libgeneric.jar", "bin java/a/libprecise.jar")); } /** Tests that multiple matches are allowed for conditions where the value is the same. */ @Test public void multipleMatchesSameValue() throws Exception { reporter.removeHandler(failFastHandler); // Expect errors. scratch.file( "conditions/BUILD", "config_setting(", " name = 'dup1',", " values = {'compilation_mode': 'opt'})", "config_setting(", " name = 'dup2',", " values = {'define': 'foo=bar'})"); scratch.file( "a/BUILD", "genrule(", " name = 'gen',", " cmd = '',", " outs = ['gen.out'],", " srcs = select({", " '//conditions:dup1': ['a.in'],", " '//conditions:dup2': ['a.in'],", " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': [':default.in'],", " }))"); checkRule( "//a:gen", "srcs", ImmutableList.of("-c", "opt", "--define", "foo=bar"), /*expected:*/ ImmutableList.of("src a/a.in"), /*not expected:*/ ImmutableList.of("src a/default.in")); } /** * Tests that when multiple conditions match but one condition is more specialized than the * others, it is chosen and there is no error. */ @Test public void multipleMatchesUnambiguous() throws Exception { scratch.file( "conditions/BUILD", "config_setting(", " name = 'a',", " values = {'define': 'a=1'})", "config_setting(", " name = 'b',", " values = {'compilation_mode': 'opt'})", "config_setting(", " name = 'c',", " values = {'foo': 'baz'})", "config_setting(", " name = 'b_a_c',", // Named to come alphabetically after a and b but before c. " values = {'define': 'a=1', 'foo': 'baz', 'compilation_mode': 'opt'})"); scratch.file("java/a/BUILD", "java_binary(", " name = 'binary',", " srcs = ['binary.java'],", " deps = select({", " '//conditions:a': [':a'],", " '//conditions:b': [':b'],", " '//conditions:c': [':c'],", " '//conditions:b_a_c': [':b_a_c'],", " }))", "java_library(", " name = 'a',", " srcs = ['a.java'])", "java_library(", " name = 'b',", " srcs = ['b.java'])", "java_library(", " name = 'c',", " srcs = ['c.java'])", "java_library(", " name = 'b_a_c',", " srcs = ['b_a_c.java'])"); checkRule( "//java/a:binary", ImmutableList.of("--define", "a=1", "--compilation_mode", "opt", "--foo", "baz"), /*expected:*/ ImmutableList.of("bin java/a/libb_a_c.jar"), /*not expected:*/ ImmutableList.of( "bin java/a/liba.jar", "bin java/a/libb.jar", "bin java/a/libc.jar")); } /** Tests that default conditions are only required when no main condition matches. */ @Test public void noDefaultCondition() throws Exception { writeHelloRules(/*includeDefaultCondition=*/false); writeConfigRules(); // An explicit configuration matches: all is well. checkRule( "//java/hello:hello", "--foo=a", /*expected:*/ ImmutableList.of(ADEP_INPUT), /*not expected:*/ ImmutableList.of(BDEP_INPUT, DEFAULTDEP_INPUT)); // Nothing matches: expect an error. reporter.removeHandler(failFastHandler); useConfiguration(""); assertThat(getConfiguredTarget("//java/hello:hello")).isNull(); assertContainsEvent( "configurable attribute \"deps\" in //java/hello:hello doesn't match this configuration"); } @Test public void noMatchCustomErrorMessage() throws Exception { writeConfigRules(); scratch.file("java/hello/BUILD", "java_binary(", " name = 'hello_default_no_match_error',", " srcs = select({", " '//conditions:a': ['not_chosen.java'],", " }))", "java_binary(", " name = 'hello_custom_no_match_error',", " srcs = select({", " '//conditions:a': ['not_chosen.java'],", " },", " no_match_error = 'You always have to choose condition a!'", "))"); reporter.removeHandler(failFastHandler); AnalysisFailureRecorder analysisFailureRecorder = new AnalysisFailureRecorder(); eventBus.register(analysisFailureRecorder); useConfiguration(""); assertThat(getConfiguredTarget("//java/hello:hello_default_no_match_error")).isNull(); assertContainsEvent( "configurable attribute \"srcs\" in //java/hello:hello_default_no_match_error doesn't" + " match this configuration. Would a default condition help?\n" + "\n" + "Conditions checked:"); // Verify a Root Cause is reported when a target cannot be configured due to no matching config. assertThat(analysisFailureRecorder.causes).hasSize(1); AnalysisRootCauseEvent rootCause = analysisFailureRecorder.causes.get(0); assertThat(rootCause.getLabel()) .isEqualTo(Label.parseCanonical("//java/hello:hello_default_no_match_error")); eventBus.unregister(analysisFailureRecorder); analysisFailureRecorder = new AnalysisFailureRecorder(); eventBus.register(analysisFailureRecorder); eventCollector.clear(); assertThat(getConfiguredTarget("//java/hello:hello_custom_no_match_error")).isNull(); assertContainsEvent( "configurable attribute \"srcs\" in //java/hello:hello_custom_no_match_error doesn't match " + "this configuration: You always have to choose condition a!"); // Verify a Root Cause is reported when a target cannot be configured due to no matching config. assertThat(analysisFailureRecorder.causes).hasSize(1); rootCause = analysisFailureRecorder.causes.get(0); assertThat(rootCause.getLabel()) .isEqualTo(Label.parseCanonical("//java/hello:hello_custom_no_match_error")); } @Test public void nativeTypeConcatenatedWithSelect() throws Exception { writeConfigRules(); scratch.file( "java/foo/rule.bzl", "def _rule_impl(ctx):", " return []", "myrule = rule(", " implementation = _rule_impl,", " attrs = {", " 'deps': attr.label_keyed_string_dict()", " },", ")"); scratch.file( "java/foo/BUILD", "load(':rule.bzl', 'myrule')", "myrule(", " name = 'mytarget',", " deps = {':always': 'always'} | select({", " '//conditions:a': {':a': 'a'},", " '//conditions:b': {':b': 'b'},", " })", ")", "java_binary(", " name = 'binary',", " srcs = ['binary.java'],", " deps = [':always'] + select({", " '//conditions:a': [':a'],", " '//conditions:b': [':b'],", " })", ")", "java_library(", " name = 'always',", " srcs = ['always.java'])", "java_library(", " name = 'a',", " srcs = ['a.java'])", "java_library(", " name = 'b',", " srcs = ['b.java'])"); checkRule( "//java/foo:binary", "--foo=b", /*expected:*/ ImmutableList.of("bin java/foo/libalways.jar", "bin java/foo/libb.jar"), /*not expected:*/ ImmutableList.of("bin java/foo/liba.jar")); checkRule( "//java/foo:mytarget", "--foo=b", /*expected:*/ ImmutableList.of("bin java/foo/libalways.jar", "bin java/foo/libb.jar"), /*not expected:*/ ImmutableList.of("bin java/foo/liba.jar")); } @Test public void selectConcatenatedWithNativeType() throws Exception { writeConfigRules(); scratch.file( "java/foo/rule.bzl", "def _rule_impl(ctx):", " return []", "myrule = rule(", " implementation = _rule_impl,", " attrs = {", " 'deps': attr.label_keyed_string_dict()", " },", ")"); scratch.file( "java/foo/BUILD", "load(':rule.bzl', 'myrule')", "myrule(", " name = 'mytarget',", " deps = select({", " '//conditions:a': {':a': 'a'},", " '//conditions:b': {':b': 'b'},", " }) | {':always': 'always'}", ")", "java_binary(", " name = 'binary',", " srcs = ['binary.java'],", " deps = select({", " '//conditions:a': [':a'],", " '//conditions:b': [':b'],", " }) + [':always'])", "java_library(", " name = 'always',", " srcs = ['always.java'])", "java_library(", " name = 'a',", " srcs = ['a.java'])", "java_library(", " name = 'b',", " srcs = ['b.java'])"); checkRule( "//java/foo:binary", "--foo=b", /*expected:*/ ImmutableList.of("bin java/foo/libalways.jar", "bin java/foo/libb.jar"), /*not expected:*/ ImmutableList.of("bin java/foo/liba.jar")); checkRule( "//java/foo:mytarget", "--foo=b", /*expected:*/ ImmutableList.of("bin java/foo/libalways.jar", "bin java/foo/libb.jar"), /*not expected:*/ ImmutableList.of("bin java/foo/liba.jar")); } @Test public void selectConcatenatedWithSelect() throws Exception { writeConfigRules(); scratch.file( "java/foo/rule.bzl", "def _rule_impl(ctx):", " return []", "myrule = rule(", " implementation = _rule_impl,", " attrs = {", " 'deps': attr.label_keyed_string_dict()", " },", ")"); scratch.file( "java/foo/BUILD", "load(':rule.bzl', 'myrule')", "myrule(", " name = 'mytarget',", " deps = select({", " '//conditions:a': {':a': 'a'},", " '//conditions:b': {':b': 'b'},", " }) | select({", " '//conditions:a': {':a2': 'a2'},", " '//conditions:b': {':b2': 'b2'},", " })", ")", "java_binary(", " name = 'binary',", " srcs = ['binary.java'],", " deps = select({", " '//conditions:a': [':a'],", " '//conditions:b': [':b'],", " }) + select({", " '//conditions:a': [':a2'],", " '//conditions:b': [':b2'],", " })", ")", "java_library(", " name = 'a',", " srcs = ['a.java'])", "java_library(", " name = 'b',", " srcs = ['b.java'])", "java_library(", " name = 'a2',", " srcs = ['a2.java'])", "java_library(", " name = 'b2',", " srcs = ['b2.java'])"); checkRule( "//java/foo:binary", "--foo=b", /*expected:*/ ImmutableList.of("bin java/foo/libb.jar", "bin java/foo/libb2.jar"), /*not expected:*/ ImmutableList.of("bin java/foo/liba.jar", "bin java/foo/liba2.jar")); checkRule( "//java/foo:mytarget", "--foo=b", /*expected:*/ ImmutableList.of("bin java/foo/libb.jar", "bin java/foo/libb2.jar"), /*not expected:*/ ImmutableList.of("bin java/foo/liba.jar", "bin java/foo/liba2.jar")); } @Test public void dictsWithSameKey() throws Exception { writeConfigRules(); scratch.file( "java/foo/rule.bzl", "def _rule_impl(ctx):", " outputs = []", " for target, value in ctx.attr.deps.items():", " output = ctx.actions.declare_file(target.label.name + value)", " ctx.actions.write(content = value, output = output)", " outputs.append(output)", " return [DefaultInfo(files=depset(outputs))]", "myrule = rule(", " implementation = _rule_impl,", " attrs = {", " 'deps': attr.label_keyed_string_dict()", " },", ")"); scratch.file( "java/foo/BUILD", "load(':rule.bzl', 'myrule')", "myrule(", " name = 'mytarget',", " deps = select({", " '//conditions:a': {':a': 'a'},", " }) | select({", " '//conditions:a': {':a': 'a2'},", " })", ")", "java_library(", " name = 'a',", " srcs = ['a.java']", ")", "filegroup(", " name = 'group',", " srcs = [':mytarget'],", ")"); checkRule( "//java/foo:group", "srcs", ImmutableList.of("--foo=a"), /*expected:*/ ImmutableList.of("bin java/foo/aa2"), /*not expected:*/ ImmutableList.of("bin java/foo/aa")); } @Test public void selectConcatenatedWithNonSupportingType() throws Exception { writeConfigRules(); scratch.file( "foo/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = 0 + select({", " '//conditions:a': 0,", " '//conditions:b': 1,", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//foo:binary")).isNull(); assertContainsEvent("type 'boolean' doesn't support select concatenation"); } @Test public void concatenationWithDifferentTypes() throws Exception { writeConfigRules(); scratch.file("java/foo/BUILD", "java_binary(", " name = 'binary',", " srcs = select({", " '//conditions:a': ['a.java'],", " '//conditions:b': ['b.java'],", " }) + 'always.java'", ")"); reporter.removeHandler(failFastHandler); assertThrows(NoSuchTargetException.class, () -> getTarget("//java/foo:binary")); assertContainsEvent("Cannot combine incompatible types"); } @Test public void selectsWithGlobs() throws Exception { writeConfigRules(); scratch.file("java/foo/globbed/ceecee.java"); scratch.file("java/foo/BUILD", "java_binary(", " name = 'binary',", " srcs = glob(['globbed/*.java']) + select({", " '//conditions:a': ['a.java'],", " '//conditions:b': ['b.java'],", " }))"); useConfiguration("--foo=b"); ConfiguredTarget binary = getConfiguredTarget("//java/foo:binary"); assertThat(binary).isNotNull(); Set sources = artifactsToStrings(getPrerequisiteArtifacts(binary, "srcs")); assertThat(sources).contains("src java/foo/b.java"); assertThat(sources).contains("src java/foo/globbed/ceecee.java"); assertThat(sources).doesNotContain("src java/foo/a.java"); } @Test public void selectsWithGlobsWrongType() throws Exception { writeConfigRules(); scratch.file( "foo/BUILD", "genrule(", " name = 'gen',", " srcs = [],", " outs = ['gen.out'],", " cmd = 'echo' + select({", " '//conditions:a': 'a',", " '//conditions:b': 'b',", " }) + glob(['globbed.java'], allow_empty = True))"); reporter.removeHandler(failFastHandler); assertThrows(NoSuchTargetException.class, () -> getTarget("//foo:binary")); assertContainsEvent("Cannot combine incompatible types"); } @Test public void globsInSelect() throws Exception { writeConfigRules(); scratch.file("java/foo/globbed/ceecee.java"); scratch.file("java/foo/BUILD", "java_binary(", " name = 'binary',", " srcs = ['binary.java'] + select({", " '//conditions:a': glob(['globbed/*.java']),", " '//conditions:b': ['b.java'],", " }))"); useConfiguration("--foo=a"); ConfiguredTarget binary = getConfiguredTarget("//java/foo:binary"); assertThat(binary).isNotNull(); Set sources = artifactsToStrings(getPrerequisiteArtifacts(binary, "srcs")); assertThat(sources).contains("src java/foo/binary.java"); assertThat(sources).contains("src java/foo/globbed/ceecee.java"); assertThat(sources).doesNotContain("src java/foo/b.java"); } @Test public void selectAcceptedInAttributeWithAllowedValues() throws Exception { scratch.file("foo/BUILD", "rule_with_allowed_values(", " name = 'rule',", " one_two = select({", " '//conditions:default': 'one',", " }))"); assertThat(getConfiguredTarget("//foo:rule")).isNotNull(); } @Test public void selectWithNonAllowedValueCausesError() throws Exception { scratch.file("foo/BUILD", "rule_with_allowed_values(", " name = 'rule',", " one_two = select({", " '//conditions:default': 'TOTALLY_ILLEGAL_VALUE',", " }))"); reporter.removeHandler(failFastHandler); // Expect errors. getConfiguredTarget("//foo:rule"); assertContainsEvent( "invalid value in 'one_two' attribute: " + "has to be one of 'one' or 'two' instead of 'TOTALLY_ILLEGAL_VALUE'"); } @Test public void selectWithMultipleNonAllowedValuesCausesMultipleErrors() throws Exception { scratch.file("foo/BUILD", "rule_with_allowed_values(", " name = 'rule',", " one_two = select({", " '//conditions:a': 'TOTALLY_ILLEGAL_VALUE',", " '//conditions:default': 'DIFFERENT_BUT_STILL_ILLEGAL',", " }))"); reporter.removeHandler(failFastHandler); // Expect errors. getConfiguredTarget("//foo:rule"); assertContainsEvent( "invalid value in 'one_two' attribute: " + "has to be one of 'one' or 'two' instead of 'TOTALLY_ILLEGAL_VALUE'"); assertContainsEvent( "invalid value in 'one_two' attribute: " + "has to be one of 'one' or 'two' instead of 'DIFFERENT_BUT_STILL_ILLEGAL'"); } @Test public void selectConcatenationWithAllowedValues() throws Exception { scratch.file("foo/BUILD", "rule_with_allowed_values(", " name = 'rule',", " one_two = 'on' + select({", " '//conditions:default': 'e',", " }))"); assertThat(getConfiguredTarget("//foo:rule")).isNotNull(); } @Test public void selectConcatenationWithNonAllowedValues() throws Exception { scratch.file("foo/BUILD", "rule_with_allowed_values(", " name = 'rule',", " one_two = 'on' + select({", " '//conditions:default': 'o',", " }))"); reporter.removeHandler(failFastHandler); // Expect errors. getConfiguredTarget("//foo:binary"); assertContainsEvent( "invalid value in 'one_two' attribute: " + "has to be one of 'one' or 'two' instead of 'ono'"); } @Test public void computedDefaultAttributesCanReferenceConfigurableAttributes() throws Exception { scratch.file( "test/selector_rules.bzl", "def _impl(ctx):", " ctx.actions.write(", " output=ctx.outputs.out_file,", " content=ctx.attr.string_value,", " )", " return []", "", "def _derived_value(string_value):", " return Label(\"//test:%s\" % string_value)", "", "selector_rule = rule(", " attrs = {", " \"string_value\": attr.string(default = \"\"),", " \"out_file\": attr.output(),", " \"_derived\": attr.label(default = _derived_value),", " },", "implementation = _impl,", ")"); scratch.file("test/BUILD", "genrule(name = \"foo\", srcs = [], outs = [\"foo.out\"], cmd = \"\")"); scratch.file( "foo/BUILD", "load('//test:selector_rules.bzl', \"selector_rule\")", "selector_rule(", " name = \"rule\",", " out_file = \"rule.out\",", " string_value = select({\"//conditions:default\": \"foo\"}),", ")"); getConfiguredTarget("//foo:rule"); assertNoEvents(); } @Test public void selectableDefaultValueWithTypeDefault() throws Exception { writeConfigRules(); scratch.file("srctest/BUILD", "genrule(", " name = 'gen',", " cmd = '',", " outs = ['gen.out'],", " srcs = select({", " '//conditions:a': None,", " }))"); useConfiguration("--foo=a"); ConfiguredTargetAndData ctad = getConfiguredTargetAndData("//srctest:gen"); AttributeMap attributes = getMapperFromConfiguredTargetAndTarget(ctad); assertThat(attributes.get("srcs", LABEL_LIST)).isEmpty(); } @Test public void selectableDefaultValueWithRuleDefault() throws Exception { writeConfigRules(); scratch.file("foo/BUILD", "rule_with_label_default(", " name = 'rule',", " dep = select({", " '//conditions:a': None,", " }))", "rule_with_boolean_attr(", " name = 'default',", " boolean_attr = 1)"); useConfiguration("--foo=a"); ConfiguredTargetAndData ctad = getConfiguredTargetAndData("//foo:rule"); AttributeMap attributes = getMapperFromConfiguredTargetAndTarget(ctad); assertThat(attributes.get("dep", BuildType.LABEL)) .isEqualTo(Label.parseCanonical("//foo:default")); } @Test public void noneValuesWithMultipleSelectsMixedValues() throws Exception { writeConfigRules(); scratch.file("a/BUILD", "genrule(", " name = 'gen',", " srcs = [],", " outs = ['out'],", " cmd = '',", " message = select({", " '//conditions:a': 'defined message 1',", " '//conditions:b': None,", " }) + select({", " '//conditions:a': None,", " '//conditions:b': 'defined message 2',", " }),", ")"); reporter.removeHandler(failFastHandler); useConfiguration("--define", "mode=a"); assertThat(getConfiguredTarget("//a:gen")).isNull(); assertContainsEvent("Cannot combine incompatible types (select of string, select of NoneType)"); } @Test public void emptySelectCannotBeConcatenated() throws Exception { scratch.file("a/BUILD", "genrule(", " name = 'gen',", " srcs = [],", " outs = ['out'],", " cmd = select({}) + ' always include'", ")"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:gen")).isNull(); assertContainsEvent( "select({}) with an empty dictionary can never resolve because it includes no conditions " + "to match"); } @Test public void selectOnConstraints() throws Exception { // create some useful constraints and platforms. scratch.file( "conditions/BUILD", "constraint_setting(name = 'fruit')", "constraint_value(name = 'apple', constraint_setting = 'fruit')", "constraint_value(name = 'banana', constraint_setting = 'fruit')", "platform(", " name = 'apple_platform',", " constraint_values = [':apple'],", ")", "platform(", " name = 'banana_platform',", " constraint_values = [':banana'],", ")", "config_setting(", " name = 'a',", " constraint_values = [':apple']", ")", "config_setting(", " name = 'b',", " constraint_values = [':banana']", ")"); scratch.file( "check/BUILD", "filegroup(name = 'adep', srcs = ['afile'])", "filegroup(name = 'bdep', srcs = ['bfile'])", "filegroup(name = 'defaultdep', srcs = ['defaultfile'])", "filegroup(name = 'hello',", " srcs = select({", " '//conditions:a': [':adep'],", " '//conditions:b': [':bdep'],", " '" + BuildType.Selector.DEFAULT_CONDITION_KEY + "': [':defaultdep'],", " }))"); checkRule( "//check:hello", "srcs", ImmutableList.of("--experimental_platforms=//conditions:apple_platform"), /*expected:*/ ImmutableList.of("src check/afile"), /*not expected:*/ ImmutableList.of("src check/bfile", "src check/defaultfile")); } @Test public void selectDirectlyOnConstraints() throws Exception { // Tests select()ing directly on a constraint_value (with no intermediate config_setting). scratch.file( "conditions/BUILD", "constraint_setting(name = 'fruit')", "constraint_value(name = 'apple', constraint_setting = 'fruit')", "constraint_value(name = 'banana', constraint_setting = 'fruit')", "platform(", " name = 'apple_platform',", " constraint_values = [':apple'],", ")", "platform(", " name = 'banana_platform',", " constraint_values = [':banana'],", ")"); scratch.file( "check/defs.bzl", "def _impl(ctx):", " pass", "simple_rule = rule(", " implementation = _impl,", " attrs = {'srcs': attr.label_list(allow_files = True)}", ")"); scratch.file( "check/BUILD", "load('//check:defs.bzl', 'simple_rule')", "filegroup(name = 'adep', srcs = ['afile'])", "filegroup(name = 'bdep', srcs = ['bfile'])", "simple_rule(name = 'hello',", " srcs = select({", " '//conditions:apple': [':adep'],", " '//conditions:banana': [':bdep'],", " }))"); checkRule( "//check:hello", "srcs", ImmutableList.of("--platforms=//conditions:apple_platform"), /*expected:*/ ImmutableList.of("src check/afile"), /*not expected:*/ ImmutableList.of("src check/bfile", "src check/defaultfile")); checkRule( "//check:hello", "srcs", ImmutableList.of("--platforms=//conditions:banana_platform"), /*expected:*/ ImmutableList.of("src check/bfile"), /*not expected:*/ ImmutableList.of("src check/afile", "src check/defaultfile")); } @Test public void nonToolchainResolvingTargetsCantSelectDirectlyOnConstraints() throws Exception { // Tests select()ing directly on a constraint_value (with no intermediate config_setting). scratch.file( "conditions/BUILD", "constraint_setting(name = 'fruit')", "constraint_value(name = 'apple', constraint_setting = 'fruit')", "platform(", " name = 'apple_platform',", " constraint_values = [':apple'],", ")"); scratch.file( "check/BUILD", "filegroup(name = 'adep', srcs = ['afile'])", "rule_with_no_platform(name = 'hello',", " deps = select({", " '//conditions:apple': [':adep'],", " })", ")"); reporter.removeHandler(failFastHandler); useConfiguration("--platforms=//conditions:apple_platform"); assertThat(getConfiguredTarget("//check:hello")).isNull(); assertContainsEvent("//conditions:apple is not a valid select() condition for //check:hello"); } @Test public void selectOnlyToolchainResolvingTargetsCanSelectDirectlyOnConstraints() throws Exception { // Tests select()ing directly on a constraint_value when the rule uses toolchain resolution // *only if it has a select()*. As of this test, alias() is the only rule that supports that // (see Alias#useToolchainResolution(ToolchainResolutionMode.ENABLED_ONLY_FOR_COMMON_LOGIC). scratch.file( "conditions/BUILD", "constraint_setting(name = 'fruit')", "constraint_value(name = 'apple', constraint_setting = 'fruit')", "constraint_value(name = 'banana', constraint_setting = 'fruit')", "platform(", " name = 'apple_platform',", " constraint_values = [':apple'],", ")"); scratch.file( "check/defs.bzl", "def _impl(ctx):", " pass", "simple_rule = rule(", " implementation = _impl,", " attrs = {}", ")"); scratch.file( "check/BUILD", "load('//check:defs.bzl', 'simple_rule')", "filegroup(name = 'bdep', srcs = ['bfile'])", "simple_rule(name = 'hello')", "simple_rule(name = 'tere')", "alias(", " name = 'selectable_alias',", " actual = select({", " '//conditions:apple': ':hello',", " '//conditions:banana': ':tere',", " }))"); useConfiguration("--platforms=//conditions:apple_platform"); assertThat( getConfiguredTarget("//check:selectable_alias") .getActual() .getLabel() .getCanonicalForm()) .isEqualTo("//check:hello"); } @Test public void multipleMatchErrorWhenAliasResolvesToSameSetting() throws Exception { scratch.file( "a/BUILD", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' })", "alias(", " name = 'alias_to_foo',", " actual = ':foo')", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " ':foo': 0,", " 'alias_to_foo': 1,", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNull(); assertContainsEvent( "configurable attribute \"boolean_attr\" in //a:binary doesn't match this configuration. " + "Would a default condition help?\n\n" + "Conditions checked:\n" + " //a:foo\n" + " //a:alias_to_foo"); } @Test public void defaultVisibilityConfigSetting_noVisibilityEnforcement() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=false"); scratch.file("c/BUILD", "config_setting(name = 'foo', define_values = { 'foo': '1' })"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNotNull(); assertNoEvents(); } @Test public void privateVisibilityConfigSetting_noVisibilityEnforcement() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=false"); scratch.file( "c/BUILD", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", " visibility = ['//visibility:private']", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNotNull(); assertNoEvents(); } @Test public void publicVisibilityConfigSetting_noVisibilityEnforcement() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=false"); scratch.file( "c/BUILD", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", " visibility = ['//visibility:public']", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNotNull(); assertNoEvents(); } @Test public void defaultVisibilityConfigSetting_defaultIsPublic() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=false"); scratch.file("c/BUILD", "config_setting(name = 'foo', define_values = { 'foo': '1' })"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNotNull(); assertNoEvents(); } @Test public void privateVisibilityConfigSetting_defaultIsPublic() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=false"); scratch.file( "c/BUILD", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", " visibility = ['//visibility:private']", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNull(); assertContainsEvent("'//c:foo' is not visible from target '//a:binary'"); } @Test public void publicVisibilityConfigSetting_defaultIsPublic() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=false"); scratch.file( "c/BUILD", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", " visibility = ['//visibility:public']", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNotNull(); assertNoEvents(); } @Test public void defaultPublicVisibility_aliasVisibilityIgnored_aliasVisibilityIsDefault() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions( "--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=false"); scratch.file( "c/BUILD", "alias(", " name = 'foo_alias',", " actual = ':foo')", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo_alias': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNotNull(); assertNoEvents(); } @Test public void defaultPublicVisibility_aliasVisibilityIgnored_aliasVisibilityIsExplicit() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions( "--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=false"); scratch.file( "c/BUILD", "alias(", " name = 'foo_alias',", " actual = ':foo',", // Current flag combo skips this and directly checks the config_setting's visibility. " visibility = ['//visibility:private']", ")", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo_alias': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNotNull(); assertNoEvents(); } @Test public void defaultPublicVisibility_aliasVisibilityIgnored_configSettingVisibilityIsExplicit() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions( "--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=false"); scratch.file( "c/BUILD", "alias(", " name = 'foo_alias',", " actual = ':foo',", // Current flag combo skips this and directly checks the config_setting's visibility. " visibility = ['//visibility:public']", ")", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", " visibility = ['//visibility:private']", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo_alias': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNull(); assertContainsEvent("'//c:foo' is not visible from target '//a:binary'"); } @Test public void defaultPublicVisibility_trimmedConfigsDontCrash() throws Exception { // When enforcing config_setting visibility with // --incompatible_config_setting_private_default_visibility=false, the alias // ConfiguredTargetAndData clones itself with the ConfiguredTargetAndData of the config_setting // it refers to. ConfiguredTargetAndData.fromConfiguredTarget has a safety check that both // configs are the same. When the target with a select() is a test and --trim_test_configuration // is on, the alias takes the parent's config (with TestOptions) but the config_setting has it // stripped. This is a regression test that Blaze doesn't crash expecting those configs to be // equal. setPackageOptions( "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=false"); useConfiguration("--trim_test_configuration=true"); scratch.file( "c/defs.bzl", "def _impl(ctx):", " output = ctx.outputs.out", " ctx.actions.write(output = output, content = 'hi', is_executable = True)", " return [DefaultInfo(executable = output)]", "", "fake_test = rule(", " attrs = {", " 'msg': attr.string(),", " },", " test = True,", " outputs = {'out': 'foo.out'},", " implementation = _impl,", ")"); scratch.file( "c/BUILD", "load(':defs.bzl', 'fake_test')", "alias(", " name = 'foo_alias',", " actual = ':foo',", ")", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", ")", "fake_test(", " name = 'foo_test',", " msg = select({", " ':foo_alias': 'hi',", " '//conditions:default': 'there'", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//c:foo_test")).isNotNull(); assertNoEvents(); } @Test public void defaultVisibilityConfigSetting_defaultIsPrivate() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=true"); scratch.file("c/BUILD", "config_setting(name = 'foo', define_values = { 'foo': '1' })"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNull(); assertContainsEvent("'//c:foo' is not visible from target '//a:binary'"); } @Test public void privateVisibilityConfigSetting_defaultIsPrivate() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=true"); scratch.file( "c/BUILD", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", " visibility = ['//visibility:private']", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNull(); assertContainsEvent("'//c:foo' is not visible from target '//a:binary'"); } @Test public void publicVisibilityConfigSetting_defaultIsPrivate() throws Exception { // Production builds default to private visibility, but BuildViewTestCase defaults to public. setPackageOptions("--default_visibility=private", "--incompatible_enforce_config_setting_visibility=true", "--incompatible_config_setting_private_default_visibility=true"); scratch.file( "c/BUILD", "config_setting(", " name = 'foo',", " define_values = { 'foo': '1' },", " visibility = ['//visibility:public']", ")"); scratch.file( "a/BUILD", "rule_with_boolean_attr(", " name = 'binary',", " boolean_attr = select({", " '//c:foo': 0,", " '//conditions:default': 1", " }))"); reporter.removeHandler(failFastHandler); assertThat(getConfiguredTarget("//a:binary")).isNotNull(); assertNoEvents(); } @Test public void selectWithLabelKeysInMacro() throws Exception { writeConfigRules(); scratch.file("java/BUILD"); scratch.file( "java/macros.bzl", "def my_java_binary(name, deps = [], **kwargs):", " native.java_binary(", " name = name,", " deps = select({", " Label('//conditions:a'): [Label('//java/foo:a')],", " '//conditions:b': [Label('//java/foo:b')],", " }) + select({", " '//conditions:a': [Label('//java/foo:a2')],", " Label('//conditions:b'): [Label('//java/foo:b2')],", " }),", " **kwargs,", " )"); scratch.file( "java/foo/BUILD", "load('//java:macros.bzl', 'my_java_binary')", "my_java_binary(", " name = 'binary',", " srcs = ['binary.java'],", ")", "java_library(", " name = 'a',", " srcs = ['a.java'])", "java_library(", " name = 'b',", " srcs = ['b.java'])", "java_library(", " name = 'a2',", " srcs = ['a2.java'])", "java_library(", " name = 'b2',", " srcs = ['b2.java'])"); checkRule( "//java/foo:binary", "--foo=b", /*expected:*/ ImmutableList.of("bin java/foo/libb.jar", "bin java/foo/libb2.jar"), /*not expected:*/ ImmutableList.of("bin java/foo/liba.jar", "bin java/foo/liba2.jar")); } }