blob: 236aea04e927d0a4566738734e01c1b20438b535 [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.syntax;
import static com.google.common.truth.Truth.assertThat;
import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;
import com.google.common.collect.ImmutableMap;
import com.google.devtools.build.lib.events.EventCollector;
import com.google.devtools.build.lib.events.Location;
import com.google.devtools.build.lib.syntax.util.EvaluationTestCase;
import com.google.devtools.build.lib.testutil.TestMode;
import java.util.Collections;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
/** Test of evaluation behavior. (Implicitly uses lexer + parser.) */
// TODO(adonovan): separate tests of parser, resolver, Starlark core evaluator,
// and BUILD and .bzl features.
@RunWith(JUnit4.class)
public class EvaluationTest extends EvaluationTestCase {
@Before
public final void setBuildMode() throws Exception {
super.setMode(TestMode.BUILD);
}
/**
* Creates a new instance of {@code ModalTestCase}.
*
* <p>If a test uses this method, it allows potential subclasses to run the very same test in a
* different mode in subclasses
*/
protected ModalTestCase newTest(String... skylarkOptions) {
return new BuildTest(skylarkOptions);
}
@Test
public void testExecutionStopsAtFirstError() throws Exception {
EventCollector printEvents = new EventCollector();
StarlarkThread thread =
createStarlarkThread(mutability, StarlarkThread.makeDebugPrintHandler(printEvents));
ParserInput input = ParserInput.fromLines("print('hello'); x = 1//0; print('goodbye')");
assertThrows(EvalException.class, () -> EvalUtils.exec(input, thread));
// Only expect hello, should have been an error before goodbye.
assertThat(printEvents).hasSize(1);
assertThat(printEvents.iterator().next().getMessage()).isEqualTo("hello");
}
@Test
public void testExecutionNotStartedOnInterrupt() throws Exception {
EventCollector printEvents = new EventCollector();
StarlarkThread thread =
createStarlarkThread(mutability, StarlarkThread.makeDebugPrintHandler(printEvents));
ParserInput input = ParserInput.fromLines("print('hello');");
try {
Thread.currentThread().interrupt();
assertThrows(InterruptedException.class, () -> EvalUtils.exec(input, thread));
} finally {
// Reset interrupt bit in case the test failed to do so.
Thread.interrupted();
}
assertThat(printEvents).isEmpty();
}
@Test
public void testForLoopAbortedOnInterrupt() throws Exception {
StarlarkThread thread = createStarlarkThread(mutability, (th, msg) -> {});
InterruptFunction interruptFunction = new InterruptFunction();
thread.getGlobals().put("interrupt", interruptFunction);
ParserInput input =
ParserInput.fromLines(
"def foo():", // Can't declare for loops at top level, so wrap with a function.
" for i in range(100):",
" interrupt(i == 5)",
"foo()");
try {
assertThrows(InterruptedException.class, () -> EvalUtils.exec(input, thread));
} finally {
// Reset interrupt bit in case the test failed to do so.
Thread.interrupted();
}
assertThat(interruptFunction.callCount).isEqualTo(6);
}
@Test
public void testForComprehensionAbortedOnInterrupt() throws Exception {
StarlarkThread thread = createStarlarkThread(mutability, (th, msg) -> {});
InterruptFunction interruptFunction = new InterruptFunction();
thread.getGlobals().put("interrupt", interruptFunction);
ParserInput input = ParserInput.fromLines("[interrupt(i == 5) for i in range(100)]");
try {
assertThrows(InterruptedException.class, () -> EvalUtils.exec(input, thread));
} finally {
// Reset interrupt bit in case the test failed to do so.
Thread.interrupted();
}
assertThat(interruptFunction.callCount).isEqualTo(6);
}
@Test
public void testFunctionCallsNotStartedOnInterrupt() throws Exception {
StarlarkThread thread = createStarlarkThread(mutability, (th, msg) -> {});
InterruptFunction interruptFunction = new InterruptFunction();
thread.getGlobals().put("interrupt", interruptFunction);
ParserInput input =
ParserInput.fromLines("interrupt(False); interrupt(True); interrupt(False);");
try {
assertThrows(InterruptedException.class, () -> EvalUtils.exec(input, thread));
} finally {
// Reset interrupt bit in case the test failed to do so.
Thread.interrupted();
}
// Third call shouldn't happen.
assertThat(interruptFunction.callCount).isEqualTo(2);
}
private static class InterruptFunction implements StarlarkCallable {
private int callCount = 0;
@Override
public String getName() {
return "interrupt";
}
@Override
public Object fastcall(
StarlarkThread thread, Location loc, Object[] positional, Object[] named) {
callCount++;
if (positional.length > 0 && Starlark.truth(positional[0])) {
Thread.currentThread().interrupt();
}
return Starlark.NONE;
}
}
private static StarlarkThread createStarlarkThread(
Mutability mutability, StarlarkThread.PrintHandler printHandler) {
StarlarkThread thread =
StarlarkThread.builder(mutability)
.useDefaultSemantics()
// Provide the UNIVERSE for print... this should not be necessary
.setGlobals(Module.createForBuiltins(Starlark.UNIVERSE))
.build();
thread.setPrintHandler(printHandler);
return thread;
}
@Test
public void testExprs() throws Exception {
newTest()
.testExpression("'%sx' % 'foo' + 'bar1'", "fooxbar1")
.testExpression("('%sx' % 'foo') + 'bar2'", "fooxbar2")
.testExpression("'%sx' % ('foo' + 'bar3')", "foobar3x")
.testExpression("123 + 456", 579)
.testExpression("456 - 123", 333)
.testExpression("8 % 3", 2)
.testIfErrorContains("unsupported binary operation: int % string", "3 % 'foo'")
.testExpression("-5", -5)
.testIfErrorContains("unsupported unary operation: -string", "-'foo'");
}
@Test
public void testListExprs() throws Exception {
newTest().testExactOrder("[1, 2, 3]", 1, 2, 3).testExactOrder("(1, 2, 3)", 1, 2, 3);
}
@Test
public void testStringFormatMultipleArgs() throws Exception {
newTest().testExpression("'%sY%s' % ('X', 'Z')", "XYZ");
}
@Test
public void testConditionalExpressions() throws Exception {
newTest()
.testExpression("1 if True else 2", 1)
.testExpression("1 if False else 2", 2)
.testExpression("1 + 2 if 3 + 4 else 5 + 6", 3);
}
@Test
public void testListComparison() throws Exception {
newTest()
.testExpression("[] < [1]", true)
.testExpression("[1] < [1, 1]", true)
.testExpression("[1, 1] < [1, 2]", true)
.testExpression("[1, 2] < [1, 2, 3]", true)
.testExpression("[1, 2, 3] <= [1, 2, 3]", true)
.testExpression("['a', 'b'] > ['a']", true)
.testExpression("['a', 'b'] >= ['a']", true)
.testExpression("['a', 'b'] < ['a']", false)
.testExpression("['a', 'b'] <= ['a']", false)
.testExpression("('a', 'b') > ('a', 'b')", false)
.testExpression("('a', 'b') >= ('a', 'b')", true)
.testExpression("('a', 'b') < ('a', 'b')", false)
.testExpression("('a', 'b') <= ('a', 'b')", true)
.testExpression("[[1, 1]] > [[1, 1], []]", false)
.testExpression("[[1, 1]] < [[1, 1], []]", true);
}
@Test
public void testSetComparison() throws Exception {
newTest().testIfExactError("Cannot compare depsets", "depset([1, 2]) < depset([3, 4])");
}
@Test
public void testSumFunction() throws Exception {
StarlarkCallable sum =
new StarlarkCallable() {
@Override
public String getName() {
return "sum";
}
@Override
public Object fastcall(
StarlarkThread thread, Location loc, Object[] positional, Object[] named) {
int sum = 0;
for (Object arg : positional) {
sum += (Integer) arg;
}
return sum;
}
};
newTest()
.update(sum.getName(), sum)
.testExpression("sum(1, 2, 3, 4, 5, 6)", 21)
.testExpression("sum", sum)
.testExpression("sum(a=1, b=2)", 0);
}
@Test
public void testNotCallInt() throws Exception {
newTest()
.setUp("sum = 123456")
.testLookup("sum", 123456)
.testIfExactError("'int' object is not callable", "sum(1, 2, 3, 4, 5, 6)")
.testExpression("sum", 123456);
}
@Test
public void testComplexFunctionCall() throws Exception {
newTest().setUp("functions = [min, max]", "l = [1,2]")
.testEval("(functions[0](l), functions[1](l))", "(1, 2)");
}
@Test
public void testKeywordArgs() throws Exception {
// This function returns the map of keyword arguments passed to it.
StarlarkCallable kwargs =
new StarlarkCallable() {
@Override
public String getName() {
return "kwargs";
}
@Override
public Object call(
StarlarkThread thread,
Location loc,
Tuple<Object> args,
Dict<String, Object> kwargs) {
return kwargs;
}
};
newTest()
.update(kwargs.getName(), kwargs)
.testEval(
"kwargs(foo=1, bar='bar', wiz=[1,2,3]).items()",
"[('foo', 1), ('bar', 'bar'), ('wiz', [1, 2, 3])]")
.testEval(
"kwargs(wiz=[1,2,3], bar='bar', foo=1).items()",
"[('wiz', [1, 2, 3]), ('bar', 'bar'), ('foo', 1)]");
}
@Test
public void testModulo() throws Exception {
newTest()
.testExpression("6 % 2", 0)
.testExpression("6 % 4", 2)
.testExpression("3 % 6", 3)
.testExpression("7 % -4", -1)
.testExpression("-7 % 4", 1)
.testExpression("-7 % -4", -3)
.testIfExactError("integer modulo by zero", "5 % 0");
}
@Test
public void testMult() throws Exception {
newTest()
.testExpression("6 * 7", 42)
.testExpression("3 * 'ab'", "ababab")
.testExpression("0 * 'ab'", "")
.testExpression("'1' + '0' * 5", "100000")
.testExpression("'ab' * -4", "")
.testExpression("-1 * ''", "");
}
@Test
public void testSlashOperatorIsForbidden() throws Exception {
newTest().testIfErrorContains("The `/` operator is not allowed.", "5 / 2");
}
@Test
public void testFloorDivision() throws Exception {
newTest()
.testExpression("6 // 2", 3)
.testExpression("6 // 4", 1)
.testExpression("3 // 6", 0)
.testExpression("7 // -2", -4)
.testExpression("-7 // 2", -4)
.testExpression("-7 // -2", 3)
.testExpression("2147483647 // 2", 1073741823)
.testIfErrorContains("unsupported binary operation: string // int", "'str' // 2")
.testIfExactError("integer division by zero", "5 // 0");
}
@Test
public void testCheckedArithmetic() throws Exception {
new SkylarkTest()
.testIfErrorContains("integer overflow", "2000000000 + 2000000000")
.testIfErrorContains("integer overflow", "1234567890 * 987654321")
.testIfErrorContains("integer overflow", "- 2000000000 - 2000000000")
// literal 2147483648 is not allowed, so we compute it
.setUp("minint = - 2147483647 - 1")
.testIfErrorContains("integer overflow", "-minint");
}
@Test
public void testOperatorPrecedence() throws Exception {
newTest()
.testExpression("2 + 3 * 4", 14)
.testExpression("2 + 3 // 4", 2)
.testExpression("2 * 3 + 4 // -2", 4);
}
@Test
public void testConcatStrings() throws Exception {
newTest().testExpression("'foo' + 'bar'", "foobar");
}
@SuppressWarnings("unchecked")
@Test
public void testConcatLists() throws Exception {
// TODO(fwe): cannot be handled by current testing suite
// list
Object x = eval("[1,2] + [3,4]");
assertThat((Iterable<Object>) x).containsExactly(1, 2, 3, 4).inOrder();
assertThat(x).isEqualTo(StarlarkList.of(thread.mutability(), 1, 2, 3, 4));
assertThat(EvalUtils.isImmutable(x)).isFalse();
// tuple
x = eval("(1,2) + (3,4)");
assertThat(x).isEqualTo(Tuple.of(1, 2, 3, 4));
assertThat(EvalUtils.isImmutable(x)).isTrue();
checkEvalError("unsupported binary operation: tuple + list", "(1,2) + [3,4]");
}
@Test
public void testListComprehensions() throws Exception {
newTest()
.testExactOrder("['foo/%s.java' % x for x in []]")
.testExactOrder("['foo/%s.java' % y for y in ['bar', 'wiz', 'quux']]", "foo/bar.java",
"foo/wiz.java", "foo/quux.java")
.testExactOrder("['%s/%s.java' % (z, t) for z in ['foo', 'bar'] "
+ "for t in ['baz', 'wiz', 'quux']]",
"foo/baz.java",
"foo/wiz.java",
"foo/quux.java",
"bar/baz.java",
"bar/wiz.java",
"bar/quux.java")
.testExactOrder("['%s/%s.java' % (b, b) for a in ['foo', 'bar'] "
+ "for b in ['baz', 'wiz', 'quux']]",
"baz/baz.java",
"wiz/wiz.java",
"quux/quux.java",
"baz/baz.java",
"wiz/wiz.java",
"quux/quux.java")
.testExactOrder("['%s/%s.%s' % (c, d, e) for c in ['foo', 'bar'] "
+ "for d in ['baz', 'wiz', 'quux'] for e in ['java', 'cc']]",
"foo/baz.java",
"foo/baz.cc",
"foo/wiz.java",
"foo/wiz.cc",
"foo/quux.java",
"foo/quux.cc",
"bar/baz.java",
"bar/baz.cc",
"bar/wiz.java",
"bar/wiz.cc",
"bar/quux.java",
"bar/quux.cc")
.testExactOrder("[i for i in (1, 2)]", 1, 2)
.testExactOrder("[i for i in [2, 3] or [1, 2]]", 2, 3);
}
@Test
public void testNestedListComprehensions() throws Exception {
newTest()
.setUp("li = [[1, 2], [3, 4]]")
.testExactOrder("[j for i in li for j in i]", 1, 2, 3, 4);
newTest()
.setUp("input = [['abc'], ['def', 'ghi']]\n")
.testExactOrder(
"['%s %s' % (b, c) for a in input for b in a for c in b.elems()]",
"abc a", "abc b", "abc c", "def d", "def e", "def f", "ghi g", "ghi h", "ghi i");
}
@Test
public void testListComprehensionsMultipleVariables() throws Exception {
newTest().testEval("[x + y for x, y in [(1, 2), (3, 4)]]", "[3, 7]")
.testEval("[z + t for (z, t) in [[1, 2], [3, 4]]]", "[3, 7]");
}
@Test
public void testListComprehensionsMultipleVariablesFail() throws Exception {
newTest()
.testIfErrorContains(
"assignment length mismatch: left-hand side has length 3, but right-hand side"
+ " evaluates to value of length 2",
"[x + y for x, y, z in [(1, 2), (3, 4)]]")
.testIfExactError("type 'int' is not iterable", "[x + y for x, y in (1, 2)]");
}
@Test
public void testListComprehensionsWithFiltering() throws Exception {
newTest()
.setUp("range3 = [0, 1, 2]")
.testEval("[a for a in (4, None, 2, None, 1) if a != None]", "[4, 2, 1]")
.testEval("[b+c for b in [0, 1, 2] for c in [0, 1, 2] if b + c > 2]", "[3, 3, 4]")
.testEval("[d+e for d in range3 if d % 2 == 1 for e in range3]", "[1, 2, 3]")
.testEval("[[f,g] for f in [0, 1, 2, 3, 4] if f for g in [5, 6, 7, 8] if f * g % 12 == 0 ]",
"[[2, 6], [3, 8], [4, 6]]")
.testEval("[h for h in [4, 2, 0, 1] if h]", "[4, 2, 1]");
}
@Test
public void testListComprehensionDefinitionOrder() throws Exception {
new BuildTest()
.testIfErrorContains("name 'y' is not defined", "[x for x in (1, 2) if y for y in (3, 4)]");
new SkylarkTest()
.testIfErrorContains(
"local variable 'y' is referenced before assignment",
"[x for x in (1, 2) if y for y in (3, 4)]");
}
@Test
public void testTupleDestructuring() throws Exception {
newTest()
.setUp("a, b = 1, 2")
.testLookup("a", 1)
.testLookup("b", 2)
.setUp("c, d = {'key1':2, 'key2':3}")
.testLookup("c", "key1")
.testLookup("d", "key2");
}
@Test
public void testSingleTuple() throws Exception {
newTest().setUp("(a,) = [1]").testLookup("a", 1);
}
@Test
public void testHeterogeneousDict() throws Exception {
newTest().setUp("d = {'str': 1, 2: 3}", "a = d['str']", "b = d[2]").testLookup("a", 1)
.testLookup("b", 3);
}
@Test
public void testAccessDictWithATupleKey() throws Exception {
newTest().setUp("x = {(1, 2): 3}[1, 2]").testLookup("x", 3);
}
@Test
public void testDictWithDuplicatedKey() throws Exception {
new SkylarkTest()
.testIfErrorContains(
"Duplicated key \"str\" when creating dictionary", "{'str': 1, 'x': 2, 'str': 3}");
}
@Test
public void testRecursiveTupleDestructuring() throws Exception {
newTest()
.setUp("((a, b), (c, d)) = [(1, 2), (3, 4)]")
.testLookup("a", 1)
.testLookup("b", 2)
.testLookup("c", 3)
.testLookup("d", 4);
}
@Test
public void testListComprehensionAtTopLevel() throws Exception {
// It is allowed to have a loop variable with the same name as a global variable.
newTest().update("x", 42).setUp("y = [x + 1 for x in [1,2,3]]")
.testExactOrder("y", 2, 3, 4);
}
@Test
public void testDictComprehensions() throws Exception {
newTest()
.testExpression("{a : a for a in []}", Collections.emptyMap())
.testExpression("{b : b for b in [1, 2]}", ImmutableMap.of(1, 1, 2, 2))
.testExpression(
"{c : 'v_' + c for c in ['a', 'b']}", ImmutableMap.of("a", "v_a", "b", "v_b"))
.testExpression(
"{'k_' + d : d for d in ['a', 'b']}", ImmutableMap.of("k_a", "a", "k_b", "b"))
.testExpression(
"{'k_' + e : 'v_' + e for e in ['a', 'b']}",
ImmutableMap.of("k_a", "v_a", "k_b", "v_b"))
.testExpression("{x+y : x*y for x, y in [[2, 3]]}", ImmutableMap.of(5, 6));
}
@Test
public void testDictComprehensionOnNonIterable() throws Exception {
newTest().testIfExactError("type 'int' is not iterable", "{k : k for k in 3}");
}
@Test
public void testDictComprehension_ManyClauses() throws Exception {
new SkylarkTest()
.testExpression(
"{x : x * y for x in range(1, 10) if x % 2 == 0 for y in range(1, 10) if y == x}",
ImmutableMap.of(2, 4, 4, 16, 6, 36, 8, 64));
}
@Test
public void testDictComprehensions_MultipleKey() throws Exception {
newTest()
.testExpression("{x : x for x in [1, 2, 1]}", ImmutableMap.of(1, 1, 2, 2))
.testExpression(
"{y : y for y in ['ab', 'c', 'a' + 'b']}", ImmutableMap.of("ab", "ab", "c", "c"));
}
@Test
public void testListConcatenation() throws Exception {
newTest()
.testExpression("[1, 2] + [3, 4]", StarlarkList.of(thread.mutability(), 1, 2, 3, 4))
.testExpression("(1, 2) + (3, 4)", Tuple.of(1, 2, 3, 4))
.testIfExactError("unsupported binary operation: list + tuple", "[1, 2] + (3, 4)")
.testIfExactError("unsupported binary operation: tuple + list", "(1, 2) + [3, 4]");
}
@Test
public void testListMultiply() throws Exception {
Mutability mu = thread.mutability();
newTest()
.testExpression("[1, 2, 3] * 1", StarlarkList.of(mu, 1, 2, 3))
.testExpression("[1, 2] * 2", StarlarkList.of(mu, 1, 2, 1, 2))
.testExpression("[1, 2] * 3", StarlarkList.of(mu, 1, 2, 1, 2, 1, 2))
.testExpression("[1, 2] * 4", StarlarkList.of(mu, 1, 2, 1, 2, 1, 2, 1, 2))
.testExpression("[8] * 5", StarlarkList.of(mu, 8, 8, 8, 8, 8))
.testExpression("[ ] * 10", StarlarkList.empty())
.testExpression("[1, 2] * 0", StarlarkList.empty())
.testExpression("[1, 2] * -4", StarlarkList.empty())
.testExpression("2 * [1, 2]", StarlarkList.of(mu, 1, 2, 1, 2))
.testExpression("10 * []", StarlarkList.empty())
.testExpression("0 * [1, 2]", StarlarkList.empty())
.testExpression("-4 * [1, 2]", StarlarkList.empty());
}
@Test
public void testTupleMultiply() throws Exception {
newTest()
.testExpression("(1, 2, 3) * 1", Tuple.of(1, 2, 3))
.testExpression("(1, 2) * 2", Tuple.of(1, 2, 1, 2))
.testExpression("(1, 2) * 3", Tuple.of(1, 2, 1, 2, 1, 2))
.testExpression("(1, 2) * 4", Tuple.of(1, 2, 1, 2, 1, 2, 1, 2))
.testExpression("(8,) * 5", Tuple.of(8, 8, 8, 8, 8))
.testExpression("( ) * 10", Tuple.empty())
.testExpression("(1, 2) * 0", Tuple.empty())
.testExpression("(1, 2) * -4", Tuple.empty())
.testExpression("2 * (1, 2)", Tuple.of(1, 2, 1, 2))
.testExpression("10 * ()", Tuple.empty())
.testExpression("0 * (1, 2)", Tuple.empty())
.testExpression("-4 * (1, 2)", Tuple.empty());
}
@SuppressWarnings("unchecked")
@Test
public void testSelectorListConcatenation() throws Exception {
// TODO(fwe): cannot be handled by current testing suite
SelectorList x = (SelectorList) eval("select({'foo': ['FOO'], 'bar': ['BAR']}) + []");
List<Object> elements = x.getElements();
assertThat(elements).hasSize(2);
assertThat(elements.get(0)).isInstanceOf(SelectorValue.class);
assertThat((Iterable<Object>) elements.get(1)).isEmpty();
}
@Test
public void testAddSelectIncompatibleType() throws Exception {
newTest()
.testIfErrorContains(
"'+' operator applied to incompatible types (select of list, int)",
"select({'foo': ['FOO'], 'bar': ['BAR']}) + 1");
}
@Test
public void testAddSelectIncompatibleType2() throws Exception {
newTest()
.testIfErrorContains(
"'+' operator applied to incompatible types (select of list, select of int)",
"select({'foo': ['FOO']}) + select({'bar': 2})");
}
@Test
public void testListComprehensionFailsOnNonSequence() throws Exception {
newTest().testIfErrorContains("type 'int' is not iterable", "[x + 1 for x in 123]");
}
@Test
public void testListComprehensionOnStringIsForbidden() throws Exception {
newTest().testIfErrorContains("type 'string' is not iterable", "[x for x in 'abc']");
}
@Test
public void testInvalidAssignment() throws Exception {
newTest().testIfErrorContains(
"cannot assign to 'x + 1'", "x + 1 = 2");
}
@Test
public void testListComprehensionOnDictionary() throws Exception {
newTest().testExactOrder("['var_' + n for n in {'a':1,'b':2}]", "var_a", "var_b");
}
@Test
public void testListComprehensionOnDictionaryCompositeExpression() throws Exception {
new BuildTest()
.setUp("d = {1:'a',2:'b'}", "l = [d[x] for x in d]")
.testLookup("l", StarlarkList.of(thread.mutability(), "a", "b"));
}
@Test
public void testListComprehensionUpdate() throws Exception {
new BuildTest()
.setUp("xs = [1, 2, 3]")
.testIfErrorContains("trying to mutate a locked object",
"[xs.append(4) for x in xs]");
}
@Test
public void testNestedListComprehensionUpdate() throws Exception {
new BuildTest()
.setUp("xs = [1, 2, 3]")
.testIfErrorContains("trying to mutate a locked object",
"[xs.append(4) for x in xs for y in xs]");
}
@Test
public void testListComprehensionUpdateInClause() throws Exception {
new BuildTest()
.setUp("xs = [1, 2, 3]")
.testIfErrorContains("trying to mutate a locked object",
// Use short-circuiting to produce valid output in the event
// the exception is not raised.
"[y for x in xs for y in (xs.append(4) or xs)]");
}
@Test
public void testDictComprehensionUpdate() throws Exception {
new BuildTest()
.setUp("xs = {1:1, 2:2, 3:3}")
.testIfErrorContains("trying to mutate a locked object",
"[xs.popitem() for x in xs]");
}
@Test
public void testListComprehensionScope() throws Exception {
// Test list comprehension creates a scope, so outer variables kept unchanged
new BuildTest()
.setUp("x = 1", "l = [x * 3 for x in [2]]", "y = x")
.testEval("y", "1")
.testEval("l", "[6]");
}
@Test
public void testInOperator() throws Exception {
newTest()
.testExpression("'b' in ['a', 'b']", Boolean.TRUE)
.testExpression("'c' in ['a', 'b']", Boolean.FALSE)
.testExpression("'b' in ('a', 'b')", Boolean.TRUE)
.testExpression("'c' in ('a', 'b')", Boolean.FALSE)
.testExpression("'b' in {'a' : 1, 'b' : 2}", Boolean.TRUE)
.testExpression("'c' in {'a' : 1, 'b' : 2}", Boolean.FALSE)
.testExpression("1 in {'a' : 1, 'b' : 2}", Boolean.FALSE)
.testExpression("'b' in 'abc'", Boolean.TRUE)
.testExpression("'d' in 'abc'", Boolean.FALSE);
}
@Test
public void testNotInOperator() throws Exception {
newTest()
.testExpression("'b' not in ['a', 'b']", Boolean.FALSE)
.testExpression("'c' not in ['a', 'b']", Boolean.TRUE)
.testExpression("'b' not in ('a', 'b')", Boolean.FALSE)
.testExpression("'c' not in ('a', 'b')", Boolean.TRUE)
.testExpression("'b' not in {'a' : 1, 'b' : 2}", Boolean.FALSE)
.testExpression("'c' not in {'a' : 1, 'b' : 2}", Boolean.TRUE)
.testExpression("1 not in {'a' : 1, 'b' : 2}", Boolean.TRUE)
.testExpression("'b' not in 'abc'", Boolean.FALSE)
.testExpression("'d' not in 'abc'", Boolean.TRUE);
}
@Test
public void testInFail() throws Exception {
newTest()
.testIfErrorContains(
"'in <string>' requires string as left operand, not 'int'", "1 in '123'")
.testIfErrorContains(
"unsupported binary operation: string in int (right operand must be", "'a' in 1");
}
@Test
public void testInCompositeForPrecedence() throws Exception {
newTest().testExpression("not 'a' in ['a'] or 0", 0);
}
private StarlarkValue createObjWithStr() {
return new StarlarkValue() {
@Override
public void repr(Printer printer) {
printer.append("<str marker>");
}
};
}
private static class Dummy implements StarlarkValue {}
@Test
public void testPercentOnDummyValue() throws Exception {
newTest().update("obj", createObjWithStr()).testExpression("'%s' % obj", "<str marker>");
newTest()
.update("unknown", new Dummy())
.testExpression(
"'%s' % unknown",
"<unknown object com.google.devtools.build.lib.syntax.EvaluationTest$Dummy>");
}
@Test
public void testPercentOnTupleOfDummyValues() throws Exception {
newTest()
.update("obj", createObjWithStr())
.testExpression("'%s %s' % (obj, obj)", "<str marker> <str marker>");
newTest()
.update("unknown", new Dummy())
.testExpression(
"'%s %s' % (unknown, unknown)",
"<unknown object com.google.devtools.build.lib.syntax.EvaluationTest$Dummy> <unknown"
+ " object com.google.devtools.build.lib.syntax.EvaluationTest$Dummy>");
}
@Test
public void testPercOnObjectInvalidFormat() throws Exception {
newTest()
.update("obj", createObjWithStr())
.testIfExactError("invalid argument <str marker> for format pattern %d", "'%d' % obj");
}
@Test
public void testDictKeys() throws Exception {
newTest().testExactOrder("{'a': 1}.keys() + ['b', 'c']", "a", "b", "c");
}
@Test
public void testDictKeysTooManyArgs() throws Exception {
newTest().testIfExactError("keys() got unexpected positional argument", "{'a': 1}.keys('abc')");
}
@Test
public void testDictKeysTooManyKeyArgs() throws Exception {
newTest()
.testIfExactError(
"keys() got unexpected keyword argument 'arg'", "{'a': 1}.keys(arg='abc')");
}
@Test
public void testDictKeysDuplicateKeyArgs() throws Exception {
// TODO(adonovan): when the duplication is literal, this should be caught by a static check.
newTest()
.testIfExactError(
"int() got multiple values for argument 'base'", "int('1', base=10, base=16)");
new SkylarkTest()
.testIfExactError(
"int() got multiple values for argument 'base'", "int('1', base=10, **dict(base=16))");
}
@Test
public void testArgBothPosKey() throws Exception {
newTest()
.testIfErrorContains(
"int() got multiple values for argument 'base'", "int('2', 3, base=3)");
}
@Test
public void testStaticNameResolution() throws Exception {
newTest().testIfErrorContains("name 'foo' is not defined", "[foo for x in []]");
}
@Test
public void testDefInBuild() throws Exception {
new BuildTest()
.testIfErrorContains(
"function definitions are not allowed in BUILD files", "def func(): pass");
}
@Test
public void testForStatementForbiddenInBuild() throws Exception {
new BuildTest().testIfErrorContains("for loops are not allowed", "for _ in []: pass");
}
@Test
public void testIfStatementForbiddenInBuild() throws Exception {
new BuildTest().testIfErrorContains("if statements are not allowed", "if False: pass");
}
@Test
public void testKwargsForbiddenInBuild() throws Exception {
new BuildTest()
.testIfErrorContains("**kwargs arguments are not allowed in BUILD files", "print(**dict)");
new BuildTest()
.testIfErrorContains(
"**kwargs arguments are not allowed in BUILD files", "len(dict(**{'a': 1}))");
}
@Test
public void testArgsForbiddenInBuild() throws Exception {
new BuildTest()
.testIfErrorContains("*args arguments are not allowed in BUILD files", "print(*['a'])");
}
}