The great Skylark -> Starlark class migration: SkylarkModules SkylarkRuleClassFunctions SkylarkRuleContext SkylarkAspect SkylarkDefinedAspect SkylarkExportable SkylarkNativeAspect SkylarkNativeModule SkylarkAspectApi SkylarkNativeModuleApi SkylarkRuleContextApi SkylarkRuleFunctionsApi SkylarkAspectStub FakeSkylarkAspect FakeSkylarkNativeModuleApi FakeSkylarkRuleFunctionsApi SkylarkDefinedAspectsTest SkylarkRuleClassFunctionsTest SkylarkRuleContextTest SkylarkRuleImplementationFunctionsTest SkylarkStringRepresentationsTest SkylarkTestCase PiperOrigin-RevId: 310967362
diff --git a/src/test/java/com/google/devtools/build/lib/skylark/StarlarkRuleClassFunctionsTest.java b/src/test/java/com/google/devtools/build/lib/skylark/StarlarkRuleClassFunctionsTest.java new file mode 100644 index 0000000..ab0ddab --- /dev/null +++ b/src/test/java/com/google/devtools/build/lib/skylark/StarlarkRuleClassFunctionsTest.java
@@ -0,0 +1,1860 @@ +// Copyright 2014 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.skylark; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.base.Joiner; +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Iterables; +import com.google.devtools.build.lib.analysis.config.transitions.NoTransition; +import com.google.devtools.build.lib.analysis.skylark.StarlarkAttrModule; +import com.google.devtools.build.lib.analysis.skylark.StarlarkRuleClassFunctions.StarlarkRuleFunction; +import com.google.devtools.build.lib.analysis.skylark.StarlarkRuleContext; +import com.google.devtools.build.lib.cmdline.Label; +import com.google.devtools.build.lib.collect.nestedset.Depset; +import com.google.devtools.build.lib.events.Event; +import com.google.devtools.build.lib.events.EventKind; +import com.google.devtools.build.lib.packages.AdvertisedProviderSet; +import com.google.devtools.build.lib.packages.AspectParameters; +import com.google.devtools.build.lib.packages.Attribute; +import com.google.devtools.build.lib.packages.BuildType; +import com.google.devtools.build.lib.packages.ExecGroup; +import com.google.devtools.build.lib.packages.ImplicitOutputsFunction; +import com.google.devtools.build.lib.packages.PredicateWithMessage; +import com.google.devtools.build.lib.packages.RequiredProviders; +import com.google.devtools.build.lib.packages.RuleClass; +import com.google.devtools.build.lib.packages.RuleClass.Builder.RuleClassType; +import com.google.devtools.build.lib.packages.SkylarkAspectClass; +import com.google.devtools.build.lib.packages.SkylarkInfo; +import com.google.devtools.build.lib.packages.StarlarkDefinedAspect; +import com.google.devtools.build.lib.packages.StarlarkProvider; +import com.google.devtools.build.lib.packages.StarlarkProviderIdentifier; +import com.google.devtools.build.lib.packages.StructImpl; +import com.google.devtools.build.lib.packages.StructProvider; +import com.google.devtools.build.lib.packages.Type; +import com.google.devtools.build.lib.skyframe.StarlarkImportLookupFunction; +import com.google.devtools.build.lib.skylark.util.StarlarkTestCase; +import com.google.devtools.build.lib.syntax.ClassObject; +import com.google.devtools.build.lib.syntax.Dict; +import com.google.devtools.build.lib.syntax.EvalException; +import com.google.devtools.build.lib.syntax.EvalUtils; +import com.google.devtools.build.lib.syntax.FileOptions; +import com.google.devtools.build.lib.syntax.Module; +import com.google.devtools.build.lib.syntax.Mutability; +import com.google.devtools.build.lib.syntax.ParserInput; +import com.google.devtools.build.lib.syntax.StarlarkFile; +import com.google.devtools.build.lib.syntax.StarlarkList; +import com.google.devtools.build.lib.syntax.StarlarkThread; +import com.google.devtools.build.lib.syntax.SyntaxError; +import com.google.devtools.build.lib.syntax.Tuple; +import com.google.devtools.build.lib.testutil.MoreAsserts; +import com.google.devtools.build.lib.util.FileTypeSet; +import javax.annotation.Nullable; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** Tests for SkylarkRuleClassFunctions. */ +@RunWith(JUnit4.class) +public final class StarlarkRuleClassFunctionsTest extends StarlarkTestCase { + @Rule public ExpectedException thrown = ExpectedException.none(); + + @Before + public final void createBuildFile() throws Exception { + scratch.file( + "foo/BUILD", + "genrule(name = 'foo',", + " cmd = 'dummy_cmd',", + " srcs = ['a.txt', 'b.img'],", + " tools = ['t.exe'],", + " outs = ['c.txt'])", + "genrule(name = 'bar',", + " cmd = 'dummy_cmd',", + " srcs = [':jl', ':gl'],", + " outs = ['d.txt'])", + "java_library(name = 'jl',", + " srcs = ['a.java'])", + "genrule(name = 'gl',", + " cmd = 'touch $(OUTS)',", + " srcs = ['a.go'],", + " outs = [ 'gl.a', 'gl.gcgox', ],", + " output_to_bindir = 1,", + ")"); + } + + @Test + public void testCannotOverrideBuiltInAttribute() throws Exception { + ev.setFailFast(false); + evalAndExport( + "def impl(ctx):", + " return", + "r = rule(impl, attrs = {'tags': attr.string_list()})"); + ev.assertContainsError( + "There is already a built-in attribute 'tags' which cannot be overridden"); + } + + @Test + public void testCannotOverrideBuiltInAttributeName() throws Exception { + ev.setFailFast(false); + evalAndExport( + "def impl(ctx):", + " return", + "r = rule(impl, attrs = {'name': attr.string()})"); + ev.assertContainsError( + "There is already a built-in attribute 'name' which cannot be overridden"); + } + + @Test + public void testImplicitArgsAttribute() throws Exception { + ev.setFailFast(false); + evalAndExport( + "def _impl(ctx):", + " pass", + "exec_rule = rule(implementation = _impl, executable = True)", + "non_exec_rule = rule(implementation = _impl)"); + assertThat(getRuleClass("exec_rule").hasAttr("args", Type.STRING_LIST)).isTrue(); + assertThat(getRuleClass("non_exec_rule").hasAttr("args", Type.STRING_LIST)).isFalse(); + } + + private RuleClass getRuleClass(String name) throws Exception { + return ((StarlarkRuleFunction) lookup(name)).getRuleClass(); + } + + private void registerDummyStarlarkFunction() throws Exception { + exec("def impl():", " pass"); + } + + @Test + public void testAttrWithOnlyType() throws Exception { + Attribute attr = buildAttribute("a1", "attr.string_list()"); + assertThat(attr.getType()).isEqualTo(Type.STRING_LIST); + } + + private Attribute buildAttribute(String name, String... lines) throws Exception { + String[] strings = lines.clone(); + strings[strings.length - 1] = String.format("%s = %s", name, strings[strings.length - 1]); + evalAndExport(strings); + StarlarkAttrModule.Descriptor lookup = (StarlarkAttrModule.Descriptor) lookup(name); + return lookup != null ? lookup.build(name) : null; + } + + @Test + public void testOutputListAttr() throws Exception { + Attribute attr = buildAttribute("a1", "attr.output_list()"); + assertThat(attr.getType()).isEqualTo(BuildType.OUTPUT_LIST); + } + + @Test + public void testIntListAttr() throws Exception { + Attribute attr = buildAttribute("a1", "attr.int_list()"); + assertThat(attr.getType()).isEqualTo(Type.INTEGER_LIST); + } + + @Test + public void testOutputAttr() throws Exception { + Attribute attr = buildAttribute("a1", "attr.output()"); + assertThat(attr.getType()).isEqualTo(BuildType.OUTPUT); + } + + @Test + public void testStringDictAttr() throws Exception { + Attribute attr = buildAttribute("a1", "attr.string_dict(default = {'a': 'b'})"); + assertThat(attr.getType()).isEqualTo(Type.STRING_DICT); + } + + @Test + public void testStringListDictAttr() throws Exception { + Attribute attr = buildAttribute("a1", "attr.string_list_dict(default = {'a': ['b', 'c']})"); + assertThat(attr.getType()).isEqualTo(Type.STRING_LIST_DICT); + } + + @Test + public void testAttrAllowedFileTypesAnyFile() throws Exception { + Attribute attr = buildAttribute("a1", "attr.label_list(allow_files = True)"); + assertThat(attr.getAllowedFileTypesPredicate()).isEqualTo(FileTypeSet.ANY_FILE); + } + + @Test + public void testAttrAllowedFileTypesWrongType() throws Exception { + checkEvalErrorContains( + "allow_files should be a boolean or a string list", "attr.label_list(allow_files = 18)"); + } + + @Test + public void testAttrNameSpecialCharactersAreForbidden() throws Exception { + ev.setFailFast(false); + evalAndExport("def impl(ctx): return", "r = rule(impl, attrs = {'ab$c': attr.int()})"); + ev.assertContainsError("attribute name `ab$c` is not a valid identifier"); + } + + @Test + public void testAttrNameCannotStartWithDigit() throws Exception { + ev.setFailFast(false); + evalAndExport("def impl(ctx): return", "r = rule(impl, attrs = {'2_foo': attr.int()})"); + ev.assertContainsError("attribute name `2_foo` is not a valid identifier"); + } + + @Test + public void testRuleClassTooManyAttributes() throws Exception { + ev.setFailFast(false); + + ImmutableList.Builder<String> linesBuilder = + ImmutableList.<String>builder() + .add("def impl(ctx): return") + .add("r = rule(impl, attrs = {"); + for (int i = 0; i < 200; i++) { + linesBuilder.add(" 'attr" + i + "': attr.int(),"); + } + linesBuilder.add("})"); + + evalAndExport(linesBuilder.build().toArray(new String[0])); + + assertThat(ev.getEventCollector()).hasSize(1); + Event event = ev.getEventCollector().iterator().next(); + assertThat(event.getKind()).isEqualTo(EventKind.ERROR); + assertThat(event.getMessage()).contains("Rule class r declared too many attributes"); + } + + @Test + public void testRuleClassTooLongAttributeName() throws Exception { + ev.setFailFast(false); + + evalAndExport( + "def impl(ctx): return;", + "r = rule(impl, attrs = { '" + Strings.repeat("x", 150) + "': attr.int() })"); + + assertThat(ev.getEventCollector()).hasSize(1); + Event event = ev.getEventCollector().iterator().next(); + assertThat(event.getKind()).isEqualTo(EventKind.ERROR); + assertThat(event.getMessage()) + .matches("Attribute r\\.x{150}'s name is too long \\(150 > 128\\)"); + } + + @Test + public void testDisableDeprecatedParams() throws Exception { + setStarlarkSemanticsOptions("--incompatible_disable_deprecated_attr_params=true"); + + // Verify 'single_file' deprecation. + EvalException expected = + assertThrows(EvalException.class, () -> eval("attr.label(single_file = True)")); + assertThat(expected).hasMessageThat().contains( + "'single_file' is no longer supported. use allow_single_file instead."); + Attribute attr = buildAttribute("a1", "attr.label(allow_single_file = ['.xml'])"); + assertThat(attr.isSingleArtifact()).isTrue(); + + // Verify 'non_empty' deprecation. + expected = + assertThrows(EvalException.class, () -> eval("attr.string_list(non_empty=True)")); + assertThat(expected).hasMessageThat().contains( + "'non_empty' is no longer supported. use allow_empty instead."); + attr = buildAttribute("a2", "attr.string_list(allow_empty=False)"); + assertThat(attr.isNonEmpty()).isTrue(); + } + + @Test + public void testAttrAllowedSingleFileTypesWrongType() throws Exception { + checkEvalErrorContains( + "allow_single_file should be a boolean or a string list", + "attr.label(allow_single_file = 18)"); + } + + @Test + public void testAttrWithList() throws Exception { + Attribute attr = buildAttribute("a1", "attr.label_list(allow_files = ['.xml'])"); + assertThat(attr.getAllowedFileTypesPredicate().apply("a.xml")).isTrue(); + assertThat(attr.getAllowedFileTypesPredicate().apply("a.txt")).isFalse(); + assertThat(attr.isSingleArtifact()).isFalse(); + } + + @Test + public void testAttrSingleFileWithList() throws Exception { + Attribute attr = buildAttribute("a1", "attr.label(allow_single_file = ['.xml'])"); + assertThat(attr.getAllowedFileTypesPredicate().apply("a.xml")).isTrue(); + assertThat(attr.getAllowedFileTypesPredicate().apply("a.txt")).isFalse(); + assertThat(attr.isSingleArtifact()).isTrue(); + } + + private static StarlarkProviderIdentifier legacy(String legacyId) { + return StarlarkProviderIdentifier.forLegacy(legacyId); + } + + private static StarlarkProviderIdentifier declared(String exportedName) { + return StarlarkProviderIdentifier.forKey(new StarlarkProvider.Key(FAKE_LABEL, exportedName)); + } + + @Test + public void testAttrWithProviders() throws Exception { + Attribute attr = + buildAttribute("a1", + "b = provider()", + "attr.label_list(allow_files = True, providers = ['a', b])"); + assertThat(attr.getRequiredProviders().isSatisfiedBy(set(legacy("a"), declared("b")))).isTrue(); + assertThat(attr.getRequiredProviders().isSatisfiedBy(set(legacy("a")))).isFalse(); + } + + @Test + public void testAttrWithProvidersOneEmpty() throws Exception { + Attribute attr = + buildAttribute( + "a1", + "b = provider()", + "attr.label_list(allow_files = True, providers = [['a', b],[]])"); + assertThat(attr.getRequiredProviders().acceptsAny()).isTrue(); + } + + @Test + public void testAttrWithProvidersList() throws Exception { + Attribute attr = + buildAttribute("a1", + "b = provider()", + "attr.label_list(allow_files = True, providers = [['a', b], ['c']])"); + assertThat(attr.getRequiredProviders().isSatisfiedBy(set(legacy("a"), declared("b")))).isTrue(); + assertThat(attr.getRequiredProviders().isSatisfiedBy(set(legacy("c")))).isTrue(); + assertThat(attr.getRequiredProviders().isSatisfiedBy(set(legacy("a")))).isFalse(); + } + + private static AdvertisedProviderSet set(StarlarkProviderIdentifier... ids) { + AdvertisedProviderSet.Builder builder = AdvertisedProviderSet.builder(); + for (StarlarkProviderIdentifier id : ids) { + builder.addSkylark(id); + } + return builder.build(); + } + + private void checkAttributeError(String expectedMessage, String... lines) throws Exception { + ev.setFailFast(false); + buildAttribute("fakeAttribute", lines); + MoreAsserts.assertContainsEvent(ev.getEventCollector(), expectedMessage); + } + + @Test + public void testAttrWithWrongProvidersList() throws Exception { + checkAttributeError( + "element in 'providers' is of unexpected type. Either all elements should be providers," + + " or all elements should be lists of providers," + + " but got list with an element of type int.", + "attr.label_list(allow_files = True, providers = [['a', 1], ['c']])"); + + checkAttributeError( + "element in 'providers' is of unexpected type. Either all elements should be providers," + + " or all elements should be lists of providers," + + " but got an element of type string.", + "b = provider()", + "attr.label_list(allow_files = True, providers = [['a', b], 'c'])"); + + checkAttributeError( + "element in 'providers' is of unexpected type. Either all elements should be providers," + + " or all elements should be lists of providers," + + " but got an element of type string.", + "c = provider()", + "attr.label_list(allow_files = True, providers = [['a', b], c])"); + } + + @Test + public void testLabelListWithAspects() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(implementation = _impl)", + "a = attr.label_list(aspects = [my_aspect])"); + StarlarkAttrModule.Descriptor attr = (StarlarkAttrModule.Descriptor) lookup("a"); + StarlarkDefinedAspect aspect = (StarlarkDefinedAspect) lookup("my_aspect"); + assertThat(aspect).isNotNull(); + assertThat(attr.build("xxx").getAspectClasses()).containsExactly(aspect.getAspectClass()); + } + + @Test + public void testLabelWithAspects() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(implementation = _impl)", + "a = attr.label(aspects = [my_aspect])"); + StarlarkAttrModule.Descriptor attr = (StarlarkAttrModule.Descriptor) lookup("a"); + StarlarkDefinedAspect aspect = (StarlarkDefinedAspect) lookup("my_aspect"); + assertThat(aspect).isNotNull(); + assertThat(attr.build("xxx").getAspectClasses()).containsExactly(aspect.getAspectClass()); + } + + @Test + public void testLabelListWithAspectsError() throws Exception { + checkEvalErrorContains( + "at index 0 of aspects, got element of type int, want Aspect", + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(implementation = _impl)", + "attr.label_list(aspects = [my_aspect, 123])"); + } + + @Test + public void testAspectExtraDeps() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl,", + " attrs = { '_extra_deps' : attr.label(default = Label('//foo/bar:baz')) }", + ")"); + StarlarkDefinedAspect aspect = (StarlarkDefinedAspect) lookup("my_aspect"); + Attribute attribute = Iterables.getOnlyElement(aspect.getAttributes()); + assertThat(attribute.getName()).isEqualTo("$extra_deps"); + assertThat(attribute.getDefaultValue(null)) + .isEqualTo( + Label.parseAbsolute( + "//foo/bar:baz", + /* defaultToMain= */ false, + /* repositoryMapping= */ ImmutableMap.of())); + } + + @Test + public void testAspectParameter() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl,", + " attrs = { 'param' : attr.string(values=['a', 'b']) }", + ")"); + StarlarkDefinedAspect aspect = (StarlarkDefinedAspect) lookup("my_aspect"); + Attribute attribute = Iterables.getOnlyElement(aspect.getAttributes()); + assertThat(attribute.getName()).isEqualTo("param"); + } + + @Test + public void testAspectParameterRequiresValues() throws Exception { + checkEvalErrorContains( + "Aspect parameter attribute 'param' must have type 'string' and use the 'values' " + + "restriction.", + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl,", + " attrs = { 'param' : attr.string(default = 'c') }", + ")"); + } + + @Test + public void testAspectParameterBadType() throws Exception { + checkEvalErrorContains( + "Aspect parameter attribute 'param' must have type 'string' and use the 'values' " + + "restriction.", + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl,", + " attrs = { 'param' : attr.label(default = Label('//foo/bar:baz')) }", + ")"); + } + + @Test + public void testAspectParameterAndExtraDeps() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl,", + " attrs = { 'param' : attr.string(values=['a', 'b']),", + " '_extra' : attr.label(default = Label('//foo/bar:baz')) }", + ")"); + StarlarkDefinedAspect aspect = (StarlarkDefinedAspect) lookup("my_aspect"); + assertThat(aspect.getAttributes()).hasSize(2); + assertThat(aspect.getParamAttributes()).containsExactly("param"); + } + + @Test + public void testAspectNoDefaultValueAttribute() throws Exception { + checkEvalErrorContains( + "Aspect attribute '_extra_deps' has no default value", + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl,", + " attrs = { '_extra_deps' : attr.label() }", + ")"); + } + + @Test + public void testAspectAddToolchain() throws Exception { + scratch.file("test/BUILD", "toolchain_type(name = 'my_toolchain_type')"); + evalAndExport( + "def _impl(ctx): pass", "a1 = aspect(_impl, toolchains=['//test:my_toolchain_type'])"); + StarlarkDefinedAspect a = (StarlarkDefinedAspect) lookup("a1"); + assertThat(a.getRequiredToolchains()).containsExactly(makeLabel("//test:my_toolchain_type")); + } + + @Test + public void testNonLabelAttrWithProviders() throws Exception { + checkEvalErrorContains( + "unexpected keyword argument 'providers'", "attr.string(providers = ['a'])"); + } + + private static final RuleClass.ConfiguredTargetFactory<Object, Object, Exception> + DUMMY_CONFIGURED_TARGET_FACTORY = + ruleContext -> { + throw new IllegalStateException(); + }; + + private RuleClass ruleClass(String name) { + return new RuleClass.Builder(name, RuleClassType.NORMAL, false) + .factory(DUMMY_CONFIGURED_TARGET_FACTORY) + .add(Attribute.attr("tags", Type.STRING_LIST)) + .build(); + } + + @Test + public void testAttrAllowedRuleClassesSpecificRuleClasses() throws Exception { + Attribute attr = buildAttribute("a", + "attr.label_list(allow_rules = ['java_binary'], allow_files = True)"); + assertThat(attr.getAllowedRuleClassesPredicate().apply(ruleClass("java_binary"))).isTrue(); + assertThat(attr.getAllowedRuleClassesPredicate().apply(ruleClass("genrule"))).isFalse(); + } + + @Test + public void testAttrDefaultValue() throws Exception { + Attribute attr = buildAttribute("a1", "attr.string(default = 'some value')"); + assertThat(attr.getDefaultValueUnchecked()).isEqualTo("some value"); + } + + @Test + public void testLabelAttrDefaultValueAsString() throws Exception { + Attribute sligleAttr = buildAttribute("a1", "attr.label(default = '//foo:bar')"); + assertThat(sligleAttr.getDefaultValueUnchecked()) + .isEqualTo( + Label.parseAbsolute( + "//foo:bar", + /* defaultToMain= */ false, + /* repositoryMapping= */ ImmutableMap.of())); + + Attribute listAttr = + buildAttribute("a2", "attr.label_list(default = ['//foo:bar', '//bar:foo'])"); + assertThat(listAttr.getDefaultValueUnchecked()) + .isEqualTo( + ImmutableList.of( + Label.parseAbsolute( + "//foo:bar", + /* defaultToMain= */ false, + /* repositoryMapping= */ ImmutableMap.of()), + Label.parseAbsolute( + "//bar:foo", + /* defaultToMain= */ false, + /*repositoryMapping= */ ImmutableMap.of()))); + + Attribute dictAttr = + buildAttribute("a3", "attr.label_keyed_string_dict(default = {'//foo:bar': 'my value'})"); + assertThat(dictAttr.getDefaultValueUnchecked()) + .isEqualTo( + ImmutableMap.of( + Label.parseAbsolute( + "//foo:bar", + /* defaultToMain= */ false, + /* repositoryMapping= */ ImmutableMap.of()), + "my value")); + } + + @Test + public void testLabelAttrDefaultValueAsStringBadValue() throws Exception { + checkEvalErrorContains( + "invalid label '/foo:bar' in parameter 'default' of attribute 'label': " + + "invalid target name '/foo:bar'", + "attr.label(default = '/foo:bar')"); + + checkEvalErrorContains( + "invalid label '/bar:foo' in element 1 of parameter 'default' of attribute " + + "'label_list': invalid target name '/bar:foo'", + "attr.label_list(default = ['//foo:bar', '/bar:foo'])"); + + checkEvalErrorContains( + "invalid label '/bar:foo' in dict key element: invalid target name '/bar:foo'", + "attr.label_keyed_string_dict(default = {'//foo:bar': 'a', '/bar:foo': 'b'})"); + } + + @Test + public void testAttrDefaultValueBadType() throws Exception { + checkEvalErrorContains("got value of type 'int', want 'string'", "attr.string(default = 1)"); + } + + @Test + public void testAttrMandatory() throws Exception { + Attribute attr = buildAttribute("a1", "attr.string(mandatory=True)"); + assertThat(attr.isMandatory()).isTrue(); + assertThat(attr.isNonEmpty()).isFalse(); + } + + @Test + public void testAttrNonEmpty() throws Exception { + setStarlarkSemanticsOptions("--incompatible_disable_deprecated_attr_params=false"); + reset(); + + Attribute attr = buildAttribute("a1", "attr.string_list(non_empty=True)"); + assertThat(attr.isNonEmpty()).isTrue(); + assertThat(attr.isMandatory()).isFalse(); + } + + @Test + public void testAttrAllowEmpty() throws Exception { + Attribute attr = buildAttribute("a1", "attr.string_list(allow_empty=False)"); + assertThat(attr.isNonEmpty()).isTrue(); + assertThat(attr.isMandatory()).isFalse(); + } + + @Test + public void testAttrBadKeywordArguments() throws Exception { + checkEvalErrorContains( + "string() got unexpected keyword argument 'bad_keyword'", "attr.string(bad_keyword = '')"); + } + + @Test + public void testAttrCfg() throws Exception { + Attribute attr = buildAttribute("a1", "attr.label(cfg = 'host', allow_files = True)"); + assertThat(attr.getTransitionFactory().isHost()).isTrue(); + } + + @Test + public void testAttrCfgTarget() throws Exception { + Attribute attr = buildAttribute("a1", "attr.label(cfg = 'target', allow_files = True)"); + assertThat(NoTransition.isInstance(attr.getTransitionFactory())).isTrue(); + } + + @Test + public void incompatibleDataTransition() throws Exception { + EvalException expected = + assertThrows(EvalException.class, () -> eval("attr.label(cfg = 'data')")); + assertThat(expected).hasMessageThat().contains("cfg must be either 'host' or 'target'"); + } + + @Test + public void testAttrValues() throws Exception { + Attribute attr = buildAttribute("a1", "attr.string(values = ['ab', 'cd'])"); + PredicateWithMessage<Object> predicate = attr.getAllowedValues(); + assertThat(predicate.apply("ab")).isTrue(); + assertThat(predicate.apply("xy")).isFalse(); + } + + @Test + public void testAttrIntValues() throws Exception { + Attribute attr = buildAttribute("a1", "attr.int(values = [1, 2])"); + PredicateWithMessage<Object> predicate = attr.getAllowedValues(); + assertThat(predicate.apply(2)).isTrue(); + assertThat(predicate.apply(3)).isFalse(); + } + + @Test + public void testAttrDoc() throws Exception { + // We don't actually store the doc in the attr definition; right now it's just meant to be + // extracted by documentation generating tools. So we don't have anything to assert and we just + // verify that no exceptions were thrown from building them. + buildAttribute("a1", "attr.bool(doc='foo')"); + buildAttribute("a2", "attr.int(doc='foo')"); + buildAttribute("a3", "attr.int_list(doc='foo')"); + buildAttribute("a4", "attr.label(doc='foo')"); + buildAttribute("a5", "attr.label_keyed_string_dict(doc='foo')"); + buildAttribute("a6", "attr.label_list(doc='foo')"); + buildAttribute("a8", "attr.output(doc='foo')"); + buildAttribute("a9", "attr.output_list(doc='foo')"); + buildAttribute("a10", "attr.string(doc='foo')"); + buildAttribute("a11", "attr.string_dict(doc='foo')"); + buildAttribute("a12", "attr.string_list(doc='foo')"); + buildAttribute("a13", "attr.string_list_dict(doc='foo')"); + } + + @Test + public void testNoAttrLicense() throws Exception { + EvalException expected = assertThrows(EvalException.class, () -> eval("attr.license()")); + assertThat(expected) + .hasMessageThat() + .contains("'attr (a language module)' value has no field or method 'license'"); + } + + @Test + public void testAttrDocValueBadType() throws Exception { + checkEvalErrorContains("got value of type 'int', want 'string'", "attr.string(doc = 1)"); + } + + @Test + public void testRuleImplementation() throws Exception { + evalAndExport("def impl(ctx): return None", "rule1 = rule(impl)"); + RuleClass c = ((StarlarkRuleFunction) lookup("rule1")).getRuleClass(); + assertThat(c.getConfiguredTargetFunction().getName()).isEqualTo("impl"); + } + + @Test + public void testRuleDoc() throws Exception { + evalAndExport("def impl(ctx): return None", "rule1 = rule(impl, doc='foo')"); + } + + @Test + public void testFunctionAsAttrDefault() throws Exception { + exec("def f(): pass"); + + // Late-bound attributes, which are computed during analysis as a function + // of the configuration, are only available for attributes involving labels: + // attr.label + // attr.label_list + // attr.label_keyed_string_dict + // attr.output, + // attr.output_list + // (See testRuleClassImplicitOutputFunctionDependingOnComputedAttribute + // for a more detailed positive test.) + evalAndExport( + "attr.label(default=f)", + "attr.label_list(default=f)", + "attr.label_keyed_string_dict(default=f)"); + // Note: the default parameter of attr.output{,_list} is deprecated + // (see --incompatible_no_output_attr_default) + + // For all other attribute types, the default value may not be a function. + // + // (This is a regression test for github.com/bazelbuild/bazel/issues/9463. + // The loading-phase feature of "computed attribute defaults" is not exposed + // to Starlark; the bug was that the @SkylarkCallable + // annotation was more permissive than the method declaration.) + checkEvalErrorContains("got value of type 'function', want 'string'", "attr.string(default=f)"); + checkEvalErrorContains( + "got value of type 'function', want 'sequence'", "attr.string_list(default=f)"); + checkEvalErrorContains("got value of type 'function', want 'int'", "attr.int(default=f)"); + checkEvalErrorContains( + "got value of type 'function', want 'sequence'", "attr.int_list(default=f)"); + checkEvalErrorContains("got value of type 'function', want 'bool'", "attr.bool(default=f)"); + checkEvalErrorContains( + "got value of type 'function', want 'dict'", "attr.string_dict(default=f)"); + checkEvalErrorContains( + "got value of type 'function', want 'dict'", "attr.string_list_dict(default=f)"); + // Note: attr.license appears to be disabled already. + // (see --incompatible_no_attr_license) + } + + private static final Label FAKE_LABEL = Label.parseAbsoluteUnchecked("//fake/label.bzl"); + + @Test + public void testRuleAddAttribute() throws Exception { + evalAndExport("def impl(ctx): return None", "r1 = rule(impl, attrs={'a1': attr.string()})"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + assertThat(c.hasAttr("a1", Type.STRING)).isTrue(); + } + + private void evalAndExport(String... lines) throws Exception { + ParserInput input = ParserInput.fromLines(lines); + StarlarkThread thread = ev.getStarlarkThread(); + Module module = thread.getGlobals(); + StarlarkFile file = EvalUtils.parseAndValidate(input, FileOptions.DEFAULT, module); + if (!file.ok()) { + throw new SyntaxError.Exception(file.errors()); + } + StarlarkImportLookupFunction.execAndExport(file, FAKE_LABEL, ev.getEventHandler(), thread); + } + + @Test + public void testExportAliasedName() throws Exception { + // When there are multiple names aliasing the same SkylarkExportable, the first one to be + // declared should be used. Make sure we're not using lexicographical order, hash order, + // non-deterministic order, or anything else. + evalAndExport( + "def _impl(ctx): pass", + "d = rule(implementation = _impl)", + "a = d", + // Having more names improves the chance that non-determinism will be caught. + "b = d", + "c = d", + "e = d", + "f = d", + "foo = d", + "bar = d", + "baz = d", + "x = d", + "y = d", + "z = d"); + String dName = ((StarlarkRuleFunction) lookup("d")).getRuleClass().getName(); + String fooName = ((StarlarkRuleFunction) lookup("foo")).getRuleClass().getName(); + assertThat(dName).isEqualTo("d"); + assertThat(fooName).isEqualTo("d"); + } + + @Test + public void testOutputToGenfiles() throws Exception { + evalAndExport("def impl(ctx): pass", "r1 = rule(impl, output_to_genfiles=True)"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + assertThat(c.hasBinaryOutput()).isFalse(); + } + + @Test + public void testRuleAddMultipleAttributes() throws Exception { + evalAndExport( + "def impl(ctx): return None", + "r1 = rule(impl,", + " attrs = {", + " 'a1': attr.label_list(allow_files=True),", + " 'a2': attr.int()", + "})"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + assertThat(c.hasAttr("a1", BuildType.LABEL_LIST)).isTrue(); + assertThat(c.hasAttr("a2", Type.INTEGER)).isTrue(); + } + + @Test + public void testRuleAttributeFlag() throws Exception { + evalAndExport( + "def impl(ctx): return None", + "r1 = rule(impl, attrs = {'a1': attr.string(mandatory=True)})"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + assertThat(c.getAttributeByName("a1").isMandatory()).isTrue(); + } + + @Test + public void testRuleOutputs() throws Exception { + evalAndExport( + "def impl(ctx): return None", + "r1 = rule(impl, outputs = {'a': 'a.txt'})"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + ImplicitOutputsFunction function = c.getDefaultImplicitOutputsFunction(); + assertThat(function.getImplicitOutputs(ev.getEventHandler(), null)).containsExactly("a.txt"); + } + + @Test + public void testRuleUnknownKeyword() throws Exception { + registerDummyStarlarkFunction(); + checkEvalErrorContains( + "unexpected keyword argument 'bad_keyword'", "rule(impl, bad_keyword = 'some text')"); + } + + @Test + public void testRuleImplementationMissing() throws Exception { + checkEvalErrorContains( + "rule() missing 1 required positional argument: implementation", "rule(attrs = {})"); + } + + @Test + public void testRuleBadTypeForAdd() throws Exception { + registerDummyStarlarkFunction(); + checkEvalErrorContains( + "in call to rule(), parameter 'attrs' got value of type 'string', want 'dict or NoneType'", + "rule(impl, attrs = 'some text')"); + } + + @Test + public void testRuleBadTypeInAdd() throws Exception { + registerDummyStarlarkFunction(); + checkEvalErrorContains( + "got dict<string, string> for 'attrs', want dict<string, Attribute>", + "rule(impl, attrs = {'a1': 'some text'})"); + } + + @Test + public void testRuleBadTypeForDoc() throws Exception { + registerDummyStarlarkFunction(); + checkEvalErrorContains("got value of type 'int', want 'string'", "rule(impl, doc = 1)"); + } + + @Test + public void testLabel() throws Exception { + Object result = eval("Label('//foo/foo:foo')"); + assertThat(result).isInstanceOf(Label.class); + assertThat(result.toString()).isEqualTo("//foo/foo:foo"); + } + + @Test + public void testLabelSameInstance() throws Exception { + Object l1 = eval("Label('//foo/foo:foo')"); + // Implicitly creates a new pkgContext and environment, yet labels should be the same. + Object l2 = eval("Label('//foo/foo:foo')"); + assertThat(l1).isSameInstanceAs(l2); + } + + @Test + public void testLabelNameAndPackage() throws Exception { + Object result = eval("Label('//foo/bar:baz').name"); + assertThat(result).isEqualTo("baz"); + // NB: implicitly creates a new pkgContext and environments, yet labels should be the same. + result = eval("Label('//foo/bar:baz').package"); + assertThat(result).isEqualTo("foo/bar"); + } + + @Test + public void testRuleLabelDefaultValue() throws Exception { + evalAndExport( + "def impl(ctx): return None\n" + + "r1 = rule(impl, attrs = {'a1': " + + "attr.label(default = Label('//foo:foo'), allow_files=True)})"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + Attribute a = c.getAttributeByName("a1"); + assertThat(a.getDefaultValueUnchecked()).isInstanceOf(Label.class); + assertThat(a.getDefaultValueUnchecked().toString()).isEqualTo("//foo:foo"); + } + + @Test + public void testIntDefaultValue() throws Exception { + evalAndExport( + "def impl(ctx): return None", + "r1 = rule(impl, attrs = {'a1': attr.int(default = 40+2)})"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + Attribute a = c.getAttributeByName("a1"); + assertThat(a.getDefaultValueUnchecked()).isEqualTo(42); + } + + @Test + public void testRuleInheritsBaseRuleAttributes() throws Exception { + evalAndExport("def impl(ctx): return None", "r1 = rule(impl)"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + assertThat(c.hasAttr("tags", Type.STRING_LIST)).isTrue(); + assertThat(c.hasAttr("visibility", BuildType.NODEP_LABEL_LIST)).isTrue(); + assertThat(c.hasAttr("deprecation", Type.STRING)).isTrue(); + assertThat(c.hasAttr(":action_listener", BuildType.LABEL_LIST)) + .isTrue(); // required for extra actions + } + + private void checkTextMessage(String from, String... lines) throws Exception { + String[] strings = lines.clone(); + Object result = eval(from); + String expect = ""; + if (strings.length > 0) { + expect = Joiner.on("\n").join(lines) + "\n"; + } + assertThat(result).isEqualTo(expect); + } + + @Test + public void testSimpleTextMessagesBooleanFields() throws Exception { + checkTextMessage("struct(name=True).to_proto()", "name: true"); + checkTextMessage("struct(name=False).to_proto()", "name: false"); + } + + @Test + public void testStructRestrictedOverrides() throws Exception { + checkEvalErrorContains( + "cannot override built-in struct function 'to_json'", "struct(to_json='foo')"); + + checkEvalErrorContains( + "cannot override built-in struct function 'to_proto'", "struct(to_proto='foo')"); + } + + @Test + public void testSimpleTextMessages() throws Exception { + checkTextMessage("struct(name='value').to_proto()", "name: \"value\""); + checkTextMessage("struct(name=[]).to_proto()"); // empty lines + checkTextMessage("struct(name=['a', 'b']).to_proto()", "name: \"a\"", "name: \"b\""); + checkTextMessage("struct(name=123).to_proto()", "name: 123"); + checkTextMessage("struct(name=[1, 2, 3]).to_proto()", "name: 1", "name: 2", "name: 3"); + checkTextMessage("struct(a=struct(b='b')).to_proto()", "a {", " b: \"b\"", "}"); + checkTextMessage( + "struct(a=[struct(b='x'), struct(b='y')]).to_proto()", + "a {", + " b: \"x\"", + "}", + "a {", + " b: \"y\"", + "}"); + checkTextMessage( + "struct(a=struct(b=struct(c='c'))).to_proto()", "a {", " b {", " c: \"c\"", " }", "}"); + // dict to_proto tests + checkTextMessage("struct(name={}).to_proto()"); // empty lines + checkTextMessage( + "struct(name={'a': 'b'}).to_proto()", "name {", " key: \"a\"", " value: \"b\"", "}"); + checkTextMessage( + "struct(name={'c': 'd', 'a': 'b'}).to_proto()", + "name {", + " key: \"c\"", + " value: \"d\"", + "}", + "name {", + " key: \"a\"", + " value: \"b\"", + "}"); + checkTextMessage( + "struct(x=struct(y={'a': 1})).to_proto()", + "x {", + " y {", + " key: \"a\"", + " value: 1", + " }", + "}"); + checkTextMessage( + "struct(name={'a': struct(b=1, c=2)}).to_proto()", + "name {", + " key: \"a\"", + " value {", + " b: 1", + " c: 2", + " }", + "}"); + checkTextMessage( + "struct(name={'a': struct(b={4: 'z', 3: 'y'}, c=2)}).to_proto()", + "name {", + " key: \"a\"", + " value {", + " b {", + " key: 4", + " value: \"z\"", + " }", + " b {", + " key: 3", + " value: \"y\"", + " }", + " c: 2", + " }", + "}"); + } + + @Test + public void testProtoFieldsOrder() throws Exception { + checkTextMessage("struct(d=4, b=2, c=3, a=1).to_proto()", "a: 1", "b: 2", "c: 3", "d: 4"); + } + + @Test + public void testTextMessageEscapes() throws Exception { + checkTextMessage("struct(name='a\"b').to_proto()", "name: \"a\\\"b\""); + checkTextMessage("struct(name='a\\'b').to_proto()", "name: \"a'b\""); + checkTextMessage("struct(name='a\\nb').to_proto()", "name: \"a\\nb\""); + + // struct(name="a\\\"b") -> name: "a\\\"b" + checkTextMessage("struct(name='a\\\\\\\"b').to_proto()", "name: \"a\\\\\\\"b\""); + } + + @Test + public void testTextMessageInvalidElementInListStructure() throws Exception { + checkEvalErrorContains( + "Invalid text format, expected a struct, a dict, a string, a bool, or " + + "an int but got a list for list element in struct field 'a'", + "struct(a=[['b']]).to_proto()"); + } + + @Test + public void testTextMessageInvalidStructure() throws Exception { + checkEvalErrorContains( + "Invalid text format, expected a struct, a dict, a string, a bool, or an int " + + "but got a function for struct field 'a'", + "struct(a=rule).to_proto()"); + } + + private void checkJson(String from, String expected) throws Exception { + Object result = eval(from); + assertThat(result).isEqualTo(expected); + } + + @Test + public void testJsonBooleanFields() throws Exception { + checkJson("struct(name=True).to_json()", "{\"name\":true}"); + checkJson("struct(name=False).to_json()", "{\"name\":false}"); + } + + @Test + public void testJsonDictFields() throws Exception { + checkJson("struct(config={}).to_json()", "{\"config\":{}}"); + checkJson("struct(config={'key': 'value'}).to_json()", "{\"config\":{\"key\":\"value\"}}"); + checkEvalErrorContains( + "Keys must be a string but got a int for struct field 'config'", + "struct(config={1:2}).to_json()"); + checkEvalErrorContains( + "Keys must be a string but got a int for dict value 'foo'", + "struct(config={'foo':{1:2}}).to_json()"); + checkEvalErrorContains( + "Keys must be a string but got a bool for struct field 'config'", + "struct(config={True: False}).to_json()"); + } + + @Test + public void testJsonEncoding() throws Exception { + checkJson("struct(name='value').to_json()", "{\"name\":\"value\"}"); + checkJson("struct(name=['a', 'b']).to_json()", "{\"name\":[\"a\",\"b\"]}"); + checkJson("struct(name=123).to_json()", "{\"name\":123}"); + checkJson("struct(name=[1, 2, 3]).to_json()", "{\"name\":[1,2,3]}"); + checkJson("struct(a=struct(b='b')).to_json()", "{\"a\":{\"b\":\"b\"}}"); + checkJson("struct(a=[struct(b='x'), struct(b='y')]).to_json()", + "{\"a\":[{\"b\":\"x\"},{\"b\":\"y\"}]}"); + checkJson("struct(a=struct(b=struct(c='c'))).to_json()", + "{\"a\":{\"b\":{\"c\":\"c\"}}}"); + } + + @Test + public void testJsonEscapes() throws Exception { + checkJson("struct(name='a\"b').to_json()", "{\"name\":\"a\\\"b\"}"); + checkJson("struct(name='a\\'b').to_json()", "{\"name\":\"a'b\"}"); + checkJson("struct(name='a\\\\b').to_json()", "{\"name\":\"a\\\\b\"}"); + checkJson("struct(name='a\\nb').to_json()", "{\"name\":\"a\\nb\"}"); + checkJson("struct(name='a\\rb').to_json()", "{\"name\":\"a\\rb\"}"); + checkJson("struct(name='a\\tb').to_json()", "{\"name\":\"a\\tb\"}"); + } + + @Test + public void testJsonNestedListStructure() throws Exception { + checkJson("struct(a=[['b']]).to_json()", "{\"a\":[[\"b\"]]}"); + } + + @Test + public void testJsonInvalidStructure() throws Exception { + checkEvalErrorContains( + "Invalid text format, expected a struct, a string, a bool, or an int but got a " + + "function for struct field 'a'", + "struct(a=rule).to_json()"); + } + + @Test + public void testLabelAttrWrongDefault() throws Exception { + checkEvalErrorContains( + "got value of type 'int', want 'Label or string or LateBoundDefault or function or" + + " NoneType'", + "attr.label(default = 123)"); + } + + @Test + public void testLabelGetRelative() throws Exception { + assertThat(eval("Label('//foo:bar').relative('baz')").toString()).isEqualTo("//foo:baz"); + assertThat(eval("Label('//foo:bar').relative('//baz:qux')").toString()).isEqualTo("//baz:qux"); + } + + @Test + public void testLabelGetRelativeSyntaxError() throws Exception { + checkEvalErrorContains( + "invalid target name 'bad//syntax': target names may not contain '//' path separators", + "Label('//foo:bar').relative('bad//syntax')"); + } + + @Test + public void testStructCreation() throws Exception { + // TODO(fwe): cannot be handled by current testing suite + exec("x = struct(a = 1, b = 2)"); + assertThat(lookup("x")).isInstanceOf(ClassObject.class); + } + + @Test + public void testStructFields() throws Exception { + // TODO(fwe): cannot be handled by current testing suite + exec("x = struct(a = 1, b = 2)"); + ClassObject x = (ClassObject) lookup("x"); + assertThat(x.getValue("a")).isEqualTo(1); + assertThat(x.getValue("b")).isEqualTo(2); + } + + @Test + public void testStructEquality() throws Exception { + assertThat((Boolean) eval("struct(a = 1, b = 2) == struct(b = 2, a = 1)")).isTrue(); + assertThat((Boolean) eval("struct(a = 1) == struct(a = 1, b = 2)")).isFalse(); + assertThat((Boolean) eval("struct(a = 1, b = 2) == struct(a = 1)")).isFalse(); + // Compare a recursive object to itself to make sure reference equality is checked + exec("s = struct(a = 1, b = []); s.b.append(s)"); + assertThat((Boolean) eval("s == s")).isTrue(); + assertThat((Boolean) eval("struct(a = 1, b = 2) == struct(a = 1, b = 3)")).isFalse(); + assertThat((Boolean) eval("struct(a = 1) == [1]")).isFalse(); + assertThat((Boolean) eval("[1] == struct(a = 1)")).isFalse(); + assertThat((Boolean) eval("struct() == struct()")).isTrue(); + assertThat((Boolean) eval("struct() == struct(a = 1)")).isFalse(); + + exec("foo = provider(); bar = provider()"); + assertThat((Boolean) eval("struct(a = 1) == foo(a = 1)")).isFalse(); + assertThat((Boolean) eval("foo(a = 1) == struct(a = 1)")).isFalse(); + assertThat((Boolean) eval("foo(a = 1) == bar(a = 1)")).isFalse(); + assertThat((Boolean) eval("foo(a = 1) == foo(a = 1)")).isTrue(); + } + + @Test + public void testStructIncomparability() throws Exception { + checkEvalErrorContains("Cannot compare structs", "struct(a = 1) < struct(a = 2)"); + checkEvalErrorContains("Cannot compare structs", "struct(a = 1) > struct(a = 2)"); + checkEvalErrorContains("Cannot compare structs", "struct(a = 1) <= struct(a = 2)"); + checkEvalErrorContains("Cannot compare structs", "struct(a = 1) >= struct(a = 2)"); + } + + @Test + public void testStructAccessingFieldsFromStarlark() throws Exception { + exec("x = struct(a = 1, b = 2)", "x1 = x.a", "x2 = x.b"); + assertThat(lookup("x1")).isEqualTo(1); + assertThat(lookup("x2")).isEqualTo(2); + } + + @Test + public void testStructAccessingUnknownField() throws Exception { + checkEvalErrorContains( + "'struct' value has no field or method 'c'\n" + "Available attributes: a, b", + "x = struct(a = 1, b = 2)", + "y = x.c"); + } + + @Test + public void testStructAccessingUnknownFieldWithArgs() throws Exception { + checkEvalErrorContains( + "'struct' value has no field or method 'c'", "x = struct(a = 1, b = 2)", "y = x.c()"); + } + + @Test + public void testStructAccessingNonFunctionFieldWithArgs() throws Exception { + checkEvalErrorContains( + "'int' object is not callable", "x = struct(a = 1, b = 2)", "x1 = x.a(1)"); + } + + @Test + public void testStructAccessingFunctionFieldWithArgs() throws Exception { + exec("def f(x): return x+5", "x = struct(a = f, b = 2)", "x1 = x.a(1)"); + assertThat(lookup("x1")).isEqualTo(6); + } + + @Test + public void testStructPosArgs() throws Exception { + checkEvalErrorContains("struct() got unexpected positional argument", "x = struct(1, b = 2)"); + } + + @Test + public void testStructConcatenationFieldNames() throws Exception { + // TODO(fwe): cannot be handled by current testing suite + exec( + "x = struct(a = 1, b = 2)", // + "y = struct(c = 1, d = 2)", + "z = x + y\n"); + StructImpl z = (StructImpl) lookup("z"); + assertThat(z.getFieldNames()).containsExactly("a", "b", "c", "d"); + } + + @Test + public void testStructConcatenationFieldValues() throws Exception { + // TODO(fwe): cannot be handled by current testing suite + exec( + "x = struct(a = 1, b = 2)", // + "y = struct(c = 1, d = 2)", + "z = x + y\n"); + StructImpl z = (StructImpl) lookup("z"); + assertThat(z.getValue("a")).isEqualTo(1); + assertThat(z.getValue("b")).isEqualTo(2); + assertThat(z.getValue("c")).isEqualTo(1); + assertThat(z.getValue("d")).isEqualTo(2); + } + + @Test + public void testStructConcatenationCommonFields() throws Exception { + checkEvalErrorContains( + "cannot add struct instances with common field 'a'", + "x = struct(a = 1, b = 2)", + "y = struct(c = 1, a = 2)", + "z = x + y\n"); + } + + @Test + public void testConditionalStructConcatenation() throws Exception { + // TODO(fwe): cannot be handled by current testing suite + exec( + "def func():", + " x = struct(a = 1, b = 2)", + " if True:", + " x += struct(c = 1, d = 2)", + " return x", + "x = func()"); + StructImpl x = (StructImpl) lookup("x"); + assertThat(x.getValue("a")).isEqualTo(1); + assertThat(x.getValue("b")).isEqualTo(2); + assertThat(x.getValue("c")).isEqualTo(1); + assertThat(x.getValue("d")).isEqualTo(2); + } + + @Test + public void testGetattrNoAttr() throws Exception { + checkEvalErrorContains( + "'struct' value has no field or method 'b'\nAvailable attributes: a", + "s = struct(a='val')", + "getattr(s, 'b')"); + } + + @Test + public void testGetattr() throws Exception { + exec("s = struct(a='val')", "x = getattr(s, 'a')", "y = getattr(s, 'b', 'def')"); + assertThat(lookup("x")).isEqualTo("val"); + assertThat(lookup("y")).isEqualTo("def"); + } + + @Test + public void testHasattr() throws Exception { + exec( + "s = struct(a=1)", // + "x = hasattr(s, 'a')", + "y = hasattr(s, 'b')\n"); + assertThat(lookup("x")).isEqualTo(true); + assertThat(lookup("y")).isEqualTo(false); + } + + @Test + public void testStructStr() throws Exception { + assertThat(eval("str(struct(x = 2, y = 3, z = 4))")) + .isEqualTo("struct(x = 2, y = 3, z = 4)"); + } + + @Test + public void testStructsInSets() throws Exception { + exec("depset([struct(a='a')])"); + } + + @Test + public void testStructsInDicts() throws Exception { + exec("d = {struct(a = 1): 'aa', struct(b = 2): 'bb'}"); + assertThat(eval("d[struct(a = 1)]")).isEqualTo("aa"); + assertThat(eval("d[struct(b = 2)]")).isEqualTo("bb"); + assertThat(eval("str([d[k] for k in d])")).isEqualTo("[\"aa\", \"bb\"]"); + + checkEvalErrorContains("unhashable type: 'struct'", "{struct(a = []): 'foo'}"); + } + + @Test + public void testStructDictMembersAreMutable() throws Exception { + exec( + "s = struct(x = {'a' : 1})", // + "s.x['b'] = 2\n"); + assertThat(((StructImpl) lookup("s")).getValue("x")).isEqualTo(ImmutableMap.of("a", 1, "b", 2)); + } + + @Test + public void testDepsetGoodCompositeItem() throws Exception { + exec("def func():", " return depset([struct(a='a')])", "s = func()"); + ImmutableList<?> result = ((Depset) lookup("s")).toList(); + assertThat(result).hasSize(1); + assertThat(result.get(0)).isInstanceOf(StructImpl.class); + } + + private static StructImpl makeStruct(String field, Object value) { + return StructProvider.STRUCT.create(ImmutableMap.of(field, value), "no field '%'"); + } + + private static StructImpl makeBigStruct(@Nullable Mutability mu) { + // struct(a=[struct(x={1:1}), ()], b=(), c={2:2}) + return StructProvider.STRUCT.create( + ImmutableMap.<String, Object>of( + "a", + StarlarkList.<Object>of( + mu, + StructProvider.STRUCT.create( + ImmutableMap.<String, Object>of("x", Dict.<Object, Object>of(mu, 1, 1)), + "no field '%s'"), + Tuple.of()), + "b", Tuple.of(), + "c", Dict.<Object, Object>of(mu, 2, 2)), + "no field '%s'"); + } + + @Test + public void testStructMutabilityShallow() throws Exception { + assertThat(EvalUtils.isImmutable(makeStruct("a", 1))).isTrue(); + } + + private static StarlarkList<Object> makeList(@Nullable Mutability mu) { + return StarlarkList.<Object>of(mu, 1, 2, 3); + } + + @Test + public void testStructMutabilityDeep() throws Exception { + assertThat(EvalUtils.isImmutable(Tuple.<Object>of(makeList(null)))).isTrue(); + assertThat(EvalUtils.isImmutable(makeStruct("a", makeList(null)))).isTrue(); + assertThat(EvalUtils.isImmutable(makeBigStruct(null))).isTrue(); + + Mutability mu = ev.getStarlarkThread().mutability(); + assertThat(EvalUtils.isImmutable(Tuple.<Object>of(makeList(mu)))).isFalse(); + assertThat(EvalUtils.isImmutable(makeStruct("a", makeList(mu)))).isFalse(); + assertThat(EvalUtils.isImmutable(makeBigStruct(mu))).isFalse(); + } + + @Test + public void declaredProviders() throws Exception { + evalAndExport( + "data = provider()", + "d = data(x = 1, y ='abc')", + "d_x = d.x", + "d_y = d.y" + ); + assertThat(lookup("d_x")).isEqualTo(1); + assertThat(lookup("d_y")).isEqualTo("abc"); + StarlarkProvider dataConstructor = (StarlarkProvider) lookup("data"); + StructImpl data = (StructImpl) lookup("d"); + assertThat(data.getProvider()).isEqualTo(dataConstructor); + assertThat(dataConstructor.isExported()).isTrue(); + assertThat(dataConstructor.getPrintableName()).isEqualTo("data"); + assertThat(dataConstructor.getKey()).isEqualTo(new StarlarkProvider.Key(FAKE_LABEL, "data")); + } + + @Test + public void declaredProvidersConcatSuccess() throws Exception { + evalAndExport( + "data = provider()", + "dx = data(x = 1)", + "dy = data(y = 'abc')", + "dxy = dx + dy", + "x = dxy.x", + "y = dxy.y" + ); + assertThat(lookup("x")).isEqualTo(1); + assertThat(lookup("y")).isEqualTo("abc"); + StarlarkProvider dataConstructor = (StarlarkProvider) lookup("data"); + StructImpl dx = (StructImpl) lookup("dx"); + assertThat(dx.getProvider()).isEqualTo(dataConstructor); + StructImpl dy = (StructImpl) lookup("dy"); + assertThat(dy.getProvider()).isEqualTo(dataConstructor); + } + + @Test + public void declaredProvidersConcatError() throws Exception { + evalAndExport( + "data1 = provider()", + "data2 = provider()" + ); + + checkEvalErrorContains( + "Cannot use '+' operator on instances of different providers (data1 and data2)", + "d1 = data1(x = 1)", + "d2 = data2(y = 2)", + "d = d1 + d2"); + } + + @Test + public void declaredProvidersWithFieldsConcatSuccess() throws Exception { + evalAndExport( + "data = provider(fields=['f1', 'f2'])", + "d1 = data(f1 = 4)", + "d2 = data(f2 = 5)", + "d3 = d1 + d2", + "f1 = d3.f1", + "f2 = d3.f2"); + assertThat(lookup("f1")).isEqualTo(4); + assertThat(lookup("f2")).isEqualTo(5); + } + + @Test + public void declaredProvidersWithFieldsConcatError() throws Exception { + evalAndExport("data1 = provider(fields=['f1', 'f2'])", "data2 = provider(fields=['f3'])"); + checkEvalErrorContains( + "Cannot use '+' operator on instances of different providers (data1 and data2)", + "d1 = data1(f1=1, f2=2)", + "d2 = data2(f3=3)", + "d = d1 + d2"); + } + + @Test + public void declaredProvidersWithOverlappingFieldsConcatError() throws Exception { + evalAndExport("data = provider(fields=['f1', 'f2'])"); + checkEvalErrorContains( + "cannot add struct instances with common field 'f1'", + "d1 = data(f1 = 4)", + "d2 = data(f1 = 5)", + "d1 + d2"); + } + + @Test + public void structsAsDeclaredProvidersTest() throws Exception { + evalAndExport( + "data = struct(x = 1)" + ); + StructImpl data = (StructImpl) lookup("data"); + assertThat(StructProvider.STRUCT.isExported()).isTrue(); + assertThat(data.getProvider()).isEqualTo(StructProvider.STRUCT); + assertThat(data.getProvider().getKey()).isEqualTo(StructProvider.STRUCT.getKey()); + } + + @Test + public void declaredProvidersDoc() throws Exception { + evalAndExport("data1 = provider(doc='foo')"); + } + + @Test + public void declaredProvidersBadTypeForDoc() throws Exception { + checkEvalErrorContains("got value of type 'int', want 'string'", "provider(doc = 1)"); + } + + @Test + public void aspectAllAttrs() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl, attr_aspects=['*'])"); + + StarlarkDefinedAspect myAspect = (StarlarkDefinedAspect) lookup("my_aspect"); + assertThat(myAspect.getDefinition(AspectParameters.EMPTY).propagateAlong("foo")).isTrue(); + } + + @Test + public void aspectRequiredAspectProvidersSingle() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "cc = provider()", + "my_aspect = aspect(_impl, required_aspect_providers=['java', cc])" + ); + StarlarkDefinedAspect myAspect = (StarlarkDefinedAspect) lookup("my_aspect"); + RequiredProviders requiredProviders = myAspect.getDefinition(AspectParameters.EMPTY) + .getRequiredProvidersForAspects(); + assertThat(requiredProviders.isSatisfiedBy(AdvertisedProviderSet.ANY)).isTrue(); + assertThat(requiredProviders.isSatisfiedBy(AdvertisedProviderSet.EMPTY)).isFalse(); + assertThat(requiredProviders.isSatisfiedBy( + AdvertisedProviderSet.builder() + .addSkylark(declared("cc")) + .addSkylark("java") + .build())) + .isTrue(); + assertThat(requiredProviders.isSatisfiedBy( + AdvertisedProviderSet.builder() + .addSkylark("cc") + .build())) + .isFalse(); + } + + @Test + public void aspectRequiredAspectProvidersAlternatives() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "cc = provider()", + "my_aspect = aspect(_impl, required_aspect_providers=[['java'], [cc]])" + ); + StarlarkDefinedAspect myAspect = (StarlarkDefinedAspect) lookup("my_aspect"); + RequiredProviders requiredProviders = myAspect.getDefinition(AspectParameters.EMPTY) + .getRequiredProvidersForAspects(); + assertThat(requiredProviders.isSatisfiedBy(AdvertisedProviderSet.ANY)).isTrue(); + assertThat(requiredProviders.isSatisfiedBy(AdvertisedProviderSet.EMPTY)).isFalse(); + assertThat(requiredProviders.isSatisfiedBy( + AdvertisedProviderSet.builder() + .addSkylark("java") + .build())) + .isTrue(); + assertThat(requiredProviders.isSatisfiedBy( + AdvertisedProviderSet.builder() + .addSkylark(declared("cc")) + .build())) + .isTrue(); + assertThat(requiredProviders.isSatisfiedBy( + AdvertisedProviderSet.builder() + .addSkylark("prolog") + .build())) + .isFalse(); + } + + @Test + public void aspectRequiredAspectProvidersEmpty() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl, required_aspect_providers=[])" + ); + StarlarkDefinedAspect myAspect = (StarlarkDefinedAspect) lookup("my_aspect"); + RequiredProviders requiredProviders = myAspect.getDefinition(AspectParameters.EMPTY) + .getRequiredProvidersForAspects(); + assertThat(requiredProviders.isSatisfiedBy(AdvertisedProviderSet.ANY)).isFalse(); + assertThat(requiredProviders.isSatisfiedBy(AdvertisedProviderSet.EMPTY)).isFalse(); + } + + @Test + public void aspectRequiredAspectProvidersDefault() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl)" + ); + StarlarkDefinedAspect myAspect = (StarlarkDefinedAspect) lookup("my_aspect"); + RequiredProviders requiredProviders = myAspect.getDefinition(AspectParameters.EMPTY) + .getRequiredProvidersForAspects(); + assertThat(requiredProviders.isSatisfiedBy(AdvertisedProviderSet.ANY)).isFalse(); + assertThat(requiredProviders.isSatisfiedBy(AdvertisedProviderSet.EMPTY)).isFalse(); + } + + @Test + public void aspectProvides() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "y = provider()", + "my_aspect = aspect(_impl, provides = ['x', y])" + ); + StarlarkDefinedAspect myAspect = (StarlarkDefinedAspect) lookup("my_aspect"); + AdvertisedProviderSet advertisedProviders = myAspect.getDefinition(AspectParameters.EMPTY) + .getAdvertisedProviders(); + assertThat(advertisedProviders.canHaveAnyProvider()).isFalse(); + assertThat(advertisedProviders.getSkylarkProviders()) + .containsExactly(legacy("x"), declared("y")); + } + + @Test + public void aspectProvidesError() throws Exception { + ev.setFailFast(false); + evalAndExport( + "def _impl(target, ctx):", + " pass", + "y = provider()", + "my_aspect = aspect(_impl, provides = ['x', 1])" + ); + MoreAsserts.assertContainsEvent(ev.getEventCollector(), + " Illegal argument: element in 'provides' is of unexpected type." + + " Should be list of providers, but got item of type int. "); + } + + @Test + public void aspectDoc() throws Exception { + evalAndExport( + "def _impl(target, ctx):", + " pass", + "my_aspect = aspect(_impl, doc='foo')"); + } + + @Test + public void aspectBadTypeForDoc() throws Exception { + registerDummyStarlarkFunction(); + checkEvalErrorContains("got value of type 'int', want 'string'", "aspect(impl, doc = 1)"); + } + + @Test + public void fancyExports() throws Exception { + evalAndExport( + "def _impla(target, ctx): pass", + "p, (a, p1) = [", + " provider(),", + " [ aspect(_impla),", + " provider() ]", + "]" + ); + StarlarkProvider p = (StarlarkProvider) lookup("p"); + StarlarkDefinedAspect a = (StarlarkDefinedAspect) lookup("a"); + StarlarkProvider p1 = (StarlarkProvider) lookup("p1"); + assertThat(p.getPrintableName()).isEqualTo("p"); + assertThat(p.getKey()).isEqualTo(new StarlarkProvider.Key(FAKE_LABEL, "p")); + assertThat(p1.getPrintableName()).isEqualTo("p1"); + assertThat(p1.getKey()).isEqualTo(new StarlarkProvider.Key(FAKE_LABEL, "p1")); + assertThat(a.getAspectClass()).isEqualTo( + new SkylarkAspectClass(FAKE_LABEL, "a") + ); + } + + @Test + public void multipleTopLevels() throws Exception { + evalAndExport( + "p = provider()", + "p1 = p" + ); + StarlarkProvider p = (StarlarkProvider) lookup("p"); + StarlarkProvider p1 = (StarlarkProvider) lookup("p1"); + assertThat(p).isEqualTo(p1); + assertThat(p.getKey()).isEqualTo(new StarlarkProvider.Key(FAKE_LABEL, "p")); + assertThat(p1.getKey()).isEqualTo(new StarlarkProvider.Key(FAKE_LABEL, "p")); + } + + @Test + public void providerWithFields() throws Exception { + evalAndExport( + "p = provider(fields = ['x', 'y'])", + "p1 = p(x = 1, y = 2)", + "x = p1.x", + "y = p1.y" + ); + StarlarkProvider p = (StarlarkProvider) lookup("p"); + SkylarkInfo p1 = (SkylarkInfo) lookup("p1"); + + assertThat(p1.getProvider()).isEqualTo(p); + assertThat(lookup("x")).isEqualTo(1); + assertThat(lookup("y")).isEqualTo(2); + } + + @Test + public void providerWithFieldsDict() throws Exception { + evalAndExport( + "p = provider(fields = { 'x' : 'I am x', 'y' : 'I am y'})", + "p1 = p(x = 1, y = 2)", + "x = p1.x", + "y = p1.y" + ); + StarlarkProvider p = (StarlarkProvider) lookup("p"); + SkylarkInfo p1 = (SkylarkInfo) lookup("p1"); + + assertThat(p1.getProvider()).isEqualTo(p); + assertThat(lookup("x")).isEqualTo(1); + assertThat(lookup("y")).isEqualTo(2); + } + + @Test + public void providerWithFieldsOptional() throws Exception { + evalAndExport( + "p = provider(fields = ['x', 'y'])", + "p1 = p(y = 2)", + "y = p1.y" + ); + StarlarkProvider p = (StarlarkProvider) lookup("p"); + SkylarkInfo p1 = (SkylarkInfo) lookup("p1"); + + assertThat(p1.getProvider()).isEqualTo(p); + assertThat(lookup("y")).isEqualTo(2); + } + + @Test + public void providerWithFieldsOptionalError() throws Exception { + ev.setFailFast(false); + evalAndExport( + "p = provider(fields = ['x', 'y'])", + "p1 = p(y = 2)", + "x = p1.x" + ); + MoreAsserts.assertContainsEvent( + ev.getEventCollector(), " 'p' value has no field or method 'x'"); + } + + @Test + public void providerWithExtraFieldsError() throws Exception { + ev.setFailFast(false); + evalAndExport( + "p = provider(fields = ['x', 'y'])", + "p1 = p(x = 1, y = 2, z = 3)" + ); + MoreAsserts.assertContainsEvent( + ev.getEventCollector(), "unexpected keyword z in call to instantiate provider p"); + } + + @Test + public void providerWithEmptyFieldsError() throws Exception { + ev.setFailFast(false); + evalAndExport( + "p = provider(fields = [])", + "p1 = p(x = 1, y = 2, z = 3)" + ); + MoreAsserts.assertContainsEvent( + ev.getEventCollector(), "unexpected keywords x, y, z in call to instantiate provider p"); + } + + @Test + public void providerWithDuplicateFieldsError() throws Exception { + ev.setFailFast(false); + evalAndExport("p = provider(fields = ['a', 'b'])", "p(a = 1, b = 2, **dict(b = 3))"); + MoreAsserts.assertContainsEvent( + ev.getEventCollector(), + "got multiple values for parameter b in call to instantiate provider p"); + } + + @Test + public void starTheOnlyAspectArg() throws Exception { + checkEvalErrorContains( + "'*' must be the only string in 'attr_aspects' list", + "def _impl(target, ctx):", + " pass", + "aspect(_impl, attr_aspects=['*', 'foo'])"); + } + + @Test + public void testMandatoryConfigParameterForExecutableLabels() throws Exception { + scratch.file("third_party/foo/extension.bzl", + "def _main_rule_impl(ctx):", + " pass", + "my_rule = rule(_main_rule_impl,", + " attrs = { ", + " 'exe' : attr.label(executable = True, allow_files = True),", + " },", + ")" + ); + scratch.file("third_party/foo/BUILD", + "load(':extension.bzl', 'my_rule')", + "my_rule(name = 'main', exe = ':tool.sh')" + ); + + AssertionError expected = + assertThrows(AssertionError.class, () -> createRuleContext("//third_party/foo:main")); + assertThat(expected).hasMessageThat() + .contains("cfg parameter is mandatory when executable=True is provided."); + } + + @Test + public void testRuleAddToolchain() throws Exception { + scratch.file("test/BUILD", "toolchain_type(name = 'my_toolchain_type')"); + evalAndExport( + "def impl(ctx): return None", "r1 = rule(impl, toolchains=['//test:my_toolchain_type'])"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + assertThat(c.getRequiredToolchains()).containsExactly(makeLabel("//test:my_toolchain_type")); + } + + @Test + public void testRuleAddExecutionConstraints() throws Exception { + registerDummyStarlarkFunction(); + scratch.file("test/BUILD", "toolchain_type(name = 'my_toolchain_type')"); + evalAndExport( + "r1 = rule(", + " implementation = impl,", + " toolchains=['//test:my_toolchain_type'],", + " exec_compatible_with=['//constraint:cv1', '//constraint:cv2'],", + ")"); + RuleClass c = ((StarlarkRuleFunction) lookup("r1")).getRuleClass(); + assertThat(c.getExecutionPlatformConstraints()) + .containsExactly(makeLabel("//constraint:cv1"), makeLabel("//constraint:cv2")); + } + + @Test + public void testRuleAddExecGroup() throws Exception { + setStarlarkSemanticsOptions("--experimental_exec_groups=true"); + reset(); + + registerDummyStarlarkFunction(); + scratch.file("test/BUILD", "toolchain_type(name = 'my_toolchain_type')"); + evalAndExport( + "plum = rule(", + " implementation = impl,", + " exec_groups = {", + " 'group': exec_group(", + " toolchains=['//test:my_toolchain_type'],", + " exec_compatible_with=['//constraint:cv1', '//constraint:cv2'],", + " ),", + " },", + ")"); + RuleClass plum = ((StarlarkRuleFunction) lookup("plum")).getRuleClass(); + assertThat(plum.getRequiredToolchains()).isEmpty(); + assertThat(plum.getExecGroups().get("group").getRequiredToolchains()) + .containsExactly(makeLabel("//test:my_toolchain_type")); + assertThat(plum.getExecutionPlatformConstraints()).isEmpty(); + assertThat(plum.getExecGroups().get("group").getExecutionPlatformConstraints()) + .containsExactly(makeLabel("//constraint:cv1"), makeLabel("//constraint:cv2")); + } + + @Test + public void testRuleFunctionReturnsNone() throws Exception { + scratch.file("test/rule.bzl", + "def _impl(ctx):", + " pass", + "foo_rule = rule(", + " implementation = _impl,", + " attrs = {'params': attr.string_list()},", + ")"); + scratch.file("test/BUILD", + "load(':rule.bzl', 'foo_rule')", + "r = foo_rule(name='foo')", // Custom rule should return None + "c = cc_library(name='cc')", // Native rule should return None + "", + "foo_rule(", + " name='check',", + " params = [type(r), type(c)]", + ")"); + invalidatePackages(); + StarlarkRuleContext context = createRuleContext("//test:check"); + @SuppressWarnings("unchecked") + StarlarkList<Object> params = (StarlarkList<Object>) context.getAttr().getValue("params"); + assertThat(params.get(0)).isEqualTo("NoneType"); + assertThat(params.get(1)).isEqualTo("NoneType"); + } + + @Test + public void testTypeOfStruct() throws Exception { + exec("p = type(struct)", "s = type(struct())"); + + assertThat(lookup("p")).isEqualTo("Provider"); + assertThat(lookup("s")).isEqualTo("struct"); + } + + @Test + public void testCreateExecGroup() throws Exception { + setStarlarkSemanticsOptions("--experimental_exec_groups=true"); + reset(); + + scratch.file("test/BUILD", "toolchain_type(name = 'my_toolchain_type')"); + evalAndExport( + "group = exec_group(", + " toolchains=['//test:my_toolchain_type'],", + " exec_compatible_with=['//constraint:cv1', '//constraint:cv2'],", + ")"); + ExecGroup group = ((ExecGroup) lookup("group")); + assertThat(group.getRequiredToolchains()) + .containsExactly(makeLabel("//test:my_toolchain_type")); + assertThat(group.getExecutionPlatformConstraints()) + .containsExactly(makeLabel("//constraint:cv1"), makeLabel("//constraint:cv2")); + } +}