diff options
Diffstat (limited to 'guava-tests/test/com/google/common/collect/ImmutableSortedMapTest.java')
| -rw-r--r-- | guava-tests/test/com/google/common/collect/ImmutableSortedMapTest.java | 1142 |
1 files changed, 483 insertions, 659 deletions
diff --git a/guava-tests/test/com/google/common/collect/ImmutableSortedMapTest.java b/guava-tests/test/com/google/common/collect/ImmutableSortedMapTest.java index 1de9e6972..9eb466cd4 100644 --- a/guava-tests/test/com/google/common/collect/ImmutableSortedMapTest.java +++ b/guava-tests/test/com/google/common/collect/ImmutableSortedMapTest.java @@ -22,12 +22,10 @@ import static com.google.common.truth.Truth.assertThat; import com.google.common.annotations.GwtCompatible; import com.google.common.annotations.GwtIncompatible; import com.google.common.base.Equivalence; -import com.google.common.base.Joiner; import com.google.common.collect.ImmutableSortedMap.Builder; import com.google.common.collect.testing.ListTestSuiteBuilder; import com.google.common.collect.testing.MapTestSuiteBuilder; import com.google.common.collect.testing.NavigableMapTestSuiteBuilder; -import com.google.common.collect.testing.SortedMapInterfaceTest; import com.google.common.collect.testing.features.CollectionFeature; import com.google.common.collect.testing.features.CollectionSize; import com.google.common.collect.testing.features.MapFeature; @@ -53,6 +51,7 @@ import java.util.stream.Stream; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; +import org.checkerframework.checker.nullness.qual.Nullable; /** * Tests for {@link ImmutableSortedMap}. @@ -125,736 +124,561 @@ public class ImmutableSortedMapTest extends TestCase { return suite; } - public abstract static class AbstractMapTests<K, V> extends SortedMapInterfaceTest<K, V> { - public AbstractMapTests() { - super(false, false, false, false, false); - } - - @Override - protected SortedMap<K, V> makeEmptyMap() { - throw new UnsupportedOperationException(); - } - - private static final Joiner joiner = Joiner.on(", "); + // Creation tests - @Override - protected void assertMoreInvariants(Map<K, V> map) { - // TODO: can these be moved to MapInterfaceTest? - for (Entry<K, V> entry : map.entrySet()) { - assertEquals(entry.getKey() + "=" + entry.getValue(), entry.toString()); - } - - assertEquals("{" + joiner.join(map.entrySet()) + "}", map.toString()); - assertEquals("[" + joiner.join(map.entrySet()) + "]", map.entrySet().toString()); - assertEquals("[" + joiner.join(map.keySet()) + "]", map.keySet().toString()); - assertEquals("[" + joiner.join(map.values()) + "]", map.values().toString()); - - assertEquals(Sets.newHashSet(map.entrySet()), map.entrySet()); - assertEquals(Sets.newHashSet(map.keySet()), map.keySet()); - } + public void testEmptyBuilder() { + ImmutableSortedMap<String, Integer> map = + ImmutableSortedMap.<String, Integer>naturalOrder().build(); + assertEquals(Collections.<String, Integer>emptyMap(), map); } - public static class MapTests extends AbstractMapTests<String, Integer> { - @Override - protected SortedMap<String, Integer> makeEmptyMap() { - return ImmutableSortedMap.of(); - } - - @Override - protected SortedMap<String, Integer> makePopulatedMap() { - return ImmutableSortedMap.of("one", 1, "two", 2, "three", 3); - } - - @Override - protected String getKeyNotInPopulatedMap() { - return "minus one"; - } - - @Override - protected Integer getValueNotInPopulatedMap() { - return -1; - } + public void testSingletonBuilder() { + ImmutableSortedMap<String, Integer> map = + ImmutableSortedMap.<String, Integer>naturalOrder().put("one", 1).build(); + assertMapEquals(map, "one", 1); } - public static class SingletonMapTests extends AbstractMapTests<String, Integer> { - @Override - protected SortedMap<String, Integer> makePopulatedMap() { - return ImmutableSortedMap.of("one", 1); - } - - @Override - protected String getKeyNotInPopulatedMap() { - return "minus one"; - } - - @Override - protected Integer getValueNotInPopulatedMap() { - return -1; - } + public void testBuilder() { + ImmutableSortedMap<String, Integer> map = + ImmutableSortedMap.<String, Integer>naturalOrder() + .put("one", 1) + .put("two", 2) + .put("three", 3) + .put("four", 4) + .put("five", 5) + .build(); + assertMapEquals(map, "five", 5, "four", 4, "one", 1, "three", 3, "two", 2); } - @GwtIncompatible // SerializableTester - public static class ReserializedMapTests extends AbstractMapTests<String, Integer> { - @Override - protected SortedMap<String, Integer> makePopulatedMap() { - return SerializableTester.reserialize(ImmutableSortedMap.of("one", 1, "two", 2, "three", 3)); - } - - @Override - protected String getKeyNotInPopulatedMap() { - return "minus one"; - } - - @Override - protected Integer getValueNotInPopulatedMap() { - return -1; + @SuppressWarnings("DoNotCall") + public void testBuilder_orderEntriesByValueFails() { + ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); + try { + builder.orderEntriesByValue(Ordering.natural()); + fail("Expected UnsupportedOperationException"); + } catch (UnsupportedOperationException expected) { } } - public static class HeadMapTests extends AbstractMapTests<String, Integer> { - @Override - protected SortedMap<String, Integer> makePopulatedMap() { - return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).headMap("d"); - } - - @Override - protected String getKeyNotInPopulatedMap() { - return "d"; - } - - @Override - protected Integer getValueNotInPopulatedMap() { - return 4; - } + public void testBuilder_withImmutableEntry() { + ImmutableSortedMap<String, Integer> map = + ImmutableSortedMap.<String, Integer>naturalOrder() + .put(Maps.immutableEntry("one", 1)) + .build(); + assertMapEquals(map, "one", 1); } - public static class HeadMapInclusiveTests extends AbstractMapTests<String, Integer> { - @Override - protected SortedMap<String, Integer> makePopulatedMap() { - return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).headMap("c", true); + public void testBuilder_withImmutableEntryAndNullContents() { + Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); + try { + builder.put(Maps.immutableEntry("one", (Integer) null)); + fail(); + } catch (NullPointerException expected) { } - - @Override - protected String getKeyNotInPopulatedMap() { - return "d"; - } - - @Override - protected Integer getValueNotInPopulatedMap() { - return 4; + try { + builder.put(Maps.immutableEntry((String) null, 1)); + fail(); + } catch (NullPointerException expected) { } } - public static class TailMapTests extends AbstractMapTests<String, Integer> { - @Override - protected SortedMap<String, Integer> makePopulatedMap() { - return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).tailMap("b"); - } - - @Override - protected String getKeyNotInPopulatedMap() { - return "a"; - } - - @Override - protected Integer getValueNotInPopulatedMap() { - return 1; - } + private static class StringHolder { + String string; } - public static class TailExclusiveMapTests extends AbstractMapTests<String, Integer> { - @Override - protected SortedMap<String, Integer> makePopulatedMap() { - return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).tailMap("a", false); - } - - @Override - protected String getKeyNotInPopulatedMap() { - return "a"; - } - - @Override - protected Integer getValueNotInPopulatedMap() { - return 1; - } + public void testBuilder_withMutableEntry() { + ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); + final StringHolder holder = new StringHolder(); + holder.string = "one"; + Entry<String, Integer> entry = + new AbstractMapEntry<String, Integer>() { + @Override + public String getKey() { + return holder.string; + } + + @Override + public Integer getValue() { + return 1; + } + }; + + builder.put(entry); + holder.string = "two"; + assertMapEquals(builder.build(), "one", 1); } - public static class SubMapTests extends AbstractMapTests<String, Integer> { - @Override - protected SortedMap<String, Integer> makePopulatedMap() { - return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).subMap("b", "d"); - } - - @Override - protected String getKeyNotInPopulatedMap() { - return "a"; - } - - @Override - protected Integer getValueNotInPopulatedMap() { - return 4; - } + public void testBuilderPutAllWithEmptyMap() { + ImmutableSortedMap<String, Integer> map = + ImmutableSortedMap.<String, Integer>naturalOrder() + .putAll(Collections.<String, Integer>emptyMap()) + .build(); + assertEquals(Collections.<String, Integer>emptyMap(), map); } - public static class CreationTests extends TestCase { - public void testEmptyBuilder() { - ImmutableSortedMap<String, Integer> map = - ImmutableSortedMap.<String, Integer>naturalOrder().build(); - assertEquals(Collections.<String, Integer>emptyMap(), map); - } - - public void testSingletonBuilder() { - ImmutableSortedMap<String, Integer> map = - ImmutableSortedMap.<String, Integer>naturalOrder().put("one", 1).build(); - assertMapEquals(map, "one", 1); - } - - public void testBuilder() { - ImmutableSortedMap<String, Integer> map = - ImmutableSortedMap.<String, Integer>naturalOrder() - .put("one", 1) - .put("two", 2) - .put("three", 3) - .put("four", 4) - .put("five", 5) - .build(); - assertMapEquals(map, "five", 5, "four", 4, "one", 1, "three", 3, "two", 2); - } - - @SuppressWarnings("DoNotCall") - public void testBuilder_orderEntriesByValueFails() { - ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); - try { - builder.orderEntriesByValue(Ordering.natural()); - fail("Expected UnsupportedOperationException"); - } catch (UnsupportedOperationException expected) { - } - } + public void testBuilderPutAll() { + Map<String, Integer> toPut = new LinkedHashMap<>(); + toPut.put("one", 1); + toPut.put("two", 2); + toPut.put("three", 3); + Map<String, Integer> moreToPut = new LinkedHashMap<>(); + moreToPut.put("four", 4); + moreToPut.put("five", 5); + + ImmutableSortedMap<String, Integer> map = + ImmutableSortedMap.<String, Integer>naturalOrder().putAll(toPut).putAll(moreToPut).build(); + assertMapEquals(map, "five", 5, "four", 4, "one", 1, "three", 3, "two", 2); + } - public void testBuilder_withImmutableEntry() { - ImmutableSortedMap<String, Integer> map = - ImmutableSortedMap.<String, Integer>naturalOrder() - .put(Maps.immutableEntry("one", 1)) - .build(); - assertMapEquals(map, "one", 1); - } + public void testBuilderReuse() { + Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); + ImmutableSortedMap<String, Integer> mapOne = builder.put("one", 1).put("two", 2).build(); + ImmutableSortedMap<String, Integer> mapTwo = builder.put("three", 3).put("four", 4).build(); - public void testBuilder_withImmutableEntryAndNullContents() { - Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); - try { - builder.put(Maps.immutableEntry("one", (Integer) null)); - fail(); - } catch (NullPointerException expected) { - } - try { - builder.put(Maps.immutableEntry((String) null, 1)); - fail(); - } catch (NullPointerException expected) { - } - } + assertMapEquals(mapOne, "one", 1, "two", 2); + assertMapEquals(mapTwo, "four", 4, "one", 1, "three", 3, "two", 2); + } - private static class StringHolder { - String string; + public void testBuilderPutNullKey() { + Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); + try { + builder.put(null, 1); + fail(); + } catch (NullPointerException expected) { } + } - public void testBuilder_withMutableEntry() { - ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); - final StringHolder holder = new StringHolder(); - holder.string = "one"; - Entry<String, Integer> entry = - new AbstractMapEntry<String, Integer>() { - @Override - public String getKey() { - return holder.string; - } - - @Override - public Integer getValue() { - return 1; - } - }; - - builder.put(entry); - holder.string = "two"; - assertMapEquals(builder.build(), "one", 1); + public void testBuilderPutNullValue() { + Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); + try { + builder.put("one", null); + fail(); + } catch (NullPointerException expected) { } + } - public void testBuilderPutAllWithEmptyMap() { - ImmutableSortedMap<String, Integer> map = - ImmutableSortedMap.<String, Integer>naturalOrder() - .putAll(Collections.<String, Integer>emptyMap()) - .build(); - assertEquals(Collections.<String, Integer>emptyMap(), map); + public void testBuilderPutNullKeyViaPutAll() { + Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); + try { + builder.putAll(Collections.<String, Integer>singletonMap(null, 1)); + fail(); + } catch (NullPointerException expected) { } + } - public void testBuilderPutAll() { - Map<String, Integer> toPut = new LinkedHashMap<>(); - toPut.put("one", 1); - toPut.put("two", 2); - toPut.put("three", 3); - Map<String, Integer> moreToPut = new LinkedHashMap<>(); - moreToPut.put("four", 4); - moreToPut.put("five", 5); - - ImmutableSortedMap<String, Integer> map = - ImmutableSortedMap.<String, Integer>naturalOrder() - .putAll(toPut) - .putAll(moreToPut) - .build(); - assertMapEquals(map, "five", 5, "four", 4, "one", 1, "three", 3, "two", 2); + public void testBuilderPutNullValueViaPutAll() { + Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); + try { + builder.putAll(Collections.<String, Integer>singletonMap("one", null)); + fail(); + } catch (NullPointerException expected) { } + } - public void testBuilderReuse() { - Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); - ImmutableSortedMap<String, Integer> mapOne = builder.put("one", 1).put("two", 2).build(); - ImmutableSortedMap<String, Integer> mapTwo = builder.put("three", 3).put("four", 4).build(); + public void testPuttingTheSameKeyTwiceThrowsOnBuild() { + Builder<String, Integer> builder = + ImmutableSortedMap.<String, Integer>naturalOrder() + .put("one", 1) + .put("one", 2); // throwing on this line would be even better - assertMapEquals(mapOne, "one", 1, "two", 2); - assertMapEquals(mapTwo, "four", 4, "one", 1, "three", 3, "two", 2); + try { + builder.build(); + fail(); + } catch (IllegalArgumentException expected) { } + } - public void testBuilderPutNullKey() { - Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); - try { - builder.put(null, 1); - fail(); - } catch (NullPointerException expected) { - } - } + public void testOf() { + assertMapEquals(ImmutableSortedMap.of("one", 1), "one", 1); + assertMapEquals(ImmutableSortedMap.of("one", 1, "two", 2), "one", 1, "two", 2); + assertMapEquals( + ImmutableSortedMap.of("one", 1, "two", 2, "three", 3), "one", 1, "three", 3, "two", 2); + assertMapEquals( + ImmutableSortedMap.of("one", 1, "two", 2, "three", 3, "four", 4), + "four", + 4, + "one", + 1, + "three", + 3, + "two", + 2); + assertMapEquals( + ImmutableSortedMap.of("one", 1, "two", 2, "three", 3, "four", 4, "five", 5), + "five", + 5, + "four", + 4, + "one", + 1, + "three", + 3, + "two", + 2); + assertMapEquals( + ImmutableSortedMap.of( + "one", 1, + "two", 2, + "three", 3, + "four", 4, + "five", 5, + "six", 6), + "five", + 5, + "four", + 4, + "one", + 1, + "six", + 6, + "three", + 3, + "two", + 2); + assertMapEquals( + ImmutableSortedMap.of( + "one", 1, + "two", 2, + "three", 3, + "four", 4, + "five", 5, + "six", 6, + "seven", 7), + "five", + 5, + "four", + 4, + "one", + 1, + "seven", + 7, + "six", + 6, + "three", + 3, + "two", + 2); + assertMapEquals( + ImmutableSortedMap.of( + "one", 1, + "two", 2, + "three", 3, + "four", 4, + "five", 5, + "six", 6, + "seven", 7, + "eight", 8), + "eight", + 8, + "five", + 5, + "four", + 4, + "one", + 1, + "seven", + 7, + "six", + 6, + "three", + 3, + "two", + 2); + assertMapEquals( + ImmutableSortedMap.of( + "one", 1, + "two", 2, + "three", 3, + "four", 4, + "five", 5, + "six", 6, + "seven", 7, + "eight", 8, + "nine", 9), + "eight", + 8, + "five", + 5, + "four", + 4, + "nine", + 9, + "one", + 1, + "seven", + 7, + "six", + 6, + "three", + 3, + "two", + 2); + assertMapEquals( + ImmutableSortedMap.of( + "one", 1, + "two", 2, + "three", 3, + "four", 4, + "five", 5, + "six", 6, + "seven", 7, + "eight", 8, + "nine", 9, + "ten", 10), + "eight", + 8, + "five", + 5, + "four", + 4, + "nine", + 9, + "one", + 1, + "seven", + 7, + "six", + 6, + "ten", + 10, + "three", + 3, + "two", + 2); + } - public void testBuilderPutNullValue() { - Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); - try { - builder.put("one", null); - fail(); - } catch (NullPointerException expected) { - } + public void testOfNullKey() { + Integer n = null; + try { + ImmutableSortedMap.of(n, 1); + fail(); + } catch (NullPointerException expected) { } - public void testBuilderPutNullKeyViaPutAll() { - Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); - try { - builder.putAll(Collections.<String, Integer>singletonMap(null, 1)); - fail(); - } catch (NullPointerException expected) { - } + try { + ImmutableSortedMap.of("one", 1, null, 2); + fail(); + } catch (NullPointerException expected) { } + } - public void testBuilderPutNullValueViaPutAll() { - Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder(); - try { - builder.putAll(Collections.<String, Integer>singletonMap("one", null)); - fail(); - } catch (NullPointerException expected) { - } + public void testOfNullValue() { + try { + ImmutableSortedMap.of("one", null); + fail(); + } catch (NullPointerException expected) { } - public void testPuttingTheSameKeyTwiceThrowsOnBuild() { - Builder<String, Integer> builder = - ImmutableSortedMap.<String, Integer>naturalOrder() - .put("one", 1) - .put("one", 2); // throwing on this line would be even better - - try { - builder.build(); - fail(); - } catch (IllegalArgumentException expected) { - } + try { + ImmutableSortedMap.of("one", 1, "two", null); + fail(); + } catch (NullPointerException expected) { } + } - public void testOf() { - assertMapEquals(ImmutableSortedMap.of("one", 1), "one", 1); - assertMapEquals(ImmutableSortedMap.of("one", 1, "two", 2), "one", 1, "two", 2); - assertMapEquals( - ImmutableSortedMap.of("one", 1, "two", 2, "three", 3), "one", 1, "three", 3, "two", 2); - assertMapEquals( - ImmutableSortedMap.of("one", 1, "two", 2, "three", 3, "four", 4), - "four", - 4, - "one", - 1, - "three", - 3, - "two", - 2); - assertMapEquals( - ImmutableSortedMap.of("one", 1, "two", 2, "three", 3, "four", 4, "five", 5), - "five", - 5, - "four", - 4, - "one", - 1, - "three", - 3, - "two", - 2); - assertMapEquals( - ImmutableSortedMap.of( - "one", 1, - "two", 2, - "three", 3, - "four", 4, - "five", 5, - "six", 6), - "five", - 5, - "four", - 4, - "one", - 1, - "six", - 6, - "three", - 3, - "two", - 2); - assertMapEquals( - ImmutableSortedMap.of( - "one", 1, - "two", 2, - "three", 3, - "four", 4, - "five", 5, - "six", 6, - "seven", 7), - "five", - 5, - "four", - 4, - "one", - 1, - "seven", - 7, - "six", - 6, - "three", - 3, - "two", - 2); - assertMapEquals( - ImmutableSortedMap.of( - "one", 1, - "two", 2, - "three", 3, - "four", 4, - "five", 5, - "six", 6, - "seven", 7, - "eight", 8), - "eight", - 8, - "five", - 5, - "four", - 4, - "one", - 1, - "seven", - 7, - "six", - 6, - "three", - 3, - "two", - 2); - assertMapEquals( - ImmutableSortedMap.of( - "one", 1, - "two", 2, - "three", 3, - "four", 4, - "five", 5, - "six", 6, - "seven", 7, - "eight", 8, - "nine", 9), - "eight", - 8, - "five", - 5, - "four", - 4, - "nine", - 9, - "one", - 1, - "seven", - 7, - "six", - 6, - "three", - 3, - "two", - 2); - assertMapEquals( - ImmutableSortedMap.of( - "one", 1, - "two", 2, - "three", 3, - "four", 4, - "five", 5, - "six", 6, - "seven", 7, - "eight", 8, - "nine", 9, - "ten", 10), - "eight", - 8, - "five", - 5, - "four", - 4, - "nine", - 9, - "one", - 1, - "seven", - 7, - "six", - 6, - "ten", - 10, - "three", - 3, - "two", - 2); + public void testOfWithDuplicateKey() { + try { + ImmutableSortedMap.of("one", 1, "one", 1); + fail(); + } catch (IllegalArgumentException expected) { } + } - public void testOfNullKey() { - Integer n = null; - try { - ImmutableSortedMap.of(n, 1); - fail(); - } catch (NullPointerException expected) { - } + public void testCopyOfEmptyMap() { + ImmutableSortedMap<String, Integer> copy = + ImmutableSortedMap.copyOf(Collections.<String, Integer>emptyMap()); + assertEquals(Collections.<String, Integer>emptyMap(), copy); + assertSame(copy, ImmutableSortedMap.copyOf(copy)); + assertSame(Ordering.natural(), copy.comparator()); + } - try { - ImmutableSortedMap.of("one", 1, null, 2); - fail(); - } catch (NullPointerException expected) { - } - } + public void testCopyOfSingletonMap() { + ImmutableSortedMap<String, Integer> copy = + ImmutableSortedMap.copyOf(Collections.singletonMap("one", 1)); + assertMapEquals(copy, "one", 1); + assertSame(copy, ImmutableSortedMap.copyOf(copy)); + assertSame(Ordering.natural(), copy.comparator()); + } - public void testOfNullValue() { - try { - ImmutableSortedMap.of("one", null); - fail(); - } catch (NullPointerException expected) { - } + public void testCopyOf() { + Map<String, Integer> original = new LinkedHashMap<>(); + original.put("one", 1); + original.put("two", 2); + original.put("three", 3); - try { - ImmutableSortedMap.of("one", 1, "two", null); - fail(); - } catch (NullPointerException expected) { - } - } + ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOf(original); + assertMapEquals(copy, "one", 1, "three", 3, "two", 2); + assertSame(copy, ImmutableSortedMap.copyOf(copy)); + assertSame(Ordering.natural(), copy.comparator()); + } - public void testOfWithDuplicateKey() { - try { - ImmutableSortedMap.of("one", 1, "one", 1); - fail(); - } catch (IllegalArgumentException expected) { - } - } + public void testCopyOfExplicitComparator() { + Comparator<String> comparator = Ordering.natural().reverse(); + Map<String, Integer> original = new LinkedHashMap<>(); + original.put("one", 1); + original.put("two", 2); + original.put("three", 3); + + ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOf(original, comparator); + assertMapEquals(copy, "two", 2, "three", 3, "one", 1); + assertSame(copy, ImmutableSortedMap.copyOf(copy, comparator)); + assertSame(comparator, copy.comparator()); + } - public void testCopyOfEmptyMap() { - ImmutableSortedMap<String, Integer> copy = - ImmutableSortedMap.copyOf(Collections.<String, Integer>emptyMap()); - assertEquals(Collections.<String, Integer>emptyMap(), copy); - assertSame(copy, ImmutableSortedMap.copyOf(copy)); - assertSame(Ordering.natural(), copy.comparator()); - } + public void testCopyOfImmutableSortedSetDifferentComparator() { + Comparator<String> comparator = Ordering.natural().reverse(); + Map<String, Integer> original = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3); + ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOf(original, comparator); + assertMapEquals(copy, "two", 2, "three", 3, "one", 1); + assertSame(copy, ImmutableSortedMap.copyOf(copy, comparator)); + assertSame(comparator, copy.comparator()); + } - public void testCopyOfSingletonMap() { - ImmutableSortedMap<String, Integer> copy = - ImmutableSortedMap.copyOf(Collections.singletonMap("one", 1)); - assertMapEquals(copy, "one", 1); - assertSame(copy, ImmutableSortedMap.copyOf(copy)); - assertSame(Ordering.natural(), copy.comparator()); - } + public void testCopyOfSortedNatural() { + SortedMap<String, Integer> original = Maps.newTreeMap(); + original.put("one", 1); + original.put("two", 2); + original.put("three", 3); - public void testCopyOf() { - Map<String, Integer> original = new LinkedHashMap<>(); - original.put("one", 1); - original.put("two", 2); - original.put("three", 3); + ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOfSorted(original); + assertMapEquals(copy, "one", 1, "three", 3, "two", 2); + assertSame(copy, ImmutableSortedMap.copyOfSorted(copy)); + assertSame(Ordering.natural(), copy.comparator()); + } - ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOf(original); - assertMapEquals(copy, "one", 1, "three", 3, "two", 2); - assertSame(copy, ImmutableSortedMap.copyOf(copy)); - assertSame(Ordering.natural(), copy.comparator()); - } + public void testCopyOfSortedExplicit() { + Comparator<String> comparator = Ordering.natural().reverse(); + SortedMap<String, Integer> original = Maps.newTreeMap(comparator); + original.put("one", 1); + original.put("two", 2); + original.put("three", 3); + + ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOfSorted(original); + assertMapEquals(copy, "two", 2, "three", 3, "one", 1); + assertSame(copy, ImmutableSortedMap.copyOfSorted(copy)); + assertSame(comparator, copy.comparator()); + } - public void testCopyOfExplicitComparator() { - Comparator<String> comparator = Ordering.natural().reverse(); - Map<String, Integer> original = new LinkedHashMap<>(); - original.put("one", 1); - original.put("two", 2); - original.put("three", 3); - - ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOf(original, comparator); - assertMapEquals(copy, "two", 2, "three", 3, "one", 1); - assertSame(copy, ImmutableSortedMap.copyOf(copy, comparator)); - assertSame(comparator, copy.comparator()); - } + private static class IntegerDiv10 implements Comparable<IntegerDiv10> { + final int value; - public void testCopyOfImmutableSortedSetDifferentComparator() { - Comparator<String> comparator = Ordering.natural().reverse(); - Map<String, Integer> original = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3); - ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOf(original, comparator); - assertMapEquals(copy, "two", 2, "three", 3, "one", 1); - assertSame(copy, ImmutableSortedMap.copyOf(copy, comparator)); - assertSame(comparator, copy.comparator()); + IntegerDiv10(int value) { + this.value = value; } - public void testCopyOfSortedNatural() { - SortedMap<String, Integer> original = Maps.newTreeMap(); - original.put("one", 1); - original.put("two", 2); - original.put("three", 3); - - ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOfSorted(original); - assertMapEquals(copy, "one", 1, "three", 3, "two", 2); - assertSame(copy, ImmutableSortedMap.copyOfSorted(copy)); - assertSame(Ordering.natural(), copy.comparator()); + @Override + public int compareTo(IntegerDiv10 o) { + return value / 10 - o.value / 10; } - public void testCopyOfSortedExplicit() { - Comparator<String> comparator = Ordering.natural().reverse(); - SortedMap<String, Integer> original = Maps.newTreeMap(comparator); - original.put("one", 1); - original.put("two", 2); - original.put("three", 3); - - ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOfSorted(original); - assertMapEquals(copy, "two", 2, "three", 3, "one", 1); - assertSame(copy, ImmutableSortedMap.copyOfSorted(copy)); - assertSame(comparator, copy.comparator()); + @Override + public String toString() { + return Integer.toString(value); } + } - private static class IntegerDiv10 implements Comparable<IntegerDiv10> { - final int value; - - IntegerDiv10(int value) { - this.value = value; - } - - @Override - public int compareTo(IntegerDiv10 o) { - return value / 10 - o.value / 10; - } - - @Override - public String toString() { - return Integer.toString(value); - } - } + public void testCopyOfDuplicateKey() { + Map<IntegerDiv10, String> original = + ImmutableMap.of( + new IntegerDiv10(3), "three", + new IntegerDiv10(20), "twenty", + new IntegerDiv10(11), "eleven", + new IntegerDiv10(35), "thirty five", + new IntegerDiv10(12), "twelve"); - public void testCopyOfDuplicateKey() { - Map<IntegerDiv10, String> original = - ImmutableMap.of( - new IntegerDiv10(3), "three", - new IntegerDiv10(20), "twenty", - new IntegerDiv10(11), "eleven", - new IntegerDiv10(35), "thirty five", - new IntegerDiv10(12), "twelve"); - - try { - ImmutableSortedMap.copyOf(original); - fail("Expected IllegalArgumentException"); - } catch (IllegalArgumentException expected) { - } + try { + ImmutableSortedMap.copyOf(original); + fail("Expected IllegalArgumentException"); + } catch (IllegalArgumentException expected) { } + } - public void testImmutableMapCopyOfImmutableSortedMap() { - IntegerDiv10 three = new IntegerDiv10(3); - IntegerDiv10 eleven = new IntegerDiv10(11); - IntegerDiv10 twelve = new IntegerDiv10(12); - IntegerDiv10 twenty = new IntegerDiv10(20); - Map<IntegerDiv10, String> original = - ImmutableSortedMap.of(three, "three", eleven, "eleven", twenty, "twenty"); - Map<IntegerDiv10, String> copy = ImmutableMap.copyOf(original); - assertTrue(original.containsKey(twelve)); - assertFalse(copy.containsKey(twelve)); - } + public void testImmutableMapCopyOfImmutableSortedMap() { + IntegerDiv10 three = new IntegerDiv10(3); + IntegerDiv10 eleven = new IntegerDiv10(11); + IntegerDiv10 twelve = new IntegerDiv10(12); + IntegerDiv10 twenty = new IntegerDiv10(20); + Map<IntegerDiv10, String> original = + ImmutableSortedMap.of(three, "three", eleven, "eleven", twenty, "twenty"); + Map<IntegerDiv10, String> copy = ImmutableMap.copyOf(original); + assertTrue(original.containsKey(twelve)); + assertFalse(copy.containsKey(twelve)); + } - public void testBuilderReverseOrder() { - ImmutableSortedMap<String, Integer> map = - ImmutableSortedMap.<String, Integer>reverseOrder() - .put("one", 1) - .put("two", 2) - .put("three", 3) - .put("four", 4) - .put("five", 5) - .build(); - assertMapEquals(map, "two", 2, "three", 3, "one", 1, "four", 4, "five", 5); - assertEquals(Ordering.natural().reverse(), map.comparator()); - } + public void testBuilderReverseOrder() { + ImmutableSortedMap<String, Integer> map = + ImmutableSortedMap.<String, Integer>reverseOrder() + .put("one", 1) + .put("two", 2) + .put("three", 3) + .put("four", 4) + .put("five", 5) + .build(); + assertMapEquals(map, "two", 2, "three", 3, "one", 1, "four", 4, "five", 5); + assertEquals(Ordering.natural().reverse(), map.comparator()); + } - public void testBuilderComparator() { - Comparator<String> comparator = Ordering.natural().reverse(); - ImmutableSortedMap<String, Integer> map = - new ImmutableSortedMap.Builder<String, Integer>(comparator) - .put("one", 1) - .put("two", 2) - .put("three", 3) - .put("four", 4) - .put("five", 5) - .build(); - assertMapEquals(map, "two", 2, "three", 3, "one", 1, "four", 4, "five", 5); - assertSame(comparator, map.comparator()); - } + public void testBuilderComparator() { + Comparator<String> comparator = Ordering.natural().reverse(); + ImmutableSortedMap<String, Integer> map = + new ImmutableSortedMap.Builder<String, Integer>(comparator) + .put("one", 1) + .put("two", 2) + .put("three", 3) + .put("four", 4) + .put("five", 5) + .build(); + assertMapEquals(map, "two", 2, "three", 3, "one", 1, "four", 4, "five", 5); + assertSame(comparator, map.comparator()); + } - public void testToImmutableSortedMap() { - Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = - ImmutableSortedMap.toImmutableSortedMap( - String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue); - BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>> - equivalence = - Equivalence.equals() - .onResultOf(ImmutableSortedMap<String, Integer>::comparator) - .and(Equivalence.equals().onResultOf(map -> map.entrySet().asList())) - .and(Equivalence.equals()); - ImmutableSortedMap<String, Integer> expected = - ImmutableSortedMap.<String, Integer>orderedBy(String.CASE_INSENSITIVE_ORDER) - .put("one", 1) - .put("three", 3) - .put("two", 2) - .build(); - CollectorTester.of(collector, equivalence) - .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3)); - } + public void testToImmutableSortedMap() { + Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = + ImmutableSortedMap.toImmutableSortedMap( + String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue); + BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>> + equivalence = + Equivalence.equals() + .onResultOf(ImmutableSortedMap<String, Integer>::comparator) + .and(Equivalence.equals().onResultOf(map -> map.entrySet().asList())) + .and(Equivalence.equals()); + ImmutableSortedMap<String, Integer> expected = + ImmutableSortedMap.<String, Integer>orderedBy(String.CASE_INSENSITIVE_ORDER) + .put("one", 1) + .put("three", 3) + .put("two", 2) + .build(); + CollectorTester.of(collector, equivalence) + .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3)); + } - public void testToImmutableSortedMap_exceptionOnDuplicateKey() { - Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = - ImmutableSortedMap.toImmutableSortedMap( - Ordering.natural(), Entry::getKey, Entry::getValue); - try { - Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector); - fail("Expected IllegalArgumentException"); - } catch (IllegalArgumentException expected) { - } + public void testToImmutableSortedMap_exceptionOnDuplicateKey() { + Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = + ImmutableSortedMap.toImmutableSortedMap(Ordering.natural(), Entry::getKey, Entry::getValue); + try { + Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector); + fail("Expected IllegalArgumentException"); + } catch (IllegalArgumentException expected) { } + } - public void testToImmutableSortedMapMerging() { - Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = - ImmutableSortedMap.toImmutableSortedMap( - Comparator.naturalOrder(), Entry::getKey, Entry::getValue, Integer::sum); - Equivalence<ImmutableMap<String, Integer>> equivalence = - Equivalence.equals() - .<Entry<String, Integer>>pairwise() - .onResultOf(ImmutableMap::entrySet); - CollectorTester.of(collector, equivalence) - .expectCollects( - ImmutableSortedMap.of("one", 1, "three", 3, "two", 4), - mapEntry("one", 1), - mapEntry("two", 2), - mapEntry("three", 3), - mapEntry("two", 2)); - } + public void testToImmutableSortedMapMerging() { + Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector = + ImmutableSortedMap.toImmutableSortedMap( + Comparator.naturalOrder(), Entry::getKey, Entry::getValue, Integer::sum); + Equivalence<ImmutableMap<String, Integer>> equivalence = + Equivalence.equals().<Entry<String, Integer>>pairwise().onResultOf(ImmutableMap::entrySet); + CollectorTester.of(collector, equivalence) + .expectCollects( + ImmutableSortedMap.of("one", 1, "three", 3, "two", 4), + mapEntry("one", 1), + mapEntry("two", 2), + mapEntry("three", 3), + mapEntry("two", 2)); } + // Other tests + public void testNullGet() { ImmutableSortedMap<String, Integer> map = ImmutableSortedMap.of("one", 1); assertNull(map.get(null)); @@ -920,7 +744,7 @@ public class ImmutableSortedMapTest extends TestCase { } @Override - public boolean equals(Object o) { + public boolean equals(@Nullable Object o) { return (o instanceof IntHolder) && ((IntHolder) o).value == value; } |