1 /* 2 * Copyright (C) 2007 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.common.collect; 18 19 import static com.google.common.truth.Truth.assertThat; 20 21 import com.google.common.annotations.GwtCompatible; 22 import com.google.common.annotations.GwtIncompatible; 23 import com.google.common.collect.testing.DerivedComparable; 24 import com.google.common.testing.NullPointerTester; 25 import java.util.Arrays; 26 import java.util.Collections; 27 import java.util.List; 28 import junit.framework.TestCase; 29 30 /** 31 * Tests for {@link Multisets}. 32 * 33 * @author Mike Bostock 34 * @author Jared Levy 35 * @author Louis Wasserman 36 */ 37 @GwtCompatible(emulated = true) 38 public class MultisetsTest extends TestCase { 39 40 /* See MultisetsImmutableEntryTest for immutableEntry() tests. */ 41 testNewTreeMultisetDerived()42 public void testNewTreeMultisetDerived() { 43 TreeMultiset<DerivedComparable> set = TreeMultiset.create(); 44 assertTrue(set.isEmpty()); 45 set.add(new DerivedComparable("foo"), 2); 46 set.add(new DerivedComparable("bar"), 3); 47 assertThat(set) 48 .containsExactly( 49 new DerivedComparable("bar"), 50 new DerivedComparable("bar"), 51 new DerivedComparable("bar"), 52 new DerivedComparable("foo"), 53 new DerivedComparable("foo")) 54 .inOrder(); 55 } 56 testNewTreeMultisetNonGeneric()57 public void testNewTreeMultisetNonGeneric() { 58 TreeMultiset<LegacyComparable> set = TreeMultiset.create(); 59 assertTrue(set.isEmpty()); 60 set.add(new LegacyComparable("foo"), 2); 61 set.add(new LegacyComparable("bar"), 3); 62 assertThat(set) 63 .containsExactly( 64 new LegacyComparable("bar"), 65 new LegacyComparable("bar"), 66 new LegacyComparable("bar"), 67 new LegacyComparable("foo"), 68 new LegacyComparable("foo")) 69 .inOrder(); 70 } 71 testNewTreeMultisetComparator()72 public void testNewTreeMultisetComparator() { 73 TreeMultiset<String> multiset = TreeMultiset.create(Collections.reverseOrder()); 74 multiset.add("bar", 3); 75 multiset.add("foo", 2); 76 assertThat(multiset).containsExactly("foo", "foo", "bar", "bar", "bar").inOrder(); 77 } 78 testRetainOccurrencesEmpty()79 public void testRetainOccurrencesEmpty() { 80 Multiset<String> multiset = HashMultiset.create(); 81 Multiset<String> toRetain = HashMultiset.create(Arrays.asList("a", "b", "a")); 82 assertFalse(Multisets.retainOccurrences(multiset, toRetain)); 83 assertThat(multiset).isEmpty(); 84 } 85 testRemoveOccurrencesIterableEmpty()86 public void testRemoveOccurrencesIterableEmpty() { 87 Multiset<String> multiset = HashMultiset.create(); 88 Iterable<String> toRemove = Arrays.asList("a", "b", "a"); 89 assertFalse(Multisets.removeOccurrences(multiset, toRemove)); 90 assertTrue(multiset.isEmpty()); 91 } 92 testRemoveOccurrencesMultisetEmpty()93 public void testRemoveOccurrencesMultisetEmpty() { 94 Multiset<String> multiset = HashMultiset.create(); 95 Multiset<String> toRemove = HashMultiset.create(Arrays.asList("a", "b", "a")); 96 assertFalse(Multisets.removeOccurrences(multiset, toRemove)); 97 assertTrue(multiset.isEmpty()); 98 } 99 testUnion()100 public void testUnion() { 101 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 102 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "b", "c")); 103 assertThat(Multisets.union(ms1, ms2)).containsExactly("a", "a", "b", "b", "c"); 104 } 105 testUnionEqualMultisets()106 public void testUnionEqualMultisets() { 107 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 108 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 109 assertEquals(ms1, Multisets.union(ms1, ms2)); 110 } 111 testUnionEmptyNonempty()112 public void testUnionEmptyNonempty() { 113 Multiset<String> ms1 = HashMultiset.create(); 114 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 115 assertEquals(ms2, Multisets.union(ms1, ms2)); 116 } 117 testUnionNonemptyEmpty()118 public void testUnionNonemptyEmpty() { 119 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 120 Multiset<String> ms2 = HashMultiset.create(); 121 assertEquals(ms1, Multisets.union(ms1, ms2)); 122 } 123 testIntersectEmptyNonempty()124 public void testIntersectEmptyNonempty() { 125 Multiset<String> ms1 = HashMultiset.create(); 126 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 127 assertThat(Multisets.intersection(ms1, ms2)).isEmpty(); 128 } 129 testIntersectNonemptyEmpty()130 public void testIntersectNonemptyEmpty() { 131 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 132 Multiset<String> ms2 = HashMultiset.create(); 133 assertThat(Multisets.intersection(ms1, ms2)).isEmpty(); 134 } 135 testSum()136 public void testSum() { 137 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 138 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("b", "c")); 139 assertThat(Multisets.sum(ms1, ms2)).containsExactly("a", "a", "b", "b", "c"); 140 } 141 testSumEmptyNonempty()142 public void testSumEmptyNonempty() { 143 Multiset<String> ms1 = HashMultiset.create(); 144 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 145 assertThat(Multisets.sum(ms1, ms2)).containsExactly("a", "b", "a"); 146 } 147 testSumNonemptyEmpty()148 public void testSumNonemptyEmpty() { 149 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 150 Multiset<String> ms2 = HashMultiset.create(); 151 assertThat(Multisets.sum(ms1, ms2)).containsExactly("a", "b", "a"); 152 } 153 testDifferenceWithNoRemovedElements()154 public void testDifferenceWithNoRemovedElements() { 155 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 156 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a")); 157 assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "b"); 158 } 159 testDifferenceWithRemovedElement()160 public void testDifferenceWithRemovedElement() { 161 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 162 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("b")); 163 assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "a"); 164 } 165 testDifferenceWithMoreElementsInSecondMultiset()166 public void testDifferenceWithMoreElementsInSecondMultiset() { 167 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 168 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "b", "b")); 169 Multiset<String> diff = Multisets.difference(ms1, ms2); 170 assertThat(diff).contains("a"); 171 assertEquals(0, diff.count("b")); 172 assertEquals(1, diff.count("a")); 173 assertFalse(diff.contains("b")); 174 assertTrue(diff.contains("a")); 175 } 176 testDifferenceEmptyNonempty()177 public void testDifferenceEmptyNonempty() { 178 Multiset<String> ms1 = HashMultiset.create(); 179 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 180 assertEquals(ms1, Multisets.difference(ms1, ms2)); 181 } 182 testDifferenceNonemptyEmpty()183 public void testDifferenceNonemptyEmpty() { 184 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 185 Multiset<String> ms2 = HashMultiset.create(); 186 assertEquals(ms1, Multisets.difference(ms1, ms2)); 187 } 188 testContainsOccurrencesEmpty()189 public void testContainsOccurrencesEmpty() { 190 Multiset<String> superMultiset = HashMultiset.create(Arrays.asList("a", "b", "a")); 191 Multiset<String> subMultiset = HashMultiset.create(); 192 assertTrue(Multisets.containsOccurrences(superMultiset, subMultiset)); 193 assertFalse(Multisets.containsOccurrences(subMultiset, superMultiset)); 194 } 195 testContainsOccurrences()196 public void testContainsOccurrences() { 197 Multiset<String> superMultiset = HashMultiset.create(Arrays.asList("a", "b", "a")); 198 Multiset<String> subMultiset = HashMultiset.create(Arrays.asList("a", "b")); 199 assertTrue(Multisets.containsOccurrences(superMultiset, subMultiset)); 200 assertFalse(Multisets.containsOccurrences(subMultiset, superMultiset)); 201 Multiset<String> diffMultiset = HashMultiset.create(Arrays.asList("a", "b", "c")); 202 assertFalse(Multisets.containsOccurrences(superMultiset, diffMultiset)); 203 assertTrue(Multisets.containsOccurrences(diffMultiset, subMultiset)); 204 } 205 testRetainEmptyOccurrences()206 public void testRetainEmptyOccurrences() { 207 Multiset<String> multiset = HashMultiset.create(Arrays.asList("a", "b", "a")); 208 Multiset<String> toRetain = HashMultiset.create(); 209 assertTrue(Multisets.retainOccurrences(multiset, toRetain)); 210 assertTrue(multiset.isEmpty()); 211 } 212 testRetainOccurrences()213 public void testRetainOccurrences() { 214 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a", "c")); 215 Multiset<String> toRetain = HashMultiset.create(Arrays.asList("a", "b", "b")); 216 assertTrue(Multisets.retainOccurrences(multiset, toRetain)); 217 assertThat(multiset).containsExactly("a", "b").inOrder(); 218 } 219 testRemoveEmptyOccurrencesMultiset()220 public void testRemoveEmptyOccurrencesMultiset() { 221 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a")); 222 Multiset<String> toRemove = HashMultiset.create(); 223 assertFalse(Multisets.removeOccurrences(multiset, toRemove)); 224 assertThat(multiset).containsExactly("a", "a", "b").inOrder(); 225 } 226 testRemoveOccurrencesMultiset()227 public void testRemoveOccurrencesMultiset() { 228 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a", "c")); 229 Multiset<String> toRemove = HashMultiset.create(Arrays.asList("a", "b", "b")); 230 assertTrue(Multisets.removeOccurrences(multiset, toRemove)); 231 assertThat(multiset).containsExactly("a", "c").inOrder(); 232 } 233 testRemoveEmptyOccurrencesIterable()234 public void testRemoveEmptyOccurrencesIterable() { 235 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a")); 236 Iterable<String> toRemove = ImmutableList.of(); 237 assertFalse(Multisets.removeOccurrences(multiset, toRemove)); 238 assertThat(multiset).containsExactly("a", "a", "b").inOrder(); 239 } 240 testRemoveOccurrencesMultisetIterable()241 public void testRemoveOccurrencesMultisetIterable() { 242 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a", "c")); 243 List<String> toRemove = Arrays.asList("a", "b", "b"); 244 assertTrue(Multisets.removeOccurrences(multiset, toRemove)); 245 assertThat(multiset).containsExactly("a", "c").inOrder(); 246 } 247 248 @SuppressWarnings("deprecation") testUnmodifiableMultisetShortCircuit()249 public void testUnmodifiableMultisetShortCircuit() { 250 Multiset<String> mod = HashMultiset.create(); 251 Multiset<String> unmod = Multisets.unmodifiableMultiset(mod); 252 assertNotSame(mod, unmod); 253 assertSame(unmod, Multisets.unmodifiableMultiset(unmod)); 254 ImmutableMultiset<String> immutable = ImmutableMultiset.of("a", "a", "b", "a"); 255 assertSame(immutable, Multisets.unmodifiableMultiset(immutable)); 256 assertSame(immutable, Multisets.unmodifiableMultiset((Multiset<String>) immutable)); 257 } 258 testHighestCountFirst()259 public void testHighestCountFirst() { 260 Multiset<String> multiset = HashMultiset.create(Arrays.asList("a", "a", "a", "b", "c", "c")); 261 ImmutableMultiset<String> sortedMultiset = Multisets.copyHighestCountFirst(multiset); 262 263 assertThat(sortedMultiset.entrySet()) 264 .containsExactly( 265 Multisets.immutableEntry("a", 3), 266 Multisets.immutableEntry("c", 2), 267 Multisets.immutableEntry("b", 1)) 268 .inOrder(); 269 270 assertThat(sortedMultiset).containsExactly("a", "a", "a", "c", "c", "b").inOrder(); 271 272 assertThat(Multisets.copyHighestCountFirst(ImmutableMultiset.of())).isEmpty(); 273 } 274 275 @GwtIncompatible // NullPointerTester 276 @AndroidIncompatible // see ImmutableTableTest.testNullPointerInstance testNullPointers()277 public void testNullPointers() { 278 new NullPointerTester().testAllPublicStaticMethods(Multisets.class); 279 } 280 } 281