blob: 01b0497827a00f95600cb33bef98f074189295de [file] [log] [blame]
// 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 com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.devtools.build.lib.analysis.config.transitions.NoTransition;
import com.google.devtools.build.lib.analysis.skylark.SkylarkAttr;
import com.google.devtools.build.lib.analysis.skylark.SkylarkAttr.Descriptor;
import com.google.devtools.build.lib.analysis.skylark.SkylarkRuleClassFunctions.SkylarkRuleFunction;
import com.google.devtools.build.lib.analysis.skylark.SkylarkRuleContext;
import com.google.devtools.build.lib.cmdline.Label;
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.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.RuleClass.ExecutionPlatformConstraintsAllowed;
import com.google.devtools.build.lib.packages.SkylarkAspectClass;
import com.google.devtools.build.lib.packages.SkylarkDefinedAspect;
import com.google.devtools.build.lib.packages.SkylarkInfo;
import com.google.devtools.build.lib.packages.SkylarkProvider;
import com.google.devtools.build.lib.packages.SkylarkProviderIdentifier;
import com.google.devtools.build.lib.packages.StructImpl;
import com.google.devtools.build.lib.packages.StructProvider;
import com.google.devtools.build.lib.skyframe.SkylarkImportLookupFunction;
import com.google.devtools.build.lib.skylark.util.SkylarkTestCase;
import com.google.devtools.build.lib.syntax.BuildFileAST;
import com.google.devtools.build.lib.syntax.ClassObject;
import com.google.devtools.build.lib.syntax.Environment;
import com.google.devtools.build.lib.syntax.EvalException;
import com.google.devtools.build.lib.syntax.EvalUtils;
import com.google.devtools.build.lib.syntax.SkylarkDict;
import com.google.devtools.build.lib.syntax.SkylarkList.MutableList;
import com.google.devtools.build.lib.syntax.SkylarkList.Tuple;
import com.google.devtools.build.lib.syntax.SkylarkNestedSet;
import com.google.devtools.build.lib.syntax.StarlarkSemantics;
import com.google.devtools.build.lib.syntax.Type;
import com.google.devtools.build.lib.testutil.MoreAsserts;
import com.google.devtools.build.lib.util.FileTypeSet;
import java.util.Collection;
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 class SkylarkRuleClassFunctionsTest extends SkylarkTestCase {
@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 ((SkylarkRuleFunction) lookup(name)).getRuleClass();
}
private void registerDummyUserDefinedFunction() throws Exception {
eval("def impl():\n" + " return 0\n");
}
@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);
Descriptor lookup = (Descriptor) ev.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 {
checkErrorContains(
"allow_files should be a boolean or a string list",
"attr.label_list(allow_files = 18)");
}
@Test
public void testDisableDeprecatedParams() throws Exception {
ev =
createEvaluationTestCase(
StarlarkSemantics.DEFAULT_SEMANTICS
.toBuilder()
.incompatibleDisableDeprecatedAttrParams(true)
.build());
ev.initialize();
// 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 {
checkErrorContains(
"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 SkylarkProviderIdentifier legacy(String legacyId) {
return SkylarkProviderIdentifier.forLegacy(legacyId);
}
private static SkylarkProviderIdentifier declared(String exportedName) {
return SkylarkProviderIdentifier.forKey(
new SkylarkProvider.SkylarkKey(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(SkylarkProviderIdentifier... ids) {
AdvertisedProviderSet.Builder builder = AdvertisedProviderSet.builder();
for (SkylarkProviderIdentifier 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])");
SkylarkAttr.Descriptor attr = (SkylarkAttr.Descriptor) ev.lookup("a");
SkylarkDefinedAspect aspect = (SkylarkDefinedAspect) ev.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])");
SkylarkAttr.Descriptor attr = (SkylarkAttr.Descriptor) ev.lookup("a");
SkylarkDefinedAspect aspect = (SkylarkDefinedAspect) ev.lookup("my_aspect");
assertThat(aspect).isNotNull();
assertThat(attr.build("xxx").getAspectClasses()).containsExactly(aspect.getAspectClass());
}
@Test
public void testLabelListWithAspectsError() throws Exception {
checkErrorContains(
"expected type 'Aspect' for 'aspects' element but got type 'int' instead",
"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')) }",
")");
SkylarkDefinedAspect aspect = (SkylarkDefinedAspect) ev.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']) }",
")");
SkylarkDefinedAspect aspect = (SkylarkDefinedAspect) ev.lookup("my_aspect");
Attribute attribute = Iterables.getOnlyElement(aspect.getAttributes());
assertThat(attribute.getName()).isEqualTo("param");
}
@Test
public void testAspectParameterRequiresValues() throws Exception {
checkErrorContains(
"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 {
checkErrorContains(
"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')) }",
")");
SkylarkDefinedAspect aspect = (SkylarkDefinedAspect) ev.lookup("my_aspect");
assertThat(aspect.getAttributes()).hasSize(2);
assertThat(aspect.getParamAttributes()).containsExactly("param");
}
@Test
public void testAspectNoDefaultValueAttribute() throws Exception {
checkErrorContains(
"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'])");
SkylarkDefinedAspect a = (SkylarkDefinedAspect) lookup("a1");
assertThat(a.getRequiredToolchains()).containsExactly(makeLabel("//test:my_toolchain_type"));
}
@Test
public void testNonLabelAttrWithProviders() throws Exception {
checkErrorContains(
"unexpected keyword 'providers', for call to method "
+ "string(default = '', doc = '', mandatory = False, values = []) "
+ "of 'attr (a language module)'",
"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 {
checkErrorContains(
"invalid label '/foo:bar' in parameter 'default' of attribute 'label': "
+ "invalid target name '/foo:bar'",
"attr.label(default = '/foo:bar')");
checkErrorContains(
"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'])");
checkErrorContains(
"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 {
checkErrorContains(
"expected value of type 'string' for parameter 'default', for call to method "
+ "string(default = '', doc = '', mandatory = False, values = []) "
+ "of 'attr (a language module)'",
"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 {
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 {
checkErrorContains(
"unexpected keyword 'bad_keyword', for call to method "
+ "string(default = '', doc = '', mandatory = False, values = []) of "
+ "'attr (a language module)'",
"attr.string(bad_keyword = '')");
}
@Test
public void testAttrCfg() throws Exception {
Attribute attr = buildAttribute("a1", "attr.label(cfg = 'host', allow_files = True)");
assertThat(attr.getConfigurationTransition().isHostTransition()).isTrue();
}
@Test
public void testAttrCfgTarget() throws Exception {
Attribute attr = buildAttribute("a1", "attr.label(cfg = 'target', allow_files = True)");
assertThat(attr.getConfigurationTransition()).isEqualTo(NoTransition.INSTANCE);
}
@Test
public void incompatibleDataTransition() throws Exception {
ev =
createEvaluationTestCase(
StarlarkSemantics.DEFAULT_SEMANTICS
.toBuilder()
.incompatibleDisallowDataTransition(true)
.build());
ev.initialize();
EvalException expected =
assertThrows(EvalException.class, () -> eval("attr.label(cfg = 'data')"));
assertThat(expected).hasMessageThat().contains(
"Using cfg = \"data\" on an attribute is a noop and no longer supported");
}
@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("a7", "attr.license(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 {
ev =
createEvaluationTestCase(
StarlarkSemantics.DEFAULT_SEMANTICS
.toBuilder()
.incompatibleNoAttrLicense(true)
.build());
ev.initialize();
EvalException expected = assertThrows(EvalException.class, () -> eval("attr.license()"));
assertThat(expected)
.hasMessageThat()
.contains("type 'attr (a language module)' has no method license()");
}
@Test
public void testAttrDocValueBadType() throws Exception {
checkErrorContains(
"expected value of type 'string' for parameter 'doc', for call to method "
+ "string(default = '', doc = '', mandatory = False, values = []) "
+ "of 'attr (a language module)'",
"attr.string(doc = 1)");
}
@Test
public void testRuleImplementation() throws Exception {
evalAndExport("def impl(ctx): return None", "rule1 = rule(impl)");
RuleClass c = ((SkylarkRuleFunction) 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 testLateBoundAttrWorksWithOnlyLabel() throws Exception {
checkEvalError(
"expected value of type 'string' for parameter 'default', for call to method "
+ "string(default = '', doc = '', mandatory = False, values = []) "
+ "of 'attr (a language module)'",
"def attr_value(cfg): return 'a'",
"attr.string(default=attr_value)");
}
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 = ((SkylarkRuleFunction) lookup("r1")).getRuleClass();
assertThat(c.hasAttr("a1", Type.STRING)).isTrue();
}
protected void evalAndExport(String... lines) throws Exception {
BuildFileAST buildFileAST = BuildFileAST.parseAndValidateSkylarkString(
ev.getEnvironment(), lines);
SkylarkImportLookupFunction.execAndExport(
buildFileAST, FAKE_LABEL, ev.getEventHandler(), ev.getEnvironment());
}
@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 = ((SkylarkRuleFunction) lookup("d")).getRuleClass().getName();
String fooName = ((SkylarkRuleFunction) 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 = ((SkylarkRuleFunction) 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 = ((SkylarkRuleFunction) 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 = ((SkylarkRuleFunction) 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 = ((SkylarkRuleFunction) lookup("r1")).getRuleClass();
ImplicitOutputsFunction function = c.getDefaultImplicitOutputsFunction();
assertThat(function.getImplicitOutputs(ev.getEventHandler(), null)).containsExactly("a.txt");
}
@Test
public void testRuleUnknownKeyword() throws Exception {
registerDummyUserDefinedFunction();
checkErrorContains(
"unexpected keyword 'bad_keyword', for call to function rule(",
"rule(impl, bad_keyword = 'some text')");
}
@Test
public void testRuleImplementationMissing() throws Exception {
checkErrorContains(
"parameter 'implementation' has no default value, for call to function rule(",
"rule(attrs = {})");
}
@Test
public void testRuleBadTypeForAdd() throws Exception {
registerDummyUserDefinedFunction();
checkErrorContains(
"expected value of type 'dict or NoneType' for parameter 'attrs', "
+ "for call to function rule(",
"rule(impl, attrs = 'some text')");
}
@Test
public void testRuleBadTypeInAdd() throws Exception {
registerDummyUserDefinedFunction();
checkErrorContains(
"expected <String, Descriptor> type for 'attrs' but got <string, string> instead",
"rule(impl, attrs = {'a1': 'some text'})");
}
@Test
public void testRuleBadTypeForDoc() throws Exception {
registerDummyUserDefinedFunction();
checkErrorContains(
"expected value of type 'string' for parameter 'doc', for call to function rule(",
"rule(impl, doc = 1)");
}
@Test
public void testLabel() throws Exception {
Object result = evalRuleClassCode("Label('//foo/foo:foo')");
assertThat(result).isInstanceOf(Label.class);
assertThat(result.toString()).isEqualTo("//foo/foo:foo");
}
@Test
public void testLabelSameInstance() throws Exception {
Object l1 = evalRuleClassCode("Label('//foo/foo:foo')");
// Implicitly creates a new pkgContext and environment, yet labels should be the same.
Object l2 = evalRuleClassCode("Label('//foo/foo:foo')");
assertThat(l1).isSameAs(l2);
}
@Test
public void testLabelNameAndPackage() throws Exception {
Object result = evalRuleClassCode("Label('//foo/bar:baz').name");
assertThat(result).isEqualTo("baz");
// NB: implicitly creates a new pkgContext and environments, yet labels should be the same.
result = evalRuleClassCode("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 = ((SkylarkRuleFunction) 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 = ((SkylarkRuleFunction) lookup("r1")).getRuleClass();
Attribute a = c.getAttributeByName("a1");
assertThat(a.getDefaultValueUnchecked()).isEqualTo(42);
}
@Test
public void testFileTypeIsDisabled() throws Exception {
StarlarkSemantics semantics =
StarlarkSemantics.DEFAULT_SEMANTICS.toBuilder().incompatibleDisallowFileType(true).build();
EvalException expected =
assertThrows(EvalException.class, () -> evalRuleClassCode(semantics, "FileType(['.css'])"));
assertThat(expected).hasMessageThat().contains("FileType function is not available.");
}
@Test
public void testRuleInheritsBaseRuleAttributes() throws Exception {
evalAndExport("def impl(ctx): return None", "r1 = rule(impl)");
RuleClass c = ((SkylarkRuleFunction) 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 {
Object result = evalRuleClassCode(from);
assertThat(result).isEqualTo(Joiner.on("\n").join(lines) + "\n");
}
@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 {
checkErrorContains(
"cannot override built-in struct function 'to_json'",
"struct(to_json='foo')");
checkErrorContains(
"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=['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\"", " }", "}");
}
@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 {
checkErrorContains(
"Invalid text format, expected a struct, 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 {
checkErrorContains(
"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_proto()");
}
private void checkJson(String from, String expected) throws Exception {
Object result = evalRuleClassCode(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\"}}");
checkErrorContains(
"Keys must be a string but got a int for struct field 'config'",
"struct(config={1:2}).to_json()");
checkErrorContains(
"Keys must be a string but got a int for dict value 'foo'",
"struct(config={'foo':{1:2}}).to_json()");
checkErrorContains(
"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 {
checkErrorContains(
"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 {
checkErrorContains(
"expected value of type 'Label or string or LateBoundDefault or function or NoneType' "
+ "for parameter 'default', for call to method label(",
"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 {
checkErrorContains(
"invalid target name 'bad//syntax': target names may not contain '//' path separators",
"Label('//foo:bar').relative('bad//syntax')");
}
@Test
public void testLicenseAttributesNonconfigurable() throws Exception {
scratch.file("test/BUILD");
scratch.file("test/rule.bzl",
"def _impl(ctx):",
" return",
"some_rule = rule(",
" implementation = _impl,",
" attrs = {",
" 'licenses': attr.license()",
" }",
")");
scratch.file("third_party/foo/BUILD",
"load('//test:rule.bzl', 'some_rule')",
"some_rule(",
" name='r',",
" licenses = ['unencumbered']",
")");
invalidatePackages();
// Should succeed without a "licenses attribute is potentially configurable" loading error:
createRuleContext("//third_party/foo:r");
}
@Test
public void testStructCreation() throws Exception {
// TODO(fwe): cannot be handled by current testing suite
eval("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
eval("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
assertThat((Boolean) eval("s = (struct(a = 1, b = [])); s.b.append(s); 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();
eval("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 {
checkErrorContains("Cannot compare structs", "struct(a = 1) < struct(a = 2)");
checkErrorContains("Cannot compare structs", "struct(a = 1) > struct(a = 2)");
checkErrorContains("Cannot compare structs", "struct(a = 1) <= struct(a = 2)");
checkErrorContains("Cannot compare structs", "struct(a = 1) >= struct(a = 2)");
}
@Test
public void testStructAccessingFieldsFromSkylark() throws Exception {
eval("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 {
checkErrorContains(
"'struct' object has no attribute 'c'\n" + "Available attributes: a, b",
"x = struct(a = 1, b = 2)",
"y = x.c");
}
@Test
public void testStructAccessingUnknownFieldWithArgs() throws Exception {
checkErrorContains(
"type 'struct' has no method c()", "x = struct(a = 1, b = 2)", "y = x.c()");
}
@Test
public void testStructAccessingNonFunctionFieldWithArgs() throws Exception {
checkErrorContains("'int' object is not callable", "x = struct(a = 1, b = 2)", "x1 = x.a(1)");
}
@Test
public void testStructAccessingFunctionFieldWithArgs() throws Exception {
eval("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 {
checkErrorContains(
"expected no more than 0 positional arguments, but got 1", "x = struct(1, b = 2)");
}
@Test
public void testStructConcatenationFieldNames() throws Exception {
// TODO(fwe): cannot be handled by current testing suite
eval("x = struct(a = 1, b = 2)",
"y = struct(c = 1, d = 2)",
"z = x + y\n");
StructImpl z = (StructImpl) lookup("z");
assertThat(z.getFieldNames()).isEqualTo(ImmutableSet.of("a", "b", "c", "d"));
}
@Test
public void testStructConcatenationFieldValues() throws Exception {
// TODO(fwe): cannot be handled by current testing suite
eval("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 {
checkErrorContains("Cannot use '+' operator on provider instances with overlapping field(s): 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
eval("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 {
checkErrorContains(
"'struct' object has no attribute 'b'\nAvailable attributes: a",
"s = struct(a='val')",
"getattr(s, 'b')");
}
@Test
public void testGetattr() throws Exception {
eval(
"s = struct(a='val')",
"x = getattr(s, 'a')",
"y = getattr(s, 'b', 'def')",
"z = getattr(s, 'b', default = 'def')",
"w = getattr(s, 'a', default='ignored')");
assertThat(lookup("x")).isEqualTo("val");
assertThat(lookup("y")).isEqualTo("def");
assertThat(lookup("z")).isEqualTo("def");
assertThat(lookup("w")).isEqualTo("val");
}
@Test
public void testHasattr() throws Exception {
eval("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 {
eval("depset([struct(a='a')])");
}
@Test
public void testStructsInDicts() throws Exception {
eval("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\"]");
checkErrorContains(
"unhashable type: 'struct'",
"{struct(a = []): 'foo'}");
}
@Test
public void testStructMembersAreImmutable() throws Exception {
checkErrorContains(
"cannot assign to 's.x'",
"s = struct(x = 'a')",
"s.x = 'b'\n");
}
@Test
public void testStructDictMembersAreMutable() throws Exception {
eval(
"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 testNsetGoodCompositeItem() throws Exception {
eval("def func():", " return depset([struct(a='a')])", "s = func()");
Collection<Object> result = ((SkylarkNestedSet) lookup("s")).toCollection();
assertThat(result).hasSize(1);
assertThat(result.iterator().next()).isInstanceOf(StructImpl.class);
}
@Test
public void testNsetBadMutableItem() throws Exception {
checkEvalError("depsets cannot contain mutable items", "depset([([],)])");
checkEvalError("depsets cannot contain mutable items", "depset([struct(a=[])])");
}
private static StructImpl makeStruct(String field, Object value) {
return StructProvider.STRUCT.create(ImmutableMap.of(field, value), "no field '%'");
}
private static StructImpl makeBigStruct(Environment env) {
// struct(a=[struct(x={1:1}), ()], b=(), c={2:2})
return StructProvider.STRUCT.create(
ImmutableMap.<String, Object>of(
"a",
MutableList.<Object>of(
env,
StructProvider.STRUCT.create(
ImmutableMap.<String, Object>of(
"x", SkylarkDict.<Object, Object>of(env, 1, 1)),
"no field '%s'"),
Tuple.of()),
"b", Tuple.of(),
"c", SkylarkDict.<Object, Object>of(env, 2, 2)),
"no field '%s'");
}
@Test
public void testStructMutabilityShallow() throws Exception {
assertThat(EvalUtils.isImmutable(makeStruct("a", 1))).isTrue();
}
private static MutableList<Object> makeList(Environment env) {
return MutableList.<Object>of(env, 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();
assertThat(EvalUtils.isImmutable(Tuple.<Object>of(makeList(ev.getEnvironment())))).isFalse();
assertThat(EvalUtils.isImmutable(makeStruct("a", makeList(ev.getEnvironment())))).isFalse();
assertThat(EvalUtils.isImmutable(makeBigStruct(ev.getEnvironment()))).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");
SkylarkProvider dataConstructor = (SkylarkProvider) 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 SkylarkProvider.SkylarkKey(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");
SkylarkProvider dataConstructor = (SkylarkProvider) 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()"
);
checkEvalError("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'])");
checkEvalError(
"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'])");
checkEvalError(
"Cannot use '+' operator on provider instances with overlapping field(s): 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 {
checkErrorContains(
"expected value of type 'string' for parameter 'doc', for call to function "
+ "provider(doc = '', fields = None)",
"provider(doc = 1)");
}
@Test
public void aspectAllAttrs() throws Exception {
evalAndExport(
"def _impl(target, ctx):",
" pass",
"my_aspect = aspect(_impl, attr_aspects=['*'])");
SkylarkDefinedAspect myAspect = (SkylarkDefinedAspect) 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])"
);
SkylarkDefinedAspect myAspect = (SkylarkDefinedAspect) 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]])"
);
SkylarkDefinedAspect myAspect = (SkylarkDefinedAspect) 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=[])"
);
SkylarkDefinedAspect myAspect = (SkylarkDefinedAspect) 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)"
);
SkylarkDefinedAspect myAspect = (SkylarkDefinedAspect) 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])"
);
SkylarkDefinedAspect myAspect = (SkylarkDefinedAspect) 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 {
registerDummyUserDefinedFunction();
checkErrorContains(
"expected value of type 'string' for parameter 'doc', for call to function aspect(",
"aspect(impl, doc = 1)");
}
@Test
public void fancyExports() throws Exception {
evalAndExport(
"def _impla(target, ctx): pass",
"p, (a, p1) = [",
" provider(),",
" [ aspect(_impla),",
" provider() ]",
"]"
);
SkylarkProvider p = (SkylarkProvider) lookup("p");
SkylarkDefinedAspect a = (SkylarkDefinedAspect) lookup("a");
SkylarkProvider p1 = (SkylarkProvider) lookup("p1");
assertThat(p.getPrintableName()).isEqualTo("p");
assertThat(p.getKey()).isEqualTo(new SkylarkProvider.SkylarkKey(FAKE_LABEL, "p"));
assertThat(p1.getPrintableName()).isEqualTo("p1");
assertThat(p1.getKey()).isEqualTo(new SkylarkProvider.SkylarkKey(FAKE_LABEL, "p1"));
assertThat(a.getAspectClass()).isEqualTo(
new SkylarkAspectClass(FAKE_LABEL, "a")
);
}
@Test
public void multipleTopLevels() throws Exception {
evalAndExport(
"p = provider()",
"p1 = p"
);
SkylarkProvider p = (SkylarkProvider) lookup("p");
SkylarkProvider p1 = (SkylarkProvider) lookup("p1");
assertThat(p).isEqualTo(p1);
assertThat(p.getKey()).isEqualTo(new SkylarkProvider.SkylarkKey(FAKE_LABEL, "p"));
assertThat(p1.getKey()).isEqualTo(new SkylarkProvider.SkylarkKey(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"
);
SkylarkProvider p = (SkylarkProvider) 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"
);
SkylarkProvider p = (SkylarkProvider) 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"
);
SkylarkProvider p = (SkylarkProvider) 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' object has no attribute '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 p(*, x = ?, y = ?)");
}
@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 p()");
}
@Test
public void starTheOnlyAspectArg() throws Exception {
checkEvalError("'*' 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 = ((SkylarkRuleFunction) lookup("r1")).getRuleClass();
assertThat(c.getRequiredToolchains()).containsExactly(makeLabel("//test:my_toolchain_type"));
}
@Test
public void testRuleAddExecutionConstraints() throws Exception {
registerDummyUserDefinedFunction();
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 = ((SkylarkRuleFunction) lookup("r1")).getRuleClass();
assertThat(c.getExecutionPlatformConstraints())
.containsExactly(makeLabel("//constraint:cv1"), makeLabel("//constraint:cv2"));
}
@Test
public void testTargetsCanAddExecutionPlatformConstraints() throws Exception {
registerDummyUserDefinedFunction();
scratch.file("test/BUILD", "toolchain_type(name = 'my_toolchain_type')");
evalAndExport(
"r1 = rule(impl, ",
" toolchains=['//test:my_toolchain_type'],",
" execution_platform_constraints_allowed=True,",
")");
RuleClass c = ((SkylarkRuleFunction) lookup("r1")).getRuleClass();
assertThat(c.executionPlatformConstraintsAllowed())
.isEqualTo(ExecutionPlatformConstraintsAllowed.PER_TARGET);
}
@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();
SkylarkRuleContext context = createRuleContext("//test:check");
@SuppressWarnings("unchecked")
MutableList<Object> params = (MutableList<Object>) context.getAttr().getValue("params");
assertThat(params.get(0)).isEqualTo("NoneType");
assertThat(params.get(1)).isEqualTo("NoneType");
}
@Test
public void testTypeOfStruct() throws Exception {
eval("p = type(struct)", "s = type(struct())");
assertThat(lookup("p")).isEqualTo("Provider");
assertThat(lookup("s")).isEqualTo("struct");
}
}