| // 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 java.util.ArrayList; |
| import java.util.List; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** A test class for functions and scoping. */ |
| @RunWith(JUnit4.class) |
| public final class FunctionTest { |
| |
| private final EvaluationTestCase ev = new EvaluationTestCase(); |
| |
| @Test |
| public void testDef() throws Exception { |
| ev.exec("def f(a, b=1, *args, c, d=2, **kwargs): pass"); |
| StarlarkFunction f = (StarlarkFunction) ev.lookup("f"); |
| assertThat(f).isNotNull(); |
| assertThat(f.getName()).isEqualTo("f"); |
| assertThat(f.getParameterNames()) |
| .containsExactly("a", "b", "c", "d", "args", "kwargs") |
| .inOrder(); |
| assertThat(f.hasVarargs()).isTrue(); |
| assertThat(f.hasKwargs()).isTrue(); |
| assertThat(getDefaults(f)).containsExactly(null, 1, null, 2, null, null).inOrder(); |
| |
| // same, sans varargs |
| ev.exec("def g(a, b=1, *, c, d=2, **kwargs): pass"); |
| StarlarkFunction g = (StarlarkFunction) ev.lookup("g"); |
| assertThat(g.getParameterNames()).containsExactly("a", "b", "c", "d", "kwargs").inOrder(); |
| assertThat(g.hasVarargs()).isFalse(); |
| assertThat(g.hasKwargs()).isTrue(); |
| assertThat(getDefaults(g)).containsExactly(null, 1, null, 2, null).inOrder(); |
| } |
| |
| private static List<Object> getDefaults(StarlarkFunction fn) { |
| List<Object> defaults = new ArrayList<>(); |
| for (int i = 0; i < fn.getParameterNames().size(); i++) { |
| defaults.add(fn.getDefaultValue(i)); |
| } |
| return defaults; |
| } |
| |
| @Test |
| public void testFunctionDefCallOuterFunc() throws Exception { |
| List<Object> params = new ArrayList<>(); |
| createOuterFunction(params); |
| ev.exec( |
| "def func(a):", // |
| " outer_func(a)", |
| "func(1)", |
| "func(2)"); |
| assertThat(params).containsExactly(1, 2).inOrder(); |
| } |
| |
| private void createOuterFunction(final List<Object> params) throws Exception { |
| StarlarkCallable outerFunc = |
| new StarlarkCallable() { |
| @Override |
| public String getName() { |
| return "outer_func"; |
| } |
| |
| @Override |
| public NoneType call( |
| StarlarkThread thread, Tuple<Object> args, Dict<String, Object> kwargs) |
| throws EvalException { |
| params.addAll(args); |
| return Starlark.NONE; |
| } |
| }; |
| ev.update("outer_func", outerFunc); |
| } |
| |
| @Test |
| public void testFunctionDefNoEffectOutsideScope() throws Exception { |
| ev.update("a", 1); |
| ev.exec( |
| "def func():", // |
| " a = 2", |
| "func()\n"); |
| assertThat(ev.lookup("a")).isEqualTo(1); |
| } |
| |
| @Test |
| public void testFunctionDefGlobalVaribleReadInFunction() throws Exception { |
| ev.exec( |
| "a = 1", // |
| "def func():", |
| " b = a", |
| " return b", |
| "c = func()\n"); |
| assertThat(ev.lookup("c")).isEqualTo(1); |
| } |
| |
| @Test |
| public void testFunctionDefLocalGlobalScope() throws Exception { |
| ev.exec( |
| "a = 1", // |
| "def func():", |
| " a = 2", |
| " b = a", |
| " return b", |
| "c = func()\n"); |
| assertThat(ev.lookup("c")).isEqualTo(2); |
| } |
| |
| @Test |
| public void testFunctionDefLocalVariableReferencedBeforeAssignment() throws Exception { |
| ev.checkEvalErrorContains( |
| "local variable 'a' is referenced before assignment.", |
| "a = 1", |
| "def func():", |
| " b = a", |
| " a = 2", |
| " return b", |
| "c = func()\n"); |
| } |
| |
| @Test |
| public void testFunctionDefLocalVariableReferencedInCallBeforeAssignment() throws Exception { |
| ev.checkEvalErrorContains( |
| "local variable 'a' is referenced before assignment.", |
| "def dummy(x):", |
| " pass", |
| "a = 1", |
| "def func():", |
| " dummy(a)", |
| " a = 2", |
| "func()\n"); |
| } |
| |
| @Test |
| public void testFunctionDefLocalVariableReferencedAfterAssignment() throws Exception { |
| ev.exec( |
| "a = 1", // |
| "def func():", |
| " a = 2", |
| " b = a", |
| " a = 3", |
| " return b", |
| "c = func()\n"); |
| assertThat(ev.lookup("c")).isEqualTo(2); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Test |
| public void testStarlarkGlobalComprehensionIsAllowed() throws Exception { |
| ev.exec("a = [i for i in [1, 2, 3]]\n"); |
| assertThat((Iterable<Object>) ev.lookup("a")).containsExactly(1, 2, 3).inOrder(); |
| } |
| |
| @Test |
| public void testFunctionReturn() throws Exception { |
| ev.exec( |
| "def func():", // |
| " return 2", |
| "b = func()\n"); |
| assertThat(ev.lookup("b")).isEqualTo(2); |
| } |
| |
| @Test |
| public void testFunctionReturnFromALoop() throws Exception { |
| ev.exec( |
| "def func():", // |
| " for i in [1, 2, 3, 4, 5]:", |
| " return i", |
| "b = func()\n"); |
| assertThat(ev.lookup("b")).isEqualTo(1); |
| } |
| |
| @Test |
| public void testFunctionExecutesProperly() throws Exception { |
| ev.exec( |
| "def func(a):", |
| " b = 1", |
| " if a:", |
| " b = 2", |
| " return b", |
| "c = func(0)", |
| "d = func(1)\n"); |
| assertThat(ev.lookup("c")).isEqualTo(1); |
| assertThat(ev.lookup("d")).isEqualTo(2); |
| } |
| |
| @Test |
| public void testFunctionCallFromFunction() throws Exception { |
| final List<Object> params = new ArrayList<>(); |
| createOuterFunction(params); |
| ev.exec( |
| "def func2(a):", |
| " outer_func(a)", |
| "def func1(b):", |
| " func2(b)", |
| "func1(1)", |
| "func1(2)\n"); |
| assertThat(params).containsExactly(1, 2).inOrder(); |
| } |
| |
| @Test |
| public void testFunctionCallFromFunctionReadGlobalVar() throws Exception { |
| ev.exec( |
| "a = 1", // |
| "def func2():", |
| " return a", |
| "def func1():", |
| " return func2()", |
| "b = func1()\n"); |
| assertThat(ev.lookup("b")).isEqualTo(1); |
| } |
| |
| @Test |
| public void testFunctionParamCanShadowGlobalVarAfterGlobalVarIsRead() throws Exception { |
| ev.exec( |
| "a = 1", |
| "def func2(a):", |
| " return 0", |
| "def func1():", |
| " dummy = a", |
| " return func2(2)", |
| "b = func1()\n"); |
| assertThat(ev.lookup("b")).isEqualTo(0); |
| } |
| |
| @Test |
| public void testSingleLineFunction() throws Exception { |
| ev.exec( |
| "def func(): return 'a'", // |
| "s = func()\n"); |
| assertThat(ev.lookup("s")).isEqualTo("a"); |
| } |
| |
| @Test |
| public void testFunctionReturnsDictionary() throws Exception { |
| ev.exec( |
| "def func(): return {'a' : 1}", // |
| "d = func()", |
| "a = d['a']\n"); |
| assertThat(ev.lookup("a")).isEqualTo(1); |
| } |
| |
| @Test |
| public void testFunctionReturnsList() throws Exception { |
| ev.exec( |
| "def func(): return [1, 2, 3]", // |
| "d = func()", |
| "a = d[1]\n"); |
| assertThat(ev.lookup("a")).isEqualTo(2); |
| } |
| |
| @Test |
| public void testFunctionNameAliasing() throws Exception { |
| ev.exec( |
| "def func(a):", // |
| " return a + 1", |
| "alias = func", |
| "r = alias(1)"); |
| assertThat(ev.lookup("r")).isEqualTo(2); |
| } |
| |
| @Test |
| public void testCallingFunctionsWithMixedModeArgs() throws Exception { |
| ev.exec( |
| "def func(a, b, c):", // |
| " return a + b + c", |
| "v = func(1, c = 2, b = 3)"); |
| assertThat(ev.lookup("v")).isEqualTo(6); |
| } |
| |
| private String functionWithOptionalArgs() { |
| return "def func(a, b = None, c = None):\n" |
| + " r = a + 'a'\n" |
| + " if b:\n" |
| + " r += 'b'\n" |
| + " if c:\n" |
| + " r += 'c'\n" |
| + " return r\n"; |
| } |
| |
| @Test |
| public void testWhichOptionalArgsAreDefinedForFunctions() throws Exception { |
| ev.exec( |
| functionWithOptionalArgs(), |
| "v1 = func('1', 1, 1)", |
| "v2 = func(b = 2, a = '2', c = 2)", |
| "v3 = func('3')", |
| "v4 = func('4', c = 1)\n"); |
| assertThat(ev.lookup("v1")).isEqualTo("1abc"); |
| assertThat(ev.lookup("v2")).isEqualTo("2abc"); |
| assertThat(ev.lookup("v3")).isEqualTo("3a"); |
| assertThat(ev.lookup("v4")).isEqualTo("4ac"); |
| } |
| |
| @Test |
| public void testDefaultArguments() throws Exception { |
| ev.exec( |
| "def func(a, b = 'b', c = 'c'):", |
| " return a + b + c", |
| "v1 = func('a', 'x', 'y')", |
| "v2 = func(b = 'x', a = 'a', c = 'y')", |
| "v3 = func('a')", |
| "v4 = func('a', c = 'y')\n"); |
| assertThat(ev.lookup("v1")).isEqualTo("axy"); |
| assertThat(ev.lookup("v2")).isEqualTo("axy"); |
| assertThat(ev.lookup("v3")).isEqualTo("abc"); |
| assertThat(ev.lookup("v4")).isEqualTo("aby"); |
| } |
| |
| @Test |
| public void testDefaultArgumentsInsufficientArgNum() throws Exception { |
| ev.checkEvalError( |
| "func() missing 1 required positional argument: a", |
| "def func(a, b = 'b', c = 'c'):", |
| " return a + b + c", |
| "func()"); |
| } |
| |
| @Test |
| public void testArgsIsNotIterable() throws Exception { |
| ev.checkEvalError( |
| "argument after * must be an iterable, not int", |
| "def func1(a, b): return a + b", |
| "func1('a', *42)"); |
| |
| ev.checkEvalError( |
| "argument after * must be an iterable, not string", |
| "def func2(a, b): return a + b", |
| "func2('a', *'str')"); |
| } |
| |
| @Test |
| public void testKeywordOnly() throws Exception { |
| ev.checkEvalError( |
| "func() missing 1 required keyword-only argument: b", // |
| "def func(a, *, b): pass", |
| "func(5)"); |
| |
| ev.checkEvalError( |
| "func() accepts no more than 1 positional argument but got 2", |
| "def func(a, *, b): pass", |
| "func(5, 6)"); |
| |
| ev.exec("def func(a, *, b, c = 'c'): return a + b + c"); |
| assertThat(ev.eval("func('a', b = 'b')")).isEqualTo("abc"); |
| assertThat(ev.eval("func('a', b = 'b', c = 'd')")).isEqualTo("abd"); |
| } |
| |
| @Test |
| public void testStarArgsAndKeywordOnly() throws Exception { |
| ev.checkEvalError( |
| "func() missing 1 required keyword-only argument: b", |
| "def func(a, *args, b): pass", |
| "func(5)"); |
| |
| ev.checkEvalError( |
| "func() missing 1 required keyword-only argument: b", |
| "def func(a, *args, b): pass", |
| "func(5, 6)"); |
| |
| ev.exec("def func(a, *args, b, c = 'c'): return a + str(args) + b + c"); |
| assertThat(ev.eval("func('a', b = 'b')")).isEqualTo("a()bc"); |
| assertThat(ev.eval("func('a', b = 'b', c = 'd')")).isEqualTo("a()bd"); |
| assertThat(ev.eval("func('a', 1, 2, b = 'b')")).isEqualTo("a(1, 2)bc"); |
| assertThat(ev.eval("func('a', 1, 2, b = 'b', c = 'd')")).isEqualTo("a(1, 2)bd"); |
| } |
| |
| @Test |
| public void testCannotPassResidualsByName() throws Exception { |
| ev.checkEvalError( |
| "f() got unexpected keyword argument: args", "def f(*args): pass", "f(args=[])"); |
| |
| ev.exec("def f(**kwargs): return kwargs"); |
| assertThat(Starlark.repr(ev.eval("f(kwargs=1)"))).isEqualTo("{\"kwargs\": 1}"); |
| } |
| |
| @Test |
| public void testKeywordOnlyAfterStarArg() throws Exception { |
| ev.checkEvalError( |
| "func() missing 1 required keyword-only argument: c", |
| "def func(a, *b, c): pass", |
| "func(5)"); |
| |
| ev.checkEvalError( |
| "func() missing 1 required keyword-only argument: c", |
| "def func(a, *b, c): pass", |
| "func(5, 6, 7)"); |
| |
| ev.exec("def func(a, *b, c): return a + str(b) + c"); |
| assertThat(ev.eval("func('a', c = 'c')")).isEqualTo("a()c"); |
| assertThat(ev.eval("func('a', 1, c = 'c')")).isEqualTo("a(1,)c"); |
| assertThat(ev.eval("func('a', 1, 2, c = 'c')")).isEqualTo("a(1, 2)c"); |
| } |
| |
| @Test |
| public void testKwargsBadKey() throws Exception { |
| ev.checkEvalError( |
| "keywords must be strings, not int", // |
| "def func(a, b): return a + b", |
| "func('a', **{3: 1})"); |
| } |
| |
| @Test |
| public void testKwargsIsNotDict() throws Exception { |
| ev.checkEvalError( |
| "argument after ** must be a dict, not int", |
| "def func(a, b): return a + b", |
| "func('a', **42)"); |
| } |
| |
| @Test |
| public void testKwargsCollision() throws Exception { |
| ev.checkEvalError( |
| "func() got multiple values for parameter 'b'", |
| "def func(a, b): return a + b", |
| "func('a', 'b', **{'b': 'foo'})"); |
| } |
| |
| @Test |
| public void testKwargsCollisionWithNamed() throws Exception { |
| ev.checkEvalError( |
| "func() got multiple values for parameter 'b'", |
| "def func(a, b): return a + b", |
| "func('a', b = 'b', **{'b': 'foo'})"); |
| } |
| |
| @Test |
| public void testDefaultArguments2() throws Exception { |
| ev.exec( |
| "a = 2", |
| "def foo(x=a): return x", |
| "def bar():", |
| " a = 3", |
| " return foo()", |
| "v = bar()\n"); |
| assertThat(ev.lookup("v")).isEqualTo(2); |
| } |
| |
| @Test |
| public void testMixingPositionalOptional() throws Exception { |
| ev.exec( |
| "def f(name, value = '', optional = ''):", // |
| " return value", |
| "v = f('name', 'value')"); |
| assertThat(ev.lookup("v")).isEqualTo("value"); |
| } |
| |
| @Test |
| public void testStarArg() throws Exception { |
| ev.exec( |
| "def f(name, value = '1', optional = '2'): return name + value + optional", |
| "v1 = f(*['name', 'value'])", |
| "v2 = f('0', *['name', 'value'])", |
| "v3 = f('0', optional = '3', *['b'])", |
| "v4 = f(name='a', *[])\n"); |
| assertThat(ev.lookup("v1")).isEqualTo("namevalue2"); |
| assertThat(ev.lookup("v2")).isEqualTo("0namevalue"); |
| assertThat(ev.lookup("v3")).isEqualTo("0b3"); |
| assertThat(ev.lookup("v4")).isEqualTo("a12"); |
| } |
| |
| @Test |
| public void testStarParam() throws Exception { |
| ev.exec( |
| "def f(name, value = '1', optional = '2', *rest):", |
| " r = name + value + optional + '|'", |
| " for x in rest: r += x", |
| " return r", |
| "v1 = f('a', 'b', 'c', 'd', 'e')", |
| "v2 = f('a', optional='b', value='c')", |
| "v3 = f('a')"); |
| assertThat(ev.lookup("v1")).isEqualTo("abc|de"); |
| assertThat(ev.lookup("v2")).isEqualTo("acb|"); |
| assertThat(ev.lookup("v3")).isEqualTo("a12|"); |
| } |
| |
| @Test |
| public void testKwParam() throws Exception { |
| ev.exec( |
| "def foo(a, b, c=3, d=4, g=7, h=8, *args, **kwargs):\n" |
| + " return (a, b, c, d, g, h, args, kwargs)\n" |
| + "v1 = foo(1, 2)\n" |
| + "v2 = foo(1, h=9, i=0, *['x', 'y', 'z', 't'])\n" |
| + "v3 = foo(1, i=0, *[2, 3, 4, 5, 6, 7, 8])\n" |
| + "def bar(**kwargs):\n" |
| + " return kwargs\n" |
| + "b1 = bar(name='foo', type='jpg', version=42).items()\n" |
| + "b2 = bar()\n"); |
| |
| assertThat(Starlark.repr(ev.lookup("v1"))).isEqualTo("(1, 2, 3, 4, 7, 8, (), {})"); |
| assertThat(Starlark.repr(ev.lookup("v2"))) |
| .isEqualTo("(1, \"x\", \"y\", \"z\", \"t\", 9, (), {\"i\": 0})"); |
| assertThat(Starlark.repr(ev.lookup("v3"))).isEqualTo("(1, 2, 3, 4, 5, 6, (7, 8), {\"i\": 0})"); |
| assertThat(Starlark.repr(ev.lookup("b1"))) |
| .isEqualTo("[(\"name\", \"foo\"), (\"type\", \"jpg\"), (\"version\", 42)]"); |
| assertThat(Starlark.repr(ev.lookup("b2"))).isEqualTo("{}"); |
| } |
| |
| @Test |
| public void testTrailingCommas() throws Exception { |
| // Test that trailing commas are allowed in function definitions and calls |
| // even after last *args or **kwargs expressions, like python3 |
| ev.exec( |
| "def f(*args, **kwargs): pass\n" |
| + "v1 = f(1,)\n" |
| + "v2 = f(*(1,2),)\n" |
| + "v3 = f(a=1,)\n" |
| + "v4 = f(**{\"a\": 1},)\n"); |
| |
| assertThat(Starlark.repr(ev.lookup("v1"))).isEqualTo("None"); |
| assertThat(Starlark.repr(ev.lookup("v2"))).isEqualTo("None"); |
| assertThat(Starlark.repr(ev.lookup("v3"))).isEqualTo("None"); |
| assertThat(Starlark.repr(ev.lookup("v4"))).isEqualTo("None"); |
| } |
| |
| @Test |
| public void testCalls() throws Exception { |
| ev.exec("def f(a, b = None): return a, b"); |
| |
| assertThat(Starlark.repr(ev.eval("f(1)"))).isEqualTo("(1, None)"); |
| assertThat(Starlark.repr(ev.eval("f(1, 2)"))).isEqualTo("(1, 2)"); |
| assertThat(Starlark.repr(ev.eval("f(a=1)"))).isEqualTo("(1, None)"); |
| assertThat(Starlark.repr(ev.eval("f(a=1, b=2)"))).isEqualTo("(1, 2)"); |
| assertThat(Starlark.repr(ev.eval("f(b=2, a=1)"))).isEqualTo("(1, 2)"); |
| |
| ev.checkEvalError( |
| "f() missing 1 required positional argument: a", // |
| "f()"); |
| ev.checkEvalError( |
| "f() accepts no more than 2 positional arguments but got 3", // |
| "f(1, 2, 3)"); |
| ev.checkEvalError( |
| "f() got unexpected keyword arguments: c, d", // |
| "f(1, 2, c=3, d=4)"); |
| ev.checkEvalError( |
| "f() missing 1 required positional argument: a", // |
| "f(b=2)"); |
| ev.checkEvalError( |
| "f() missing 1 required positional argument: a", // |
| "f(b=2)"); |
| ev.checkEvalError( |
| "f() got multiple values for parameter 'a'", // |
| "f(2, a=1)"); |
| ev.checkEvalError( |
| "f() got unexpected keyword argument: c", // |
| "f(b=2, a=1, c=3)"); |
| |
| ev.exec("def g(*, one, two, three): pass"); |
| ev.checkEvalError( |
| "g() got unexpected keyword argument: tree (did you mean 'three'?)", // |
| "g(tree=3)"); |
| ev.checkEvalError( |
| "g() does not accept positional arguments, but got 3", // |
| "g(1, 2 ,3)"); |
| } |
| } |
