diff options
Diffstat (limited to 'guava-tests/test/com/google/common/collect/LinkedListMultimapTest.java')
| -rw-r--r-- | guava-tests/test/com/google/common/collect/LinkedListMultimapTest.java | 239 |
1 files changed, 118 insertions, 121 deletions
diff --git a/guava-tests/test/com/google/common/collect/LinkedListMultimapTest.java b/guava-tests/test/com/google/common/collect/LinkedListMultimapTest.java index d57d5c044..bc4a2df7e 100644 --- a/guava-tests/test/com/google/common/collect/LinkedListMultimapTest.java +++ b/guava-tests/test/com/google/common/collect/LinkedListMultimapTest.java @@ -35,18 +35,21 @@ import com.google.common.collect.testing.features.MapFeature; import com.google.common.collect.testing.google.ListMultimapTestSuiteBuilder; import com.google.common.collect.testing.google.TestStringListMultimapGenerator; import com.google.common.testing.EqualsTester; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.ListIterator; +import java.util.Map; import java.util.Map.Entry; import java.util.RandomAccess; import java.util.Set; -import junit.framework.Test; -import junit.framework.TestCase; -import junit.framework.TestSuite; /** * Tests for {@code LinkedListMultimap}. @@ -56,32 +59,30 @@ import junit.framework.TestSuite; @GwtCompatible(emulated = true) public class LinkedListMultimapTest extends TestCase { - @GwtIncompatible // suite + @GwtIncompatible("suite") public static Test suite() { TestSuite suite = new TestSuite(); - suite.addTest( - ListMultimapTestSuiteBuilder.using( - new TestStringListMultimapGenerator() { - @Override - protected ListMultimap<String, String> create(Entry<String, String>[] entries) { - ListMultimap<String, String> multimap = LinkedListMultimap.create(); - for (Entry<String, String> entry : entries) { - multimap.put(entry.getKey(), entry.getValue()); - } - return multimap; - } - }) - .named("LinkedListMultimap") - .withFeatures( - MapFeature.ALLOWS_NULL_KEYS, - MapFeature.ALLOWS_NULL_VALUES, - MapFeature.ALLOWS_ANY_NULL_QUERIES, - MapFeature.GENERAL_PURPOSE, - CollectionFeature.SUPPORTS_ITERATOR_REMOVE, - CollectionFeature.SERIALIZABLE, - CollectionFeature.KNOWN_ORDER, - CollectionSize.ANY) - .createTestSuite()); + suite.addTest(ListMultimapTestSuiteBuilder.using(new TestStringListMultimapGenerator() { + @Override + protected ListMultimap<String, String> create(Entry<String, String>[] entries) { + ListMultimap<String, String> multimap = LinkedListMultimap.create(); + for (Entry<String, String> entry : entries) { + multimap.put(entry.getKey(), entry.getValue()); + } + return multimap; + } + }) + .named("LinkedListMultimap") + .withFeatures( + MapFeature.ALLOWS_NULL_KEYS, + MapFeature.ALLOWS_NULL_VALUES, + MapFeature.ALLOWS_ANY_NULL_QUERIES, + MapFeature.GENERAL_PURPOSE, + CollectionFeature.SUPPORTS_ITERATOR_REMOVE, + CollectionFeature.SERIALIZABLE, + CollectionFeature.KNOWN_ORDER, + CollectionSize.ANY) + .createTestSuite()); suite.addTestSuite(LinkedListMultimapTest.class); return suite; } @@ -90,7 +91,9 @@ public class LinkedListMultimapTest extends TestCase { return LinkedListMultimap.create(); } - /** Confirm that get() returns a List that doesn't implement RandomAccess. */ + /** + * Confirm that get() returns a List that doesn't implement RandomAccess. + */ public void testGetRandomAccess() { Multimap<String, Integer> multimap = create(); multimap.put("foo", 1); @@ -100,8 +103,8 @@ public class LinkedListMultimapTest extends TestCase { } /** - * Confirm that removeAll() returns a List that implements RandomAccess, even though get() - * doesn't. + * Confirm that removeAll() returns a List that implements RandomAccess, even + * though get() doesn't. */ public void testRemoveAllRandomAccess() { Multimap<String, Integer> multimap = create(); @@ -112,15 +115,17 @@ public class LinkedListMultimapTest extends TestCase { } /** - * Confirm that replaceValues() returns a List that implements RandomAccess, even though get() - * doesn't. + * Confirm that replaceValues() returns a List that implements RandomAccess, + * even though get() doesn't. */ public void testReplaceValuesRandomAccess() { Multimap<String, Integer> multimap = create(); multimap.put("foo", 1); multimap.put("foo", 3); - assertTrue(multimap.replaceValues("foo", Arrays.asList(2, 4)) instanceof RandomAccess); - assertTrue(multimap.replaceValues("bar", Arrays.asList(2, 4)) instanceof RandomAccess); + assertTrue(multimap.replaceValues("foo", Arrays.asList(2, 4)) + instanceof RandomAccess); + assertTrue(multimap.replaceValues("bar", Arrays.asList(2, 4)) + instanceof RandomAccess); } public void testCreateFromMultimap() { @@ -128,13 +133,15 @@ public class LinkedListMultimapTest extends TestCase { multimap.put("foo", 1); multimap.put("bar", 3); multimap.put("foo", 2); - LinkedListMultimap<String, Integer> copy = LinkedListMultimap.create(multimap); + LinkedListMultimap<String, Integer> copy = + LinkedListMultimap.create(multimap); assertEquals(multimap, copy); - assertThat(copy.entries()).containsExactlyElementsIn(multimap.entries()).inOrder(); + assertThat(copy.entries()).has().exactlyAs(multimap.entries()).inOrder(); } public void testCreateFromSize() { - LinkedListMultimap<String, Integer> multimap = LinkedListMultimap.create(20); + LinkedListMultimap<String, Integer> multimap + = LinkedListMultimap.create(20); multimap.put("foo", 1); multimap.put("bar", 2); multimap.put("foo", 3); @@ -145,8 +152,7 @@ public class LinkedListMultimapTest extends TestCase { try { LinkedListMultimap.create(-20); fail(); - } catch (IllegalArgumentException expected) { - } + } catch (IllegalArgumentException expected) {} } public void testLinkedGetAdd() { @@ -158,7 +164,8 @@ public class LinkedListMultimapTest extends TestCase { map.put("bar", 4); map.put("foo", 5); assertEquals("{bar=[1, 4], foo=[2, 3, 5]}", map.toString()); - assertEquals("[bar=1, foo=2, foo=3, bar=4, foo=5]", map.entries().toString()); + assertEquals("[bar=1, foo=2, foo=3, bar=4, foo=5]", + map.entries().toString()); } public void testLinkedGetInsert() { @@ -170,7 +177,8 @@ public class LinkedListMultimapTest extends TestCase { map.put("bar", 4); map.put("foo", 5); assertEquals("{bar=[1, 4], foo=[3, 2, 5]}", map.toString()); - assertEquals("[bar=1, foo=3, foo=2, bar=4, foo=5]", map.entries().toString()); + assertEquals("[bar=1, foo=3, foo=2, bar=4, foo=5]", + map.entries().toString()); } public void testLinkedPutInOrder() { @@ -222,7 +230,7 @@ public class LinkedListMultimapTest extends TestCase { List<Integer> foos = map.get("foo"); Collection<Integer> values = map.values(); assertEquals(asList(1, 2), foos); - assertThat(values).containsExactly(1, 2, 3).inOrder(); + assertThat(values).has().exactly(1, 2, 3).inOrder(); map.clear(); assertEquals(Collections.emptyList(), foos); assertThat(values).isEmpty(); @@ -247,8 +255,9 @@ public class LinkedListMultimapTest extends TestCase { map.put("foo", 2); map.put("bar", 3); map.put("bar", 4); - assertEquals("[bar=1, foo=2, bar=3, bar=4]", map.entries().toString()); - assertThat(map.keys()).containsExactly("bar", "foo", "bar", "bar").inOrder(); + assertEquals("[bar=1, foo=2, bar=3, bar=4]", + map.entries().toString()); + assertThat(map.keys()).has().exactly("bar", "foo", "bar", "bar").inOrder(); map.keys().remove("bar"); // bar is no longer the first key! assertEquals("{foo=[2], bar=[3, 4]}", map.toString()); } @@ -269,8 +278,8 @@ public class LinkedListMultimapTest extends TestCase { map.put("bar", 1); map.put("foo", 2); map.put("bar", 3); - Iterator<Entry<String, Integer>> entries = map.entries().iterator(); - Entry<String, Integer> entry = entries.next(); + Iterator<Map.Entry<String, Integer>> entries = map.entries().iterator(); + Map.Entry<String, Integer> entry = entries.next(); assertEquals("bar", entry.getKey()); assertEquals(1, (int) entry.getValue()); entry = entries.next(); @@ -290,19 +299,19 @@ public class LinkedListMultimapTest extends TestCase { map.put("bar", 1); map.put("foo", 2); map.put("bar", 3); - Iterator<Entry<String, Collection<Integer>>> entries = map.asMap().entrySet().iterator(); - Entry<String, Collection<Integer>> entry = entries.next(); + Iterator<Map.Entry<String, Collection<Integer>>> entries + = map.asMap().entrySet().iterator(); + Map.Entry<String, Collection<Integer>> entry = entries.next(); assertEquals("bar", entry.getKey()); - assertThat(entry.getValue()).containsExactly(1, 3).inOrder(); + assertThat(entry.getValue()).has().exactly(1, 3).inOrder(); try { entry.setValue(Arrays.<Integer>asList()); fail("UnsupportedOperationException expected"); - } catch (UnsupportedOperationException expected) { - } + } catch (UnsupportedOperationException expected) {} entries.remove(); // clear entry = entries.next(); assertEquals("foo", entry.getKey()); - assertThat(entry.getValue()).contains(2); + assertThat(entry.getValue()).has().item(2); assertFalse(entries.hasNext()); assertEquals("{foo=[2]}", map.toString()); } @@ -311,10 +320,10 @@ public class LinkedListMultimapTest extends TestCase { ListMultimap<String, Integer> multimap = create(); multimap.put("foo", 2); multimap.put("bar", 3); - Collection<Entry<String, Integer>> entries = multimap.entries(); - Iterator<Entry<String, Integer>> iterator = entries.iterator(); - Entry<String, Integer> entrya = iterator.next(); - Entry<String, Integer> entryb = iterator.next(); + Collection<Map.Entry<String, Integer>> entries = multimap.entries(); + Iterator<Map.Entry<String, Integer>> iterator = entries.iterator(); + Map.Entry<String, Integer> entrya = iterator.next(); + Map.Entry<String, Integer> entryb = iterator.next(); assertEquals(2, (int) multimap.get("foo").set(0, 4)); assertFalse(multimap.containsEntry("foo", 2)); @@ -332,28 +341,25 @@ public class LinkedListMultimapTest extends TestCase { } @SuppressWarnings("unchecked") - @GwtIncompatible // unreasonably slow + @GwtIncompatible("unreasonably slow") public void testEntriesIteration() { - List<Entry<String, Integer>> addItems = - ImmutableList.of( - Maps.immutableEntry("foo", 99), - Maps.immutableEntry("foo", 88), - Maps.immutableEntry("bar", 77)); + List<Entry<String, Integer>> addItems = ImmutableList.of( + Maps.immutableEntry("foo", 99), + Maps.immutableEntry("foo", 88), + Maps.immutableEntry("bar", 77)); for (final int startIndex : new int[] {0, 3, 5}) { - List<Entry<String, Integer>> list = - Lists.newArrayList( - Maps.immutableEntry("foo", 2), - Maps.immutableEntry("foo", 3), - Maps.immutableEntry("bar", 4), - Maps.immutableEntry("bar", 5), - Maps.immutableEntry("foo", 6)); - new ListIteratorTester<Entry<String, Integer>>( - 3, addItems, ImmutableList.of(SUPPORTS_REMOVE), list, startIndex) { + List<Entry<String, Integer>> list = Lists.newArrayList( + Maps.immutableEntry("foo", 2), + Maps.immutableEntry("foo", 3), + Maps.immutableEntry("bar", 4), + Maps.immutableEntry("bar", 5), + Maps.immutableEntry("foo", 6)); + new ListIteratorTester<Entry<String, Integer>>(3, addItems, + ImmutableList.of(SUPPORTS_REMOVE), list, startIndex) { private LinkedListMultimap<String, Integer> multimap; - @Override - protected ListIterator<Entry<String, Integer>> newTargetIterator() { + @Override protected ListIterator<Entry<String, Integer>> newTargetIterator() { multimap = create(); multimap.putAll("foo", asList(2, 3)); multimap.putAll("bar", asList(4, 5)); @@ -361,25 +367,20 @@ public class LinkedListMultimapTest extends TestCase { return multimap.entries().listIterator(startIndex); } - @Override - protected void verify(List<Entry<String, Integer>> elements) { + @Override protected void verify(List<Entry<String, Integer>> elements) { assertEquals(elements, multimap.entries()); } }.test(); } } - @GwtIncompatible // unreasonably slow + @GwtIncompatible("unreasonably slow") public void testKeysIteration() { - new IteratorTester<String>( - 6, - MODIFIABLE, - newArrayList("foo", "foo", "bar", "bar", "foo"), - IteratorTester.KnownOrder.KNOWN_ORDER) { + new IteratorTester<String>(6, MODIFIABLE, newArrayList("foo", "foo", "bar", + "bar", "foo"), IteratorTester.KnownOrder.KNOWN_ORDER) { private Multimap<String, Integer> multimap; - @Override - protected Iterator<String> newTargetIterator() { + @Override protected Iterator<String> newTargetIterator() { multimap = create(); multimap.putAll("foo", asList(2, 3)); multimap.putAll("bar", asList(4, 5)); @@ -387,28 +388,23 @@ public class LinkedListMultimapTest extends TestCase { return multimap.keys().iterator(); } - @Override - protected void verify(List<String> elements) { + @Override protected void verify(List<String> elements) { assertEquals(elements, Lists.newArrayList(multimap.keys())); } }.test(); } - @GwtIncompatible // unreasonably slow + @GwtIncompatible("unreasonably slow") public void testValuesIteration() { List<Integer> addItems = ImmutableList.of(99, 88, 77); for (final int startIndex : new int[] {0, 3, 5}) { - new ListIteratorTester<Integer>( - 3, - addItems, + new ListIteratorTester<Integer>(3, addItems, ImmutableList.of(SUPPORTS_REMOVE, SUPPORTS_SET), - Lists.newArrayList(2, 3, 4, 5, 6), - startIndex) { + Lists.newArrayList(2, 3, 4, 5, 6), startIndex) { private LinkedListMultimap<String, Integer> multimap; - @Override - protected ListIterator<Integer> newTargetIterator() { + @Override protected ListIterator<Integer> newTargetIterator() { multimap = create(); multimap.put("bar", 2); multimap.putAll("foo", Arrays.asList(3, 4)); @@ -417,25 +413,21 @@ public class LinkedListMultimapTest extends TestCase { return multimap.values().listIterator(startIndex); } - @Override - protected void verify(List<Integer> elements) { + @Override protected void verify(List<Integer> elements) { assertEquals(elements, multimap.values()); } }.test(); } } - @GwtIncompatible // unreasonably slow + @GwtIncompatible("unreasonably slow") public void testKeySetIteration() { - new IteratorTester<String>( - 6, - MODIFIABLE, - newLinkedHashSet(asList("foo", "bar", "baz", "dog", "cat")), + new IteratorTester<String>(6, MODIFIABLE, newLinkedHashSet(asList( + "foo", "bar", "baz", "dog", "cat")), IteratorTester.KnownOrder.KNOWN_ORDER) { private Multimap<String, Integer> multimap; - @Override - protected Iterator<String> newTargetIterator() { + @Override protected Iterator<String> newTargetIterator() { multimap = create(); multimap.putAll("foo", asList(2, 3)); multimap.putAll("bar", asList(4, 5)); @@ -447,31 +439,34 @@ public class LinkedListMultimapTest extends TestCase { return multimap.keySet().iterator(); } - @Override - protected void verify(List<String> elements) { + @Override protected void verify(List<String> elements) { assertEquals(newHashSet(elements), multimap.keySet()); } }.test(); } @SuppressWarnings("unchecked") - @GwtIncompatible // unreasonably slow + @GwtIncompatible("unreasonably slow") public void testAsSetIteration() { - Set<Entry<String, Collection<Integer>>> set = - Sets.newLinkedHashSet( - asList( - Maps.immutableEntry("foo", (Collection<Integer>) asList(2, 3, 6)), - Maps.immutableEntry("bar", (Collection<Integer>) asList(4, 5, 10, 11)), - Maps.immutableEntry("baz", (Collection<Integer>) asList(7, 8)), - Maps.immutableEntry("dog", (Collection<Integer>) asList(9)), - Maps.immutableEntry("cat", (Collection<Integer>) asList(12, 13, 14)))); - - new IteratorTester<Entry<String, Collection<Integer>>>( - 6, MODIFIABLE, set, IteratorTester.KnownOrder.KNOWN_ORDER) { + Set<Entry<String, Collection<Integer>>> set = Sets.newLinkedHashSet(asList( + Maps.immutableEntry("foo", + (Collection<Integer>) asList(2, 3, 6)), + Maps.immutableEntry("bar", + (Collection<Integer>) asList(4, 5, 10, 11)), + Maps.immutableEntry("baz", + (Collection<Integer>) asList(7, 8)), + Maps.immutableEntry("dog", + (Collection<Integer>) asList(9)), + Maps.immutableEntry("cat", + (Collection<Integer>) asList(12, 13, 14)) + )); + + new IteratorTester<Entry<String, Collection<Integer>>>(6, MODIFIABLE, set, + IteratorTester.KnownOrder.KNOWN_ORDER) { private Multimap<String, Integer> multimap; - @Override - protected Iterator<Entry<String, Collection<Integer>>> newTargetIterator() { + @Override protected Iterator<Entry<String, Collection<Integer>>> + newTargetIterator() { multimap = create(); multimap.putAll("foo", asList(2, 3)); multimap.putAll("bar", asList(4, 5)); @@ -483,8 +478,8 @@ public class LinkedListMultimapTest extends TestCase { return multimap.asMap().entrySet().iterator(); } - @Override - protected void verify(List<Entry<String, Collection<Integer>>> elements) { + @Override protected void verify( + List<Entry<String, Collection<Integer>>> elements) { assertEquals(newHashSet(elements), multimap.asMap().entrySet()); } }.test(); @@ -493,7 +488,9 @@ public class LinkedListMultimapTest extends TestCase { public void testEquals() { new EqualsTester() .addEqualityGroup( - LinkedListMultimap.create(), LinkedListMultimap.create(), LinkedListMultimap.create(1)) + LinkedListMultimap.create(), + LinkedListMultimap.create(), + LinkedListMultimap.create(1)) .testEquals(); } } |