ImmutableSortedMultisetTest.java revision 1d580d0f6ee4f21eb309ba7b509d2c6d671c4044 
1/*
2 * Copyright (C) 2011 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5 * in compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License
10 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
11 * or implied. See the License for the specific language governing permissions and limitations under
12 * the License.
13 */
14
15package com.google.common.collect;
16
17import static java.util.Arrays.asList;
18import static org.junit.contrib.truth.Truth.ASSERT;
19
20import com.google.common.base.Function;
21import com.google.common.collect.testing.MinimalCollection;
22import com.google.common.collect.testing.SetTestSuiteBuilder;
23import com.google.common.collect.testing.TestStringSetGenerator;
24import com.google.common.collect.testing.features.CollectionFeature;
25import com.google.common.collect.testing.features.CollectionSize;
26import com.google.common.collect.testing.google.SortedMultisetTestSuiteBuilder;
27import com.google.common.collect.testing.google.TestStringMultisetGenerator;
28import com.google.common.collect.testing.google.UnmodifiableCollectionTests;
29import com.google.common.testing.NullPointerTester;
30import com.google.common.testing.SerializableTester;
31
32import junit.framework.Test;
33import junit.framework.TestCase;
34import junit.framework.TestSuite;
35
36import java.util.Arrays;
37import java.util.Collection;
38import java.util.Collections;
39import java.util.Comparator;
40import java.util.Iterator;
41import java.util.List;
42import java.util.Set;
43
44/**
45 * Tests for {@link ImmutableSortedMultiset}.
46 *
47 * @author Louis Wasserman
48 */
49public class ImmutableSortedMultisetTest extends TestCase {
50  public static Test suite() {
51    TestSuite suite = new TestSuite();
52    suite.addTestSuite(ImmutableSortedMultisetTest.class);
53
54    suite.addTest(SortedMultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {
55      @Override
56      protected Multiset<String> create(String[] elements) {
57        return ImmutableSortedMultiset.copyOf(elements);
58      }
59
60      @Override
61      public List<String> order(List<String> insertionOrder) {
62        return Ordering.natural().sortedCopy(insertionOrder);
63      }
64    }).named("ImmutableSortedMultiset").withFeatures(CollectionSize.ANY,
65        CollectionFeature.ALLOWS_NULL_QUERIES)
66        .createTestSuite());
67
68    suite.addTest(SortedMultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {
69      @Override
70      protected Multiset<String> create(String[] elements) {
71        return SerializableTester.reserialize(ImmutableSortedMultiset.copyOf(elements));
72      }
73
74      @Override
75      public List<String> order(List<String> insertionOrder) {
76        return Ordering.natural().sortedCopy(insertionOrder);
77      }
78    }).named("ImmutableSortedMultiset, reserialized").withFeatures(CollectionSize.ANY,
79        CollectionFeature.ALLOWS_NULL_QUERIES)
80        .createTestSuite());
81
82    suite.addTest(SetTestSuiteBuilder
83        .using(new TestStringSetGenerator() {
84          @Override
85          protected Set<String> create(String[] elements) {
86            return SerializableTester.reserialize(ImmutableSortedMultiset.copyOf(elements)
87                .elementSet());
88          }
89
90          @Override
91          public List<String> order(List<String> insertionOrder) {
92            return Ordering.natural().immutableSortedCopy(insertionOrder);
93          }
94        }).named("ImmutableSortedMultiset, element set").withFeatures(CollectionSize.ANY,
95            CollectionFeature.ALLOWS_NULL_QUERIES)
96        .createTestSuite());
97
98    return suite;
99  }
100
101  public void testCreation_noArgs() {
102    Multiset<String> multiset = ImmutableSortedMultiset.of();
103    assertTrue(multiset.isEmpty());
104  }
105
106  public void testCreation_oneElement() {
107    Multiset<String> multiset = ImmutableSortedMultiset.of("a");
108    assertEquals(HashMultiset.create(asList("a")), multiset);
109  }
110
111  public void testCreation_twoElements() {
112    Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b");
113    assertEquals(HashMultiset.create(asList("a", "b")), multiset);
114  }
115
116  public void testCreation_threeElements() {
117    Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c");
118    assertEquals(HashMultiset.create(asList("a", "b", "c")), multiset);
119  }
120
121  public void testCreation_fourElements() {
122    Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c", "d");
123    assertEquals(HashMultiset.create(asList("a", "b", "c", "d")), multiset);
124  }
125
126  public void testCreation_fiveElements() {
127    Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c", "d", "e");
128    assertEquals(HashMultiset.create(asList("a", "b", "c", "d", "e")), multiset);
129  }
130
131  public void testCreation_sixElements() {
132    Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c", "d", "e", "f");
133    assertEquals(HashMultiset.create(asList("a", "b", "c", "d", "e", "f")), multiset);
134  }
135
136  public void testCreation_sevenElements() {
137    Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c", "d", "e", "f", "g");
138    assertEquals(HashMultiset.create(asList("a", "b", "c", "d", "e", "f", "g")), multiset);
139  }
140
141  public void testCreation_emptyArray() {
142    String[] array = new String[0];
143    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(array);
144    assertTrue(multiset.isEmpty());
145  }
146
147  public void testCreation_arrayOfOneElement() {
148    String[] array = new String[] {"a"};
149    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(array);
150    assertEquals(HashMultiset.create(asList("a")), multiset);
151  }
152
153  public void testCreation_arrayOfArray() {
154    Comparator<String[]> comparator =
155        Ordering.natural().lexicographical()
156            .onResultOf(new Function<String[], Iterable<Comparable>>() {
157              @Override
158              public Iterable<Comparable> apply(String[] input) {
159                return Arrays.<Comparable>asList(input);
160              }
161            });
162    String[] array = new String[] {"a"};
163    Multiset<String[]> multiset = ImmutableSortedMultiset.orderedBy(comparator).add(array).build();
164    Multiset<String[]> expected = HashMultiset.create();
165    expected.add(array);
166    assertEquals(expected, multiset);
167  }
168
169  public void testCreation_arrayContainingOnlyNull() {
170    String[] array = new String[] {null};
171    try {
172      ImmutableSortedMultiset.copyOf(array);
173      fail();
174    } catch (NullPointerException expected) {}
175  }
176
177  public void testCopyOf_collection_empty() {
178    // "<String>" is required to work around a javac 1.5 bug.
179    Collection<String> c = MinimalCollection.<String>of();
180    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c);
181    assertTrue(multiset.isEmpty());
182  }
183
184  public void testCopyOf_collection_oneElement() {
185    Collection<String> c = MinimalCollection.of("a");
186    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c);
187    assertEquals(HashMultiset.create(asList("a")), multiset);
188  }
189
190  public void testCopyOf_collection_general() {
191    Collection<String> c = MinimalCollection.of("a", "b", "a");
192    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c);
193    assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset);
194  }
195
196  public void testCopyOf_collectionContainingNull() {
197    Collection<String> c = MinimalCollection.of("a", null, "b");
198    try {
199      ImmutableSortedMultiset.copyOf(c);
200      fail();
201    } catch (NullPointerException expected) {}
202  }
203
204  public void testCopyOf_multiset_empty() {
205    Multiset<String> c = HashMultiset.create();
206    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c);
207    assertTrue(multiset.isEmpty());
208  }
209
210  public void testCopyOf_multiset_oneElement() {
211    Multiset<String> c = HashMultiset.create(asList("a"));
212    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c);
213    assertEquals(HashMultiset.create(asList("a")), multiset);
214  }
215
216  public void testCopyOf_multiset_general() {
217    Multiset<String> c = HashMultiset.create(asList("a", "b", "a"));
218    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c);
219    assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset);
220  }
221
222  public void testCopyOf_multisetContainingNull() {
223    Multiset<String> c = HashMultiset.create(asList("a", null, "b"));
224    try {
225      ImmutableSortedMultiset.copyOf(c);
226      fail();
227    } catch (NullPointerException expected) {}
228  }
229
230  public void testCopyOf_iterator_empty() {
231    Iterator<String> iterator = Iterators.emptyIterator();
232    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(iterator);
233    assertTrue(multiset.isEmpty());
234  }
235
236  public void testCopyOf_iterator_oneElement() {
237    Iterator<String> iterator = Iterators.singletonIterator("a");
238    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(iterator);
239    assertEquals(HashMultiset.create(asList("a")), multiset);
240  }
241
242  public void testCopyOf_iterator_general() {
243    Iterator<String> iterator = asList("a", "b", "a").iterator();
244    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(iterator);
245    assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset);
246  }
247
248  public void testCopyOf_iteratorContainingNull() {
249    Iterator<String> iterator = asList("a", null, "b").iterator();
250    try {
251      ImmutableSortedMultiset.copyOf(iterator);
252      fail();
253    } catch (NullPointerException expected) {}
254  }
255
256  private static class CountingIterable implements Iterable<String> {
257    int count = 0;
258
259    @Override
260    public Iterator<String> iterator() {
261      count++;
262      return asList("a", "b", "a").iterator();
263    }
264  }
265
266  public void testCopyOf_plainIterable() {
267    CountingIterable iterable = new CountingIterable();
268    Multiset<String> multiset = ImmutableSortedMultiset.copyOf(iterable);
269    assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset);
270    assertEquals(1, iterable.count);
271  }
272
273  public void testCopyOf_shortcut_empty() {
274    Collection<String> c = ImmutableSortedMultiset.of();
275    assertSame(c, ImmutableSortedMultiset.copyOf(c));
276  }
277
278  public void testCopyOf_shortcut_singleton() {
279    Collection<String> c = ImmutableSortedMultiset.of("a");
280    assertSame(c, ImmutableSortedMultiset.copyOf(c));
281  }
282
283  public void testCopyOf_shortcut_immutableMultiset() {
284    Collection<String> c = ImmutableSortedMultiset.of("a", "b", "c");
285    assertSame(c, ImmutableSortedMultiset.copyOf(c));
286  }
287
288  public void testBuilderAdd() {
289    ImmutableSortedMultiset<String> multiset =
290        ImmutableSortedMultiset.<String>naturalOrder().add("a").add("b").add("a").add("c").build();
291    assertEquals(HashMultiset.create(asList("a", "b", "a", "c")), multiset);
292  }
293
294  public void testBuilderAddAll() {
295    List<String> a = asList("a", "b");
296    List<String> b = asList("c", "d");
297    ImmutableSortedMultiset<String> multiset =
298        ImmutableSortedMultiset.<String>naturalOrder().addAll(a).addAll(b).build();
299    assertEquals(HashMultiset.create(asList("a", "b", "c", "d")), multiset);
300  }
301
302  public void testBuilderAddAllMultiset() {
303    Multiset<String> a = HashMultiset.create(asList("a", "b", "b"));
304    Multiset<String> b = HashMultiset.create(asList("c", "b"));
305    ImmutableSortedMultiset<String> multiset =
306        ImmutableSortedMultiset.<String>naturalOrder().addAll(a).addAll(b).build();
307    assertEquals(HashMultiset.create(asList("a", "b", "b", "b", "c")), multiset);
308  }
309
310  public void testBuilderAddAllIterator() {
311    Iterator<String> iterator = asList("a", "b", "a", "c").iterator();
312    ImmutableSortedMultiset<String> multiset =
313        ImmutableSortedMultiset.<String>naturalOrder().addAll(iterator).build();
314    assertEquals(HashMultiset.create(asList("a", "b", "a", "c")), multiset);
315  }
316
317  public void testBuilderAddCopies() {
318    ImmutableSortedMultiset<String> multiset =
319        ImmutableSortedMultiset.<String>naturalOrder().addCopies("a", 2).addCopies("b", 3)
320            .addCopies("c", 0).build();
321    assertEquals(HashMultiset.create(asList("a", "a", "b", "b", "b")), multiset);
322  }
323
324  public void testBuilderSetCount() {
325    ImmutableSortedMultiset<String> multiset =
326        ImmutableSortedMultiset.<String>naturalOrder().add("a").setCount("a", 2).setCount("b", 3)
327            .build();
328    assertEquals(HashMultiset.create(asList("a", "a", "b", "b", "b")), multiset);
329  }
330
331  public void testBuilderAddHandlesNullsCorrectly() {
332    ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
333    try {
334      builder.add((String) null);
335      fail("expected NullPointerException");
336    } catch (NullPointerException expected) {}
337  }
338
339  public void testBuilderAddAllHandlesNullsCorrectly() {
340    ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
341    try {
342      builder.addAll((Collection<String>) null);
343      fail("expected NullPointerException");
344    } catch (NullPointerException expected) {}
345
346    builder = ImmutableSortedMultiset.naturalOrder();
347    List<String> listWithNulls = asList("a", null, "b");
348    try {
349      builder.addAll(listWithNulls);
350      fail("expected NullPointerException");
351    } catch (NullPointerException expected) {}
352
353    builder = ImmutableSortedMultiset.naturalOrder();
354    Multiset<String> multisetWithNull = LinkedHashMultiset.create(asList("a", null, "b"));
355    try {
356      builder.addAll(multisetWithNull);
357      fail("expected NullPointerException");
358    } catch (NullPointerException expected) {}
359  }
360
361  public void testBuilderAddCopiesHandlesNullsCorrectly() {
362    ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
363    try {
364      builder.addCopies(null, 2);
365      fail("expected NullPointerException");
366    } catch (NullPointerException expected) {}
367  }
368
369  public void testBuilderAddCopiesIllegal() {
370    ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
371    try {
372      builder.addCopies("a", -2);
373      fail("expected IllegalArgumentException");
374    } catch (IllegalArgumentException expected) {}
375  }
376
377  public void testBuilderSetCountHandlesNullsCorrectly() {
378    ImmutableSortedMultiset.Builder<String> builder =
379        new ImmutableSortedMultiset.Builder<String>(Ordering.natural().nullsFirst());
380    try {
381      builder.setCount(null, 2);
382      fail("expected NullPointerException");
383    } catch (NullPointerException expected) {}
384  }
385
386  public void testBuilderSetCountIllegal() {
387    ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
388    try {
389      builder.setCount("a", -2);
390      fail("expected IllegalArgumentException");
391    } catch (IllegalArgumentException expected) {}
392  }
393
394  public void testNullPointers() throws Exception {
395    NullPointerTester tester = new NullPointerTester();
396    tester.setDefault(Comparator.class, Ordering.natural());
397    tester.setDefault(Comparable.class, "");
398    tester.setDefault(Iterator.class, Iterators.emptyIterator());
399    tester.setDefault(Iterable.class, Collections.emptySet());
400    tester.setDefault(Comparable[].class, new Comparable[0]);
401    tester.testAllPublicStaticMethods(ImmutableSortedMultiset.class);
402  }
403
404  public void testSerialization_empty() {
405    Collection<String> c = ImmutableSortedMultiset.of();
406    assertSame(c, SerializableTester.reserialize(c));
407  }
408
409  public void testSerialization_multiple() {
410    Collection<String> c = ImmutableSortedMultiset.of("a", "b", "a");
411    Collection<String> copy = SerializableTester.reserializeAndAssert(c);
412    ASSERT.that(copy).hasContentsInOrder("a", "a", "b");
413  }
414
415  public void testSerialization_elementSet() {
416    Multiset<String> c = ImmutableSortedMultiset.of("a", "b", "a");
417    Collection<String> copy = SerializableTester.reserializeAndAssert(c.elementSet());
418    ASSERT.that(copy).hasContentsInOrder("a", "b");
419  }
420
421  public void testSerialization_entrySet() {
422    Multiset<String> c = ImmutableSortedMultiset.of("a", "b", "c");
423    SerializableTester.reserializeAndAssert(c.entrySet());
424  }
425
426  public void testEquals_immutableMultiset() {
427    Collection<String> c = ImmutableSortedMultiset.of("a", "b", "a");
428    assertEquals(c, ImmutableSortedMultiset.of("a", "b", "a"));
429    assertEquals(c, ImmutableSortedMultiset.of("a", "a", "b"));
430    ASSERT.that(c).isNotEqualTo(ImmutableSortedMultiset.of("a", "b"));
431    ASSERT.that(c).isNotEqualTo(ImmutableSortedMultiset.of("a", "b", "c", "d"));
432  }
433
434  public void testIterationOrder() {
435    Collection<String> c = ImmutableSortedMultiset.of("a", "b", "a");
436    ASSERT.that(c).hasContentsInOrder("a", "a", "b");
437  }
438
439  public void testMultisetWrites() {
440    Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "a");
441    UnmodifiableCollectionTests.assertMultisetIsUnmodifiable(multiset, "test");
442  }
443
444  public void testAsList() {
445    ImmutableSortedMultiset<String> multiset = ImmutableSortedMultiset.of("a", "a", "b", "b", "b");
446    ImmutableList<String> list = multiset.asList();
447    assertEquals(ImmutableList.of("a", "a", "b", "b", "b"), list);
448    assertTrue(list instanceof ImmutableAsList);
449    ImmutableList<String> copy = SerializableTester.reserializeAndAssert(list);
450    assertTrue(copy instanceof ImmutableAsList);
451    assertEquals(2, list.indexOf("b"));
452    assertEquals(4, list.lastIndexOf("b"));
453  }
454}
455