| // Copyright 2006 Google Inc. 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 org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import com.google.common.collect.Lists; |
| |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| import java.util.Arrays; |
| import java.util.IllegalFormatException; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * Test properties of the evaluator's datatypes and utility functions |
| * without actually creating any parse trees. |
| */ |
| @RunWith(JUnit4.class) |
| public class EvalUtilsTest { |
| |
| private static List<?> makeList(Object ...args) { |
| return EvalUtils.makeSequence(Arrays.<Object>asList(args), false); |
| } |
| private static List<?> makeTuple(Object ...args) { |
| return EvalUtils.makeSequence(Arrays.<Object>asList(args), true); |
| } |
| private static Map<Object, Object> makeDict() { |
| return new LinkedHashMap<>(); |
| } |
| private static FilesetEntry makeFilesetEntry() { |
| try { |
| return new FilesetEntry(Label.parseAbsolute("//foo:bar"), |
| Lists.<Label>newArrayList(), Lists.newArrayList("xyz"), "", |
| FilesetEntry.SymlinkBehavior.COPY, "."); |
| } catch (Label.SyntaxException e) { |
| throw new RuntimeException("Bad label: ", e); |
| } |
| } |
| |
| @Test |
| public void testDataTypeNames() throws Exception { |
| assertEquals("string", EvalUtils.getDataTypeName("foo")); |
| assertEquals("int", EvalUtils.getDataTypeName(3)); |
| assertEquals("Tuple", EvalUtils.getDataTypeName(makeTuple(1, 2, 3))); |
| assertEquals("List", EvalUtils.getDataTypeName(makeList(1, 2, 3))); |
| assertEquals("dict", EvalUtils.getDataTypeName(makeDict())); |
| assertEquals("FilesetEntry", EvalUtils.getDataTypeName(makeFilesetEntry())); |
| assertEquals("None", EvalUtils.getDataTypeName(Environment.NONE)); |
| } |
| |
| @Test |
| public void testDatatypeMutability() throws Exception { |
| assertTrue(EvalUtils.isImmutable("foo")); |
| assertTrue(EvalUtils.isImmutable(3)); |
| assertTrue(EvalUtils.isImmutable(makeTuple(1, 2, 3))); |
| assertFalse(EvalUtils.isImmutable(makeList(1, 2, 3))); |
| assertFalse(EvalUtils.isImmutable(makeDict())); |
| assertFalse(EvalUtils.isImmutable(makeFilesetEntry())); |
| } |
| |
| @Test |
| public void testPrintValue() throws Exception { |
| // Note that prettyPrintValue and printValue only differ on behaviour of |
| // labels and strings at toplevel. |
| assertEquals("foo\nbar", EvalUtils.printValue("foo\nbar")); |
| assertEquals("\"foo\\nbar\"", EvalUtils.prettyPrintValue("foo\nbar")); |
| assertEquals("'", EvalUtils.printValue("'")); |
| assertEquals("\"'\"", EvalUtils.prettyPrintValue("'")); |
| assertEquals("\"", EvalUtils.printValue("\"")); |
| assertEquals("\"\\\"\"", EvalUtils.prettyPrintValue("\"")); |
| assertEquals("3", EvalUtils.printValue(3)); |
| assertEquals("3", EvalUtils.prettyPrintValue(3)); |
| assertEquals("None", EvalUtils.prettyPrintValue(Environment.NONE)); |
| |
| assertEquals("//x:x", EvalUtils.printValue(Label.parseAbsolute("//x"))); |
| assertEquals("\"//x:x\"", EvalUtils.prettyPrintValue(Label.parseAbsolute("//x"))); |
| |
| List<?> list = makeList("foo", "bar"); |
| List<?> tuple = makeTuple("foo", "bar"); |
| |
| assertEquals("(1, [\"foo\", \"bar\"], 3)", |
| EvalUtils.printValue(makeTuple(1, list, 3))); |
| assertEquals("(1, [\"foo\", \"bar\"], 3)", |
| EvalUtils.prettyPrintValue(makeTuple(1, list, 3))); |
| assertEquals("[1, (\"foo\", \"bar\"), 3]", |
| EvalUtils.printValue(makeList(1, tuple, 3))); |
| assertEquals("[1, (\"foo\", \"bar\"), 3]", |
| EvalUtils.prettyPrintValue(makeList(1, tuple, 3))); |
| |
| Map<Object, Object> dict = makeDict(); |
| dict.put(1, tuple); |
| dict.put(2, list); |
| dict.put("foo", makeList()); |
| assertEquals("{1: (\"foo\", \"bar\"), 2: [\"foo\", \"bar\"], \"foo\": []}", |
| EvalUtils.printValue(dict)); |
| assertEquals("{1: (\"foo\", \"bar\"), 2: [\"foo\", \"bar\"], \"foo\": []}", |
| EvalUtils.prettyPrintValue(dict)); |
| assertEquals("FilesetEntry(srcdir = \"//foo:bar\", files = [], " |
| + "excludes = [\"xyz\"], destdir = \"\", " |
| + "strip_prefix = \".\", symlinks = \"copy\")", |
| EvalUtils.prettyPrintValue(makeFilesetEntry())); |
| } |
| |
| private void checkFormatPositionalFails(String format, List<?> tuple, |
| String errorMessage) { |
| try { |
| EvalUtils.formatString(format, tuple); |
| fail(); |
| } catch (IllegalFormatException e) { |
| assertEquals(errorMessage, e.getMessage()); |
| } |
| } |
| |
| @Test |
| public void testFormatPositional() throws Exception { |
| assertEquals("foo 3", EvalUtils.formatString("%s %d", makeTuple("foo", 3))); |
| |
| // Note: formatString doesn't perform scalar x -> (x) conversion; |
| // The %-operator is responsible for that. |
| assertThat(EvalUtils.formatString("", makeTuple())).isEmpty(); |
| assertEquals("foo", EvalUtils.formatString("%s", makeTuple("foo"))); |
| assertEquals("3.14159", EvalUtils.formatString("%s", makeTuple(3.14159))); |
| checkFormatPositionalFails("%s", makeTuple(1, 2, 3), |
| "not all arguments converted during string formatting"); |
| assertEquals("%foo", EvalUtils.formatString("%%%s", makeTuple("foo"))); |
| checkFormatPositionalFails("%%s", makeTuple("foo"), |
| "not all arguments converted during string formatting"); |
| checkFormatPositionalFails("% %s", makeTuple("foo"), |
| "invalid arguments for format string"); |
| assertEquals("[1, 2, 3]", EvalUtils.formatString("%s", makeTuple(makeList(1, 2, 3)))); |
| assertEquals("(1, 2, 3)", EvalUtils.formatString("%s", makeTuple(makeTuple(1, 2, 3)))); |
| assertEquals("[]", EvalUtils.formatString("%s", makeTuple(makeList()))); |
| assertEquals("()", EvalUtils.formatString("%s", makeTuple(makeTuple()))); |
| |
| checkFormatPositionalFails("%.3g", makeTuple(), "invalid arguments for format string"); |
| checkFormatPositionalFails("%.3g", makeTuple(1, 2), "invalid arguments for format string"); |
| checkFormatPositionalFails("%.s", makeTuple(), "invalid arguments for format string"); |
| } |
| |
| private String createExpectedFilesetEntryString(FilesetEntry.SymlinkBehavior symlinkBehavior) { |
| return "FilesetEntry(srcdir = \"//x:x\"," |
| + " files = [\"//x:x\"]," |
| + " excludes = []," |
| + " destdir = \"\"," |
| + " strip_prefix = \".\"," |
| + " symlinks = \"" + symlinkBehavior.toString().toLowerCase() + "\")"; |
| } |
| |
| private FilesetEntry createTestFilesetEntry(FilesetEntry.SymlinkBehavior symlinkBehavior) |
| throws Exception { |
| Label label = Label.parseAbsolute("//x"); |
| return new FilesetEntry(label, |
| Arrays.asList(label), |
| Arrays.<String>asList(), |
| "", |
| symlinkBehavior, |
| "."); |
| } |
| |
| @Test |
| public void testFilesetEntrySymlinkAttr() throws Exception { |
| FilesetEntry entryDereference = |
| createTestFilesetEntry(FilesetEntry.SymlinkBehavior.DEREFERENCE); |
| |
| assertEquals(createExpectedFilesetEntryString(FilesetEntry.SymlinkBehavior.DEREFERENCE), |
| EvalUtils.prettyPrintValue(entryDereference)); |
| } |
| |
| private FilesetEntry createStripPrefixFilesetEntry(String stripPrefix) throws Exception { |
| Label label = Label.parseAbsolute("//x"); |
| return new FilesetEntry( |
| label, |
| Arrays.asList(label), |
| Arrays.<String>asList(), |
| "", |
| FilesetEntry.SymlinkBehavior.DEREFERENCE, |
| stripPrefix); |
| } |
| |
| @Test |
| public void testFilesetEntryStripPrefixAttr() throws Exception { |
| FilesetEntry withoutStripPrefix = createStripPrefixFilesetEntry("."); |
| FilesetEntry withStripPrefix = createStripPrefixFilesetEntry("orange"); |
| |
| String prettyWithout = EvalUtils.prettyPrintValue(withoutStripPrefix); |
| String prettyWith = EvalUtils.prettyPrintValue(withStripPrefix); |
| |
| assertThat(prettyWithout).contains("strip_prefix = \".\""); |
| assertThat(prettyWith).contains("strip_prefix = \"orange\""); |
| } |
| |
| @Test |
| public void testRegressionCrashInPrettyPrintValue() throws Exception { |
| // Would cause crash in code such as this: |
| // Fileset(name='x', entries=[], out=[FilesetEntry(files=['a'])]) |
| // While formatting the "expected x, got y" message for the 'out' |
| // attribute, prettyPrintValue(FilesetEntry) would be recursively called |
| // with a List<Label> even though this isn't a valid datatype in the |
| // interpreter. |
| // Fileset isn't part of bazel, even though FilesetEntry is. |
| Label label = Label.parseAbsolute("//x"); |
| assertEquals("FilesetEntry(srcdir = \"//x:x\"," |
| + " files = [\"//x:x\"]," |
| + " excludes = []," |
| + " destdir = \"\"," |
| + " strip_prefix = \".\"," |
| + " symlinks = \"copy\")", |
| EvalUtils.prettyPrintValue( |
| new FilesetEntry(label, |
| Arrays.asList(label), |
| Arrays.<String>asList(), |
| "", |
| FilesetEntry.SymlinkBehavior.COPY, |
| "."))); |
| } |
| } |