diff options
Diffstat (limited to 'src/test/java/com/google/devtools/build/lib/syntax')
3 files changed, 561 insertions, 106 deletions
diff --git a/src/test/java/com/google/devtools/build/lib/syntax/EvalUtilsTest.java b/src/test/java/com/google/devtools/build/lib/syntax/EvalUtilsTest.java index bcad177f47..4969d6cb7b 100644 --- a/src/test/java/com/google/devtools/build/lib/syntax/EvalUtilsTest.java +++ b/src/test/java/com/google/devtools/build/lib/syntax/EvalUtilsTest.java @@ -19,9 +19,6 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import com.google.common.collect.Lists; -import com.google.devtools.build.lib.cmdline.LabelSyntaxException; - import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @@ -51,16 +48,6 @@ public class EvalUtilsTest { 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 (LabelSyntaxException e) { - throw new RuntimeException("Bad label: ", e); - } - } - @Test public void testDataTypeNames() throws Exception { assertEquals("string", EvalUtils.getDataTypeName("foo")); @@ -68,7 +55,6 @@ public class EvalUtilsTest { 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("NoneType", EvalUtils.getDataTypeName(Runtime.NONE)); } @@ -79,7 +65,6 @@ public class EvalUtilsTest { assertTrue(EvalUtils.isImmutable(makeTuple(1, 2, 3))); assertFalse(EvalUtils.isImmutable(makeList(1, 2, 3))); assertFalse(EvalUtils.isImmutable(makeDict())); - assertFalse(EvalUtils.isImmutable(makeFilesetEntry())); } @Test diff --git a/src/test/java/com/google/devtools/build/lib/syntax/PrinterTest.java b/src/test/java/com/google/devtools/build/lib/syntax/PrinterTest.java index 63d52368a6..f1576ddfb2 100644 --- a/src/test/java/com/google/devtools/build/lib/syntax/PrinterTest.java +++ b/src/test/java/com/google/devtools/build/lib/syntax/PrinterTest.java @@ -19,8 +19,6 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; import com.google.common.collect.ImmutableMap; -import com.google.common.collect.Lists; -import com.google.devtools.build.lib.cmdline.LabelSyntaxException; import org.junit.Test; import org.junit.runner.RunWith; @@ -47,16 +45,6 @@ public class PrinterTest { return EvalUtils.makeSequence(Arrays.<Object>asList(args), true); } - private static FilesetEntry makeFilesetEntry() { - try { - return new FilesetEntry(Label.parseAbsolute("//foo:bar"), - Lists.<Label>newArrayList(), Lists.newArrayList("xyz"), "", - FilesetEntry.SymlinkBehavior.COPY, "."); - } catch (LabelSyntaxException e) { - throw new RuntimeException("Bad label: ", e); - } - } - @Test public void testPrinter() throws Exception { // Note that prettyPrintValue and printValue only differ on behaviour of @@ -94,10 +82,6 @@ public class PrinterTest { Printer.str(dict)); assertEquals("{1: (\"foo\", \"bar\"), 2: [\"foo\", \"bar\"], \"foo\": []}", Printer.repr(dict)); - assertEquals("FilesetEntry(srcdir = \"//foo:bar\", files = [], " - + "excludes = [\"xyz\"], destdir = \"\", " - + "strip_prefix = \".\", symlinks = \"copy\")", - Printer.repr(makeFilesetEntry())); } private void checkFormatPositionalFails(String errorMessage, String format, Object... arguments) { @@ -155,51 +139,6 @@ public class PrinterTest { } @Test - public void testFilesetEntrySymlinkAttr() throws Exception { - FilesetEntry entryDereference = - createTestFilesetEntry(FilesetEntry.SymlinkBehavior.DEREFERENCE); - - assertEquals( - createExpectedFilesetEntryString(FilesetEntry.SymlinkBehavior.DEREFERENCE, '"'), - Printer.repr(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 = Printer.repr(withoutStripPrefix); - String prettyWith = Printer.repr(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. - assertEquals(createExpectedFilesetEntryString('"'), Printer.repr(createTestFilesetEntry())); - } - - @Test public void testSingleQuotes() throws Exception { assertThat(Printer.str("test", '\'')).isEqualTo("test"); assertThat(Printer.repr("test", '\'')).isEqualTo("'test'"); @@ -223,35 +162,5 @@ public class PrinterTest { .isEqualTo("{1: ('foo', 'bar'), 2: ['foo', 'bar'], 'foo': []}"); assertThat(Printer.repr(dict, '\'')) .isEqualTo("{1: ('foo', 'bar'), 2: ['foo', 'bar'], 'foo': []}"); - - assertThat(Printer.repr(createTestFilesetEntry(), '\'')) - .isEqualTo(createExpectedFilesetEntryString('\'')); - } - - private String createExpectedFilesetEntryString( - FilesetEntry.SymlinkBehavior symlinkBehavior, char quotationMark) { - return String.format( - "FilesetEntry(srcdir = %1$c//x:x%1$c," - + " files = [%1$c//x:x%1$c]," - + " excludes = []," - + " destdir = %1$c%1$c," - + " strip_prefix = %1$c.%1$c," - + " symlinks = %1$c%2$s%1$c)", - quotationMark, symlinkBehavior.toString().toLowerCase()); - } - - private String createExpectedFilesetEntryString(char quotationMark) { - return createExpectedFilesetEntryString(FilesetEntry.SymlinkBehavior.COPY, quotationMark); - } - - private FilesetEntry createTestFilesetEntry(FilesetEntry.SymlinkBehavior symlinkBehavior) - throws LabelSyntaxException { - Label label = Label.parseAbsolute("//x"); - return new FilesetEntry( - label, Arrays.asList(label), Arrays.<String>asList(), "", symlinkBehavior, "."); - } - - private FilesetEntry createTestFilesetEntry() throws LabelSyntaxException { - return createTestFilesetEntry(FilesetEntry.SymlinkBehavior.COPY); } } diff --git a/src/test/java/com/google/devtools/build/lib/syntax/TypeTest.java b/src/test/java/com/google/devtools/build/lib/syntax/TypeTest.java new file mode 100644 index 0000000000..712001d65b --- /dev/null +++ b/src/test/java/com/google/devtools/build/lib/syntax/TypeTest.java @@ -0,0 +1,561 @@ +// Copyright 2006-2015 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 com.google.devtools.build.lib.testutil.MoreAsserts.assertSameContents; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import com.google.devtools.build.lib.packages.BuildType; +import com.google.devtools.build.lib.packages.License; +import com.google.devtools.build.lib.packages.TriState; +import com.google.devtools.build.lib.syntax.Type.ConversionException; +import com.google.devtools.build.lib.testutil.MoreAsserts; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +/** + * Test of type-conversions using Type. + */ +@RunWith(JUnit4.class) +public class TypeTest { + + private Label currentRule; + + @Before + public void setUp() throws Exception { + this.currentRule = Label.parseAbsolute("//quux:baz"); + } + + @Test + public void testInteger() throws Exception { + Object x = 3; + assertEquals(x, Type.INTEGER.convert(x, null)); + assertThat(Type.INTEGER.flatten(x)).isEmpty(); + } + + @Test + public void testNonInteger() throws Exception { + try { + Type.INTEGER.convert("foo", null); + fail(); + } catch (Type.ConversionException e) { + // This does not use assertMessageContainsWordsWithQuotes because at least + // one test should test exact wording (but they all shouldn't to make + // changing/improving the messages easy). + assertThat(e).hasMessage("expected value of type 'int', but got \"foo\" (string)"); + } + } + + // Ensure that types are reported correctly. + @Test + public void testTypeErrorMessage() throws Exception { + try { + Type.STRING_LIST.convert("[(1,2), 3, 4]", "myexpr", null); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'list(string)' for myexpr, " + + "but got \"[(1,2), 3, 4]\" (string)"); + } + } + + @Test + public void testString() throws Exception { + Object s = "foo"; + assertEquals(s, Type.STRING.convert(s, null)); + assertThat(Type.STRING.flatten(s)).isEmpty(); + } + + @Test + public void testNonString() throws Exception { + try { + Type.STRING.convert(3, null); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'string', but got 3 (int)"); + } + } + + @Test + public void testBoolean() throws Exception { + Object myTrue = true; + Object myFalse = false; + assertEquals(Boolean.TRUE, Type.BOOLEAN.convert(1, null)); + assertEquals(Boolean.FALSE, Type.BOOLEAN.convert(0, null)); + assertTrue(Type.BOOLEAN.convert(true, null)); + assertTrue(Type.BOOLEAN.convert(myTrue, null)); + assertFalse(Type.BOOLEAN.convert(false, null)); + assertFalse(Type.BOOLEAN.convert(myFalse, null)); + assertThat(Type.BOOLEAN.flatten(myTrue)).isEmpty(); + } + + @Test + public void testNonBoolean() throws Exception { + try { + Type.BOOLEAN.convert("unexpected", null); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage( + "expected value of type 'int', but got \"unexpected\" (string)"); + } + // Integers other than [0, 1] should fail. + try { + Type.BOOLEAN.convert(2, null); + fail(); + } catch (Type.ConversionException e) { + assertEquals(e.getMessage(), "boolean is not one of [0, 1]"); + } + try { + Type.BOOLEAN.convert(-1, null); + fail(); + } catch (Type.ConversionException e) { + assertEquals(e.getMessage(), "boolean is not one of [0, 1]"); + } + } + + @Test + public void testTriState() throws Exception { + Assert.assertEquals(TriState.YES, BuildType.TRISTATE.convert(1, null)); + assertEquals(TriState.NO, BuildType.TRISTATE.convert(0, null)); + assertEquals(TriState.AUTO, BuildType.TRISTATE.convert(-1, null)); + assertEquals(TriState.YES, BuildType.TRISTATE.convert(true, null)); + assertEquals(TriState.NO, BuildType.TRISTATE.convert(false, null)); + assertEquals(TriState.YES, BuildType.TRISTATE.convert(TriState.YES, null)); + assertEquals(TriState.NO, BuildType.TRISTATE.convert(TriState.NO, null)); + assertEquals(TriState.AUTO, BuildType.TRISTATE.convert(TriState.AUTO, null)); + assertThat(BuildType.TRISTATE.flatten(TriState.YES)).isEmpty(); + } + + @Test + public void testTriStateDoesNotAcceptArbitraryIntegers() throws Exception { + List<Integer> listOfCases = Lists.newArrayList(2, 3, -5, -2, 20); + for (Object entry : listOfCases) { + try { + BuildType.TRISTATE.convert(entry, null); + fail(); + } catch (Type.ConversionException e) { + // Expected. + } + } + } + + @Test + public void testTriStateDoesNotAcceptStrings() throws Exception { + List<String> listOfCases = Lists.newArrayList("bad", "true", "auto", "false"); + for (Object entry : listOfCases) { + try { + BuildType.TRISTATE.convert(entry, null); + fail(); + } catch (Type.ConversionException e) { + // Expected. + } + } + } + + @Test + public void testTagConversion() throws Exception { + assertSameContents(Sets.newHashSet("attribute"), + Type.BOOLEAN.toTagSet(true, "attribute")); + assertSameContents(Sets.newHashSet("noattribute"), + Type.BOOLEAN.toTagSet(false, "attribute")); + + assertSameContents(Sets.newHashSet("whiskey"), + Type.STRING.toTagSet("whiskey", "preferred_cocktail")); + + assertSameContents(Sets.newHashSet("cheddar", "ementaler", "gruyere"), + Type.STRING_LIST.toTagSet( + Lists.newArrayList("cheddar", "ementaler", "gruyere"), "cheeses")); + } + + @Test + public void testIllegalTagConversionByType() throws Exception { + try { + BuildType.TRISTATE.toTagSet(TriState.AUTO, "some_tristate"); + fail("Expect UnsuportedOperationException"); + } catch (UnsupportedOperationException e) { + // Success. + } + try { + BuildType.LICENSE.toTagSet(License.NO_LICENSE, "output_license"); + fail("Expect UnsuportedOperationException"); + } catch (UnsupportedOperationException e) { + // Success. + } + } + + @Test + public void testIllegalTagConversIonFromNullOnSupportedType() throws Exception { + try { + Type.BOOLEAN.toTagSet(null, "a_boolean"); + fail("Expect UnsuportedOperationException"); + } catch (IllegalStateException e) { + // Success. + } + } + + @Test + public void testLabel() throws Exception { + Label label = Label.parseAbsolute("//foo:bar"); + assertEquals(label, BuildType.LABEL.convert("//foo:bar", null, currentRule)); + assertThat(BuildType.LABEL.flatten(label)).containsExactly(label); + } + + @Test + public void testNodepLabel() throws Exception { + Label label = Label.parseAbsolute("//foo:bar"); + assertEquals(label, BuildType.NODEP_LABEL.convert("//foo:bar", null, currentRule)); + assertThat(BuildType.NODEP_LABEL.flatten(label)).containsExactly(label); + } + + @Test + public void testRelativeLabel() throws Exception { + assertEquals(Label.parseAbsolute("//quux:wiz"), + BuildType.LABEL.convert(":wiz", null, currentRule)); + assertEquals(Label.parseAbsolute("//quux:wiz"), + BuildType.LABEL.convert("wiz", null, currentRule)); + try { + BuildType.LABEL.convert("wiz", null); + fail(); + } catch (NullPointerException e) { + /* ok */ + } + } + + @Test + public void testInvalidLabel() throws Exception { + try { + BuildType.LABEL.convert("not a label", null, currentRule); + fail(); + } catch (Type.ConversionException e) { + MoreAsserts.assertContainsWordsWithQuotes(e.getMessage(), "not a label"); + } + } + + @Test + public void testNonLabel() throws Exception { + try { + BuildType.LABEL.convert(3, null); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'string', but got 3 (int)"); + } + } + + @Test + public void testStringList() throws Exception { + Object input = Arrays.asList("foo", "bar", "wiz"); + List<String> converted = + Type.STRING_LIST.convert(input, null); + assertEquals(input, converted); + assertNotSame(input, converted); + assertThat(Type.STRING_LIST.flatten(input)).isEmpty(); + } + + @Test + public void testStringDict() throws Exception { + Object input = ImmutableMap.of("foo", "bar", + "wiz", "bang"); + Map<String, String> converted = Type.STRING_DICT.convert(input, null); + assertEquals(input, converted); + assertNotSame(input, converted); + assertThat(Type.STRING_DICT.flatten(converted)).isEmpty(); + } + + @Test + public void testStringDictBadElements() throws Exception { + Object input = ImmutableMap.of("foo", Arrays.asList("bar", "baz"), + "wiz", "bang"); + try { + Type.STRING_DICT.convert(input, null); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'string' for dict value element, " + + "but got [\"bar\", \"baz\"] (List)"); + } + } + + @Test + public void testNonStringList() throws Exception { + try { + Type.STRING_LIST.convert(3, "blah"); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'list(string)' for blah, but got 3 (int)"); + } + } + + @Test + public void testStringListBadElements() throws Exception { + Object input = Arrays.<Object>asList("foo", "bar", 1); + try { + Type.STRING_LIST.convert(input, "argument quux"); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage( + "expected value of type 'string' for element 2 of argument quux, but got 1 (int)"); + } + } + + @Test + public void testLabelList() throws Exception { + Object input = Arrays.asList("//foo:bar", ":wiz"); + List<Label> converted = + BuildType.LABEL_LIST.convert(input , null, currentRule); + List<Label> expected = + Arrays.asList(Label.parseAbsolute("//foo:bar"), + Label.parseAbsolute("//quux:wiz")); + assertEquals(expected, converted); + assertNotSame(expected, converted); + assertThat(BuildType.LABEL_LIST.flatten(converted)).containsExactlyElementsIn(expected); + } + + @Test + public void testNonLabelList() throws Exception { + try { + BuildType.LABEL_LIST.convert(3, "foo", currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'list(label)' for foo, but got 3 (int)"); + } + } + + @Test + public void testLabelListBadElements() throws Exception { + Object list = Arrays.<Object>asList("//foo:bar", 2, "foo"); + try { + BuildType.LABEL_LIST.convert(list, null, currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage( + "expected value of type 'string' for element 1 of null, but got 2 (int)"); + } + } + + @Test + public void testLabelListSyntaxError() throws Exception { + Object list = Arrays.<Object>asList("//foo:bar/..", "foo"); + try { + BuildType.LABEL_LIST.convert(list, "myexpr", currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("invalid label '//foo:bar/..' in element 0 of myexpr: " + + "invalid target name 'bar/..': " + + "target names may not contain up-level references '..'"); + } + } + + @Test + public void testLabelListDict() throws Exception { + Object input = ImmutableMap.of("foo", Arrays.asList("//foo:bar"), + "wiz", Arrays.asList(":bang")); + Map<String, List<Label>> converted = + BuildType.LABEL_LIST_DICT.convert(input, null, currentRule); + Label fooLabel = Label.parseAbsolute("//foo:bar"); + Label bangLabel = Label.parseAbsolute("//quux:bang"); + Map<?, ?> expected = ImmutableMap.<String, List<Label>>of( + "foo", Arrays.<Label>asList(fooLabel), + "wiz", Arrays.<Label>asList(bangLabel)); + assertEquals(expected, converted); + assertNotSame(expected, converted); + assertThat(BuildType.LABEL_LIST_DICT.flatten(converted)).containsExactly(fooLabel, bangLabel); + } + + @Test + public void testLabelListDictBadFirstElement() throws Exception { + Object input = ImmutableMap.of(2, Arrays.asList("//foo:bar"), + "wiz", Arrays.asList(":bang")); + try { + BuildType.LABEL_LIST_DICT.convert(input, null, currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage( + "expected value of type 'string' for dict key element, but got 2 (int)"); + } + } + + @Test + public void testLabelListDictBadSecondElement() throws Exception { + Object input = ImmutableMap.of("foo", "//foo:bar", + "wiz", Arrays.asList(":bang")); + try { + BuildType.LABEL_LIST_DICT.convert(input, null, currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage( + "expected value of type 'list(label)' for dict value element, " + + "but got \"//foo:bar\" (string)"); + } + } + + @Test + public void testLabelListDictBadElements1() throws Exception { + Object input = ImmutableMap.of("foo", "bar", + "bar", Arrays.asList("//foo:bar"), + "wiz", Arrays.asList(":bang")); + try { + BuildType.LABEL_LIST_DICT.convert(input, null); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'list(label)' for dict value element, " + + "but got \"bar\" (string)"); + } + } + + @Test + public void testLabelListDictSyntaxError() throws Exception { + Object input = ImmutableMap.of("foo", Arrays.asList("//foo:.."), + "wiz", Arrays.asList(":bang")); + try { + BuildType.LABEL_LIST_DICT.convert(input, "baz", currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("invalid label '//foo:..' in element 0 of dict value element: " + + "invalid target name '..': " + + "target names may not contain up-level references '..'"); + } + } + + @Test + public void testStringListDict() throws Exception { + Object input = ImmutableMap.of("foo", Arrays.asList("foo", "bar"), + "wiz", Arrays.asList("bang")); + Map<String, List<String>> converted = + Type.STRING_LIST_DICT.convert(input, null, currentRule); + Map<?, ?> expected = ImmutableMap.<String, List<String>>of( + "foo", Arrays.asList("foo", "bar"), + "wiz", Arrays.asList("bang")); + assertEquals(expected, converted); + assertNotSame(expected, converted); + assertThat(Type.STRING_LIST_DICT.flatten(converted)).isEmpty(); + } + + @Test + public void testStringListDictBadFirstElement() throws Exception { + Object input = ImmutableMap.of(2, Arrays.asList("foo", "bar"), + "wiz", Arrays.asList("bang")); + try { + Type.STRING_LIST_DICT.convert(input, null, currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage( + "expected value of type 'string' for dict key element, but got 2 (int)"); + } + } + + @Test + public void testStringListDictBadSecondElement() throws Exception { + Object input = ImmutableMap.of("foo", "bar", + "wiz", Arrays.asList("bang")); + try { + Type.STRING_LIST_DICT.convert(input, null, currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage( + "expected value of type 'list(string)' for dict value element, " + + "but got \"bar\" (string)"); + } + } + + @Test + public void testStringListDictBadElements1() throws Exception { + Object input = ImmutableMap.of(Arrays.asList("foo"), Arrays.asList("bang"), + "wiz", Arrays.asList("bang")); + try { + Type.STRING_LIST_DICT.convert(input, null); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'string' for dict key element, but got " + + "[\"foo\"] (List)"); + } + } + + @Test + public void testStringDictUnary() throws Exception { + Object input = ImmutableMap.of("foo", "bar", + "wiz", "bang"); + Map<?, ?> converted = + Type.STRING_DICT_UNARY.convert(input, null, currentRule); + Map<?, ?> expected = ImmutableMap.<String, String>of( + "foo", "bar", + "wiz", "bang"); + assertEquals(expected, converted); + assertNotSame(expected, converted); + assertThat(Type.STRING_DICT_UNARY.flatten(converted)).isEmpty(); + } + + @Test + public void testStringDictUnaryBadFirstElement() throws Exception { + Object input = ImmutableMap.of(2, Arrays.asList("foo", "bar"), + "wiz", Arrays.asList("bang")); + try { + Type.STRING_DICT_UNARY.convert(input, null, currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'string' for dict key element, but got " + + "2 (int)"); + } + } + + @Test + public void testStringDictUnaryBadSecondElement() throws Exception { + Object input = ImmutableMap.of("foo", "bar", + "wiz", Arrays.asList("bang")); + try { + Type.STRING_DICT_UNARY.convert(input, null, currentRule); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'string' for dict value element, but got " + + "[\"bang\"] (List)"); + } + } + + @Test + public void testStringDictUnaryBadElements1() throws Exception { + Object input = ImmutableMap.of("foo", "bar", + Arrays.asList("foo", "bar"), + Arrays.<Object>asList("wiz", "bang")); + try { + Type.STRING_DICT_UNARY.convert(input, null); + fail(); + } catch (Type.ConversionException e) { + assertThat(e).hasMessage("expected value of type 'string' for dict key element, but got " + + "[\"foo\", \"bar\"] (List)"); + } + } + + @Test + public void testStringDictThrowsConversionException() throws Exception { + try { + Type.STRING_DICT.convert("some string", null); + fail(); + } catch (ConversionException e) { + assertThat(e).hasMessage("Expected a map for dictionary but got a java.lang.String"); + } + } +} |