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.CollectorTester; 25 import com.google.common.testing.NullPointerTester; 26 import java.util.Arrays; 27 import java.util.Collections; 28 import java.util.List; 29 import java.util.function.BiPredicate; 30 import junit.framework.TestCase; 31 32 /** 33 * Tests for {@link Multisets}. 34 * 35 * @author Mike Bostock 36 * @author Jared Levy 37 * @author Louis Wasserman 38 */ 39 @GwtCompatible(emulated = true) 40 public class MultisetsTest extends TestCase { 41 42 /* See MultisetsImmutableEntryTest for immutableEntry() tests. */ 43 testNewTreeMultisetDerived()44 public void testNewTreeMultisetDerived() { 45 TreeMultiset<DerivedComparable> set = TreeMultiset.create(); 46 assertTrue(set.isEmpty()); 47 set.add(new DerivedComparable("foo"), 2); 48 set.add(new DerivedComparable("bar"), 3); 49 assertThat(set) 50 .containsExactly( 51 new DerivedComparable("bar"), 52 new DerivedComparable("bar"), 53 new DerivedComparable("bar"), 54 new DerivedComparable("foo"), 55 new DerivedComparable("foo")) 56 .inOrder(); 57 } 58 testNewTreeMultisetNonGeneric()59 public void testNewTreeMultisetNonGeneric() { 60 TreeMultiset<LegacyComparable> set = TreeMultiset.create(); 61 assertTrue(set.isEmpty()); 62 set.add(new LegacyComparable("foo"), 2); 63 set.add(new LegacyComparable("bar"), 3); 64 assertThat(set) 65 .containsExactly( 66 new LegacyComparable("bar"), 67 new LegacyComparable("bar"), 68 new LegacyComparable("bar"), 69 new LegacyComparable("foo"), 70 new LegacyComparable("foo")) 71 .inOrder(); 72 } 73 testNewTreeMultisetComparator()74 public void testNewTreeMultisetComparator() { 75 TreeMultiset<String> multiset = TreeMultiset.create(Collections.reverseOrder()); 76 multiset.add("bar", 3); 77 multiset.add("foo", 2); 78 assertThat(multiset).containsExactly("foo", "foo", "bar", "bar", "bar").inOrder(); 79 } 80 testRetainOccurrencesEmpty()81 public void testRetainOccurrencesEmpty() { 82 Multiset<String> multiset = HashMultiset.create(); 83 Multiset<String> toRetain = HashMultiset.create(Arrays.asList("a", "b", "a")); 84 assertFalse(Multisets.retainOccurrences(multiset, toRetain)); 85 assertThat(multiset).isEmpty(); 86 } 87 testRemoveOccurrencesIterableEmpty()88 public void testRemoveOccurrencesIterableEmpty() { 89 Multiset<String> multiset = HashMultiset.create(); 90 Iterable<String> toRemove = Arrays.asList("a", "b", "a"); 91 assertFalse(Multisets.removeOccurrences(multiset, toRemove)); 92 assertTrue(multiset.isEmpty()); 93 } 94 testRemoveOccurrencesMultisetEmpty()95 public void testRemoveOccurrencesMultisetEmpty() { 96 Multiset<String> multiset = HashMultiset.create(); 97 Multiset<String> toRemove = HashMultiset.create(Arrays.asList("a", "b", "a")); 98 assertFalse(Multisets.removeOccurrences(multiset, toRemove)); 99 assertTrue(multiset.isEmpty()); 100 } 101 testUnion()102 public void testUnion() { 103 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 104 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "b", "c")); 105 assertThat(Multisets.union(ms1, ms2)).containsExactly("a", "a", "b", "b", "c"); 106 } 107 testUnionEqualMultisets()108 public void testUnionEqualMultisets() { 109 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 110 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 111 assertEquals(ms1, Multisets.union(ms1, ms2)); 112 } 113 testUnionEmptyNonempty()114 public void testUnionEmptyNonempty() { 115 Multiset<String> ms1 = HashMultiset.create(); 116 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 117 assertEquals(ms2, Multisets.union(ms1, ms2)); 118 } 119 testUnionNonemptyEmpty()120 public void testUnionNonemptyEmpty() { 121 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 122 Multiset<String> ms2 = HashMultiset.create(); 123 assertEquals(ms1, Multisets.union(ms1, ms2)); 124 } 125 testIntersectEmptyNonempty()126 public void testIntersectEmptyNonempty() { 127 Multiset<String> ms1 = HashMultiset.create(); 128 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 129 assertThat(Multisets.intersection(ms1, ms2)).isEmpty(); 130 } 131 testIntersectNonemptyEmpty()132 public void testIntersectNonemptyEmpty() { 133 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 134 Multiset<String> ms2 = HashMultiset.create(); 135 assertThat(Multisets.intersection(ms1, ms2)).isEmpty(); 136 } 137 testSum()138 public void testSum() { 139 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 140 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("b", "c")); 141 assertThat(Multisets.sum(ms1, ms2)).containsExactly("a", "a", "b", "b", "c"); 142 } 143 testSumEmptyNonempty()144 public void testSumEmptyNonempty() { 145 Multiset<String> ms1 = HashMultiset.create(); 146 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 147 assertThat(Multisets.sum(ms1, ms2)).containsExactly("a", "b", "a"); 148 } 149 testSumNonemptyEmpty()150 public void testSumNonemptyEmpty() { 151 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 152 Multiset<String> ms2 = HashMultiset.create(); 153 assertThat(Multisets.sum(ms1, ms2)).containsExactly("a", "b", "a"); 154 } 155 testDifferenceWithNoRemovedElements()156 public void testDifferenceWithNoRemovedElements() { 157 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 158 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a")); 159 assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "b"); 160 } 161 testDifferenceWithRemovedElement()162 public void testDifferenceWithRemovedElement() { 163 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 164 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("b")); 165 assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "a"); 166 } 167 testDifferenceWithMoreElementsInSecondMultiset()168 public void testDifferenceWithMoreElementsInSecondMultiset() { 169 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 170 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "b", "b")); 171 Multiset<String> diff = Multisets.difference(ms1, ms2); 172 assertThat(diff).contains("a"); 173 assertEquals(0, diff.count("b")); 174 assertEquals(1, diff.count("a")); 175 assertFalse(diff.contains("b")); 176 assertTrue(diff.contains("a")); 177 } 178 testDifferenceEmptyNonempty()179 public void testDifferenceEmptyNonempty() { 180 Multiset<String> ms1 = HashMultiset.create(); 181 Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); 182 assertEquals(ms1, Multisets.difference(ms1, ms2)); 183 } 184 testDifferenceNonemptyEmpty()185 public void testDifferenceNonemptyEmpty() { 186 Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); 187 Multiset<String> ms2 = HashMultiset.create(); 188 assertEquals(ms1, Multisets.difference(ms1, ms2)); 189 } 190 testContainsOccurrencesEmpty()191 public void testContainsOccurrencesEmpty() { 192 Multiset<String> superMultiset = HashMultiset.create(Arrays.asList("a", "b", "a")); 193 Multiset<String> subMultiset = HashMultiset.create(); 194 assertTrue(Multisets.containsOccurrences(superMultiset, subMultiset)); 195 assertFalse(Multisets.containsOccurrences(subMultiset, superMultiset)); 196 } 197 testContainsOccurrences()198 public void testContainsOccurrences() { 199 Multiset<String> superMultiset = HashMultiset.create(Arrays.asList("a", "b", "a")); 200 Multiset<String> subMultiset = HashMultiset.create(Arrays.asList("a", "b")); 201 assertTrue(Multisets.containsOccurrences(superMultiset, subMultiset)); 202 assertFalse(Multisets.containsOccurrences(subMultiset, superMultiset)); 203 Multiset<String> diffMultiset = HashMultiset.create(Arrays.asList("a", "b", "c")); 204 assertFalse(Multisets.containsOccurrences(superMultiset, diffMultiset)); 205 assertTrue(Multisets.containsOccurrences(diffMultiset, subMultiset)); 206 } 207 testRetainEmptyOccurrences()208 public void testRetainEmptyOccurrences() { 209 Multiset<String> multiset = HashMultiset.create(Arrays.asList("a", "b", "a")); 210 Multiset<String> toRetain = HashMultiset.create(); 211 assertTrue(Multisets.retainOccurrences(multiset, toRetain)); 212 assertTrue(multiset.isEmpty()); 213 } 214 testRetainOccurrences()215 public void testRetainOccurrences() { 216 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a", "c")); 217 Multiset<String> toRetain = HashMultiset.create(Arrays.asList("a", "b", "b")); 218 assertTrue(Multisets.retainOccurrences(multiset, toRetain)); 219 assertThat(multiset).containsExactly("a", "b").inOrder(); 220 } 221 testRemoveEmptyOccurrencesMultiset()222 public void testRemoveEmptyOccurrencesMultiset() { 223 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a")); 224 Multiset<String> toRemove = HashMultiset.create(); 225 assertFalse(Multisets.removeOccurrences(multiset, toRemove)); 226 assertThat(multiset).containsExactly("a", "a", "b").inOrder(); 227 } 228 testRemoveOccurrencesMultiset()229 public void testRemoveOccurrencesMultiset() { 230 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a", "c")); 231 Multiset<String> toRemove = HashMultiset.create(Arrays.asList("a", "b", "b")); 232 assertTrue(Multisets.removeOccurrences(multiset, toRemove)); 233 assertThat(multiset).containsExactly("a", "c").inOrder(); 234 } 235 testRemoveEmptyOccurrencesIterable()236 public void testRemoveEmptyOccurrencesIterable() { 237 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a")); 238 Iterable<String> toRemove = ImmutableList.of(); 239 assertFalse(Multisets.removeOccurrences(multiset, toRemove)); 240 assertThat(multiset).containsExactly("a", "a", "b").inOrder(); 241 } 242 testRemoveOccurrencesMultisetIterable()243 public void testRemoveOccurrencesMultisetIterable() { 244 Multiset<String> multiset = TreeMultiset.create(Arrays.asList("a", "b", "a", "c")); 245 List<String> toRemove = Arrays.asList("a", "b", "b"); 246 assertTrue(Multisets.removeOccurrences(multiset, toRemove)); 247 assertThat(multiset).containsExactly("a", "c").inOrder(); 248 } 249 250 @SuppressWarnings("deprecation") testUnmodifiableMultisetShortCircuit()251 public void testUnmodifiableMultisetShortCircuit() { 252 Multiset<String> mod = HashMultiset.create(); 253 Multiset<String> unmod = Multisets.unmodifiableMultiset(mod); 254 assertNotSame(mod, unmod); 255 assertSame(unmod, Multisets.unmodifiableMultiset(unmod)); 256 ImmutableMultiset<String> immutable = ImmutableMultiset.of("a", "a", "b", "a"); 257 assertSame(immutable, Multisets.unmodifiableMultiset(immutable)); 258 assertSame(immutable, Multisets.unmodifiableMultiset((Multiset<String>) immutable)); 259 } 260 testHighestCountFirst()261 public void testHighestCountFirst() { 262 Multiset<String> multiset = HashMultiset.create(Arrays.asList("a", "a", "a", "b", "c", "c")); 263 ImmutableMultiset<String> sortedMultiset = Multisets.copyHighestCountFirst(multiset); 264 265 assertThat(sortedMultiset.entrySet()) 266 .containsExactly( 267 Multisets.immutableEntry("a", 3), 268 Multisets.immutableEntry("c", 2), 269 Multisets.immutableEntry("b", 1)) 270 .inOrder(); 271 272 assertThat(sortedMultiset).containsExactly("a", "a", "a", "c", "c", "b").inOrder(); 273 274 assertThat(Multisets.copyHighestCountFirst(ImmutableMultiset.of())).isEmpty(); 275 } 276 testToMultisetCountFunction()277 public void testToMultisetCountFunction() { 278 BiPredicate<Multiset<String>, Multiset<String>> equivalence = 279 (ms1, ms2) -> 280 ms1.equals(ms2) 281 && ImmutableList.copyOf(ms1.entrySet()) 282 .equals(ImmutableList.copyOf(ms2.entrySet())); 283 CollectorTester.of( 284 Multisets.<Multiset.Entry<String>, String, Multiset<String>>toMultiset( 285 Multiset.Entry::getElement, Multiset.Entry::getCount, LinkedHashMultiset::create), 286 equivalence) 287 .expectCollects(ImmutableMultiset.<String>of()) 288 .expectCollects( 289 ImmutableMultiset.of("a", "a", "b", "c", "c", "c"), 290 Multisets.immutableEntry("a", 1), 291 Multisets.immutableEntry("b", 1), 292 Multisets.immutableEntry("a", 1), 293 Multisets.immutableEntry("c", 3)); 294 } 295 296 @GwtIncompatible // NullPointerTester 297 @AndroidIncompatible // see ImmutableTableTest.testNullPointerInstance testNullPointers()298 public void testNullPointers() { 299 new NullPointerTester().testAllPublicStaticMethods(Multisets.class); 300 } 301 } 302