/* * Copyright (C) 2007 The Guava Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.google.common.collect; 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.collect.ImmutableSet.Builder; import com.google.common.collect.testing.ListTestSuiteBuilder; import com.google.common.collect.testing.SetTestSuiteBuilder; import com.google.common.collect.testing.TestStringSetGenerator; import com.google.common.collect.testing.features.CollectionFeature; import com.google.common.collect.testing.features.CollectionSize; import com.google.common.collect.testing.google.SetGenerators.DegeneratedImmutableSetGenerator; import com.google.common.collect.testing.google.SetGenerators.ImmutableSetAsListGenerator; import com.google.common.collect.testing.google.SetGenerators.ImmutableSetCopyOfGenerator; import com.google.common.collect.testing.google.SetGenerators.ImmutableSetSizedBuilderGenerator; import com.google.common.collect.testing.google.SetGenerators.ImmutableSetTooBigBuilderGenerator; import com.google.common.collect.testing.google.SetGenerators.ImmutableSetTooSmallBuilderGenerator; import com.google.common.collect.testing.google.SetGenerators.ImmutableSetUnsizedBuilderGenerator; import com.google.common.collect.testing.google.SetGenerators.ImmutableSetWithBadHashesGenerator; import com.google.common.testing.CollectorTester; import com.google.common.testing.EqualsTester; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Set; import java.util.function.BiPredicate; import java.util.stream.Collector; import junit.framework.Test; import junit.framework.TestSuite; /** * Unit test for {@link ImmutableSet}. * * @author Kevin Bourrillion * @author Jared Levy * @author Nick Kralevich */ @GwtCompatible(emulated = true) public class ImmutableSetTest extends AbstractImmutableSetTest { @GwtIncompatible // suite public static Test suite() { TestSuite suite = new TestSuite(); suite.addTest( SetTestSuiteBuilder.using(new ImmutableSetCopyOfGenerator()) .named(ImmutableSetTest.class.getName()) .withFeatures( CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTest( SetTestSuiteBuilder.using(new ImmutableSetUnsizedBuilderGenerator()) .named(ImmutableSetTest.class.getName() + ", with unsized builder") .withFeatures( CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTest( SetTestSuiteBuilder.using( new TestStringSetGenerator() { @Override protected Set create(String[] elements) { ImmutableSet.Builder builder = ImmutableSet.builder(); builder.forceJdk(); builder.add(elements); return builder.build(); } }) .named(ImmutableSetTest.class.getName() + ", with JDK builder") .withFeatures( CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTest( SetTestSuiteBuilder.using(new ImmutableSetSizedBuilderGenerator()) .named(ImmutableSetTest.class.getName() + ", with exactly sized builder") .withFeatures( CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTest( SetTestSuiteBuilder.using(new ImmutableSetTooBigBuilderGenerator()) .named(ImmutableSetTest.class.getName() + ", with oversized builder") .withFeatures( CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTest( SetTestSuiteBuilder.using(new ImmutableSetTooSmallBuilderGenerator()) .named(ImmutableSetTest.class.getName() + ", with undersized builder") .withFeatures( CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTest( SetTestSuiteBuilder.using(new ImmutableSetWithBadHashesGenerator()) .named(ImmutableSetTest.class.getName() + ", with bad hashes") .withFeatures( CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTest( SetTestSuiteBuilder.using(new DegeneratedImmutableSetGenerator()) .named(ImmutableSetTest.class.getName() + ", degenerate") .withFeatures( CollectionSize.ONE, CollectionFeature.KNOWN_ORDER, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTest( ListTestSuiteBuilder.using(new ImmutableSetAsListGenerator()) .named("ImmutableSet.asList") .withFeatures( CollectionSize.ANY, CollectionFeature.REJECTS_DUPLICATES_AT_CREATION, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES) .createTestSuite()); suite.addTestSuite(ImmutableSetTest.class); suite.addTestSuite(FloodingTest.class); return suite; } @Override protected > Set of() { return ImmutableSet.of(); } @Override protected > Set of(E e) { return ImmutableSet.of(e); } @Override protected > Set of(E e1, E e2) { return ImmutableSet.of(e1, e2); } @Override protected > Set of(E e1, E e2, E e3) { return ImmutableSet.of(e1, e2, e3); } @Override protected > Set of(E e1, E e2, E e3, E e4) { return ImmutableSet.of(e1, e2, e3, e4); } @Override protected > Set of(E e1, E e2, E e3, E e4, E e5) { return ImmutableSet.of(e1, e2, e3, e4, e5); } @SuppressWarnings("unchecked") @Override protected > Set of( E e1, E e2, E e3, E e4, E e5, E e6, E... rest) { return ImmutableSet.of(e1, e2, e3, e4, e5, e6, rest); } @Override protected > Set copyOf(E[] elements) { return ImmutableSet.copyOf(elements); } @Override protected > Set copyOf(Collection elements) { return ImmutableSet.copyOf(elements); } @Override protected > Set copyOf(Iterable elements) { return ImmutableSet.copyOf(elements); } @Override protected > Set copyOf(Iterator elements) { return ImmutableSet.copyOf(elements); } public void testCreation_allDuplicates() { ImmutableSet set = ImmutableSet.copyOf(Lists.newArrayList("a", "a")); assertTrue(set instanceof SingletonImmutableSet); assertEquals(Lists.newArrayList("a"), Lists.newArrayList(set)); } public void testCreation_oneDuplicate() { // now we'll get the varargs overload ImmutableSet set = ImmutableSet.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "a"); assertEquals( Lists.newArrayList("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"), Lists.newArrayList(set)); } public void testCreation_manyDuplicates() { // now we'll get the varargs overload ImmutableSet set = ImmutableSet.of("a", "b", "c", "c", "c", "c", "b", "b", "a", "a", "c", "c", "c", "a"); assertThat(set).containsExactly("a", "b", "c").inOrder(); } public void testCreation_arrayOfArray() { String[] array = new String[] {"a"}; Set set = ImmutableSet.of(array); assertEquals(Collections.singleton(array), set); } @GwtIncompatible // ImmutableSet.chooseTableSize public void testChooseTableSize() { assertEquals(8, ImmutableSet.chooseTableSize(3)); assertEquals(8, ImmutableSet.chooseTableSize(4)); assertEquals(1 << 29, ImmutableSet.chooseTableSize(1 << 28)); assertEquals(1 << 29, ImmutableSet.chooseTableSize((1 << 29) * 3 / 5)); // Now we hit the cap assertEquals(1 << 30, ImmutableSet.chooseTableSize(1 << 29)); assertEquals(1 << 30, ImmutableSet.chooseTableSize((1 << 30) - 1)); // Now we've gone too far try { ImmutableSet.chooseTableSize(1 << 30); fail(); } catch (IllegalArgumentException expected) { } } @GwtIncompatible // RegularImmutableSet.table not in emulation public void testResizeTable() { verifyTableSize(100, 2, 8); verifyTableSize(100, 5, 8); verifyTableSize(100, 33, 64); verifyTableSize(17, 17, 32); verifyTableSize(17, 16, 32); verifyTableSize(17, 15, 32); } @GwtIncompatible // RegularImmutableSet.table not in emulation private void verifyTableSize(int inputSize, int setSize, int tableSize) { Builder builder = ImmutableSet.builder(); for (int i = 0; i < inputSize; i++) { builder.add(i % setSize); } ImmutableSet set = builder.build(); assertTrue(set instanceof RegularImmutableSet); assertEquals( "Input size " + inputSize + " and set size " + setSize, tableSize, ((RegularImmutableSet) set).table.length); } public void testCopyOf_copiesImmutableSortedSet() { ImmutableSortedSet sortedSet = ImmutableSortedSet.of("a"); ImmutableSet copy = ImmutableSet.copyOf(sortedSet); assertNotSame(sortedSet, copy); } public void testToImmutableSet() { Collector> collector = ImmutableSet.toImmutableSet(); Equivalence> equivalence = Equivalence.equals().onResultOf(ImmutableSet::asList); CollectorTester.of(collector, equivalence) .expectCollects(ImmutableSet.of("a", "b", "c", "d"), "a", "b", "a", "c", "b", "b", "d"); } public void testToImmutableSet_duplicates() { class TypeWithDuplicates { final int a; final int b; TypeWithDuplicates(int a, int b) { this.a = a; this.b = b; } @Override public int hashCode() { return a; } @Override public boolean equals(Object obj) { return obj instanceof TypeWithDuplicates && ((TypeWithDuplicates) obj).a == a; } public boolean fullEquals(TypeWithDuplicates other) { return other != null && a == other.a && b == other.b; } } Collector> collector = ImmutableSet.toImmutableSet(); BiPredicate, ImmutableSet> equivalence = (set1, set2) -> { if (!set1.equals(set2)) { return false; } for (int i = 0; i < set1.size(); i++) { if (!set1.asList().get(i).fullEquals(set2.asList().get(i))) { return false; } } return true; }; TypeWithDuplicates a = new TypeWithDuplicates(1, 1); TypeWithDuplicates b1 = new TypeWithDuplicates(2, 1); TypeWithDuplicates b2 = new TypeWithDuplicates(2, 2); TypeWithDuplicates c = new TypeWithDuplicates(3, 1); CollectorTester.of(collector, equivalence) .expectCollects(ImmutableSet.of(a, b1, c), a, b1, c, b2); } @GwtIncompatible // GWT is single threaded public void testCopyOf_threadSafe() { verifyThreadSafe(); } @Override > Builder builder() { return ImmutableSet.builder(); } @Override int getComplexBuilderSetLastElement() { return LAST_COLOR_ADDED; } public void testEquals() { new EqualsTester() .addEqualityGroup(ImmutableSet.of(), ImmutableSet.of()) .addEqualityGroup(ImmutableSet.of(1), ImmutableSet.of(1), ImmutableSet.of(1, 1)) .addEqualityGroup(ImmutableSet.of(1, 2, 1), ImmutableSet.of(2, 1, 1)) .testEquals(); } /** * The maximum allowed probability of falsely detecting a hash flooding attack if the input is * randomly generated. */ private static final double HASH_FLOODING_FPP = 0.001; public void testReuseBuilderReducingHashTableSizeWithPowerOfTwoTotalElements() { ImmutableSet.Builder builder = ImmutableSet.builderWithExpectedSize(6); builder.add(0); ImmutableSet unused = builder.build(); ImmutableSet subject = builder.add(1).add(2).add(3).build(); assertFalse(subject.contains(4)); } public static class FloodingTest extends AbstractHashFloodingTest> { public FloodingTest() { super( Arrays.asList(ConstructionPathway.values()), n -> n * Math.log(n), ImmutableList.of( QueryOp.create( "contains", (s, o) -> { boolean unused = s.contains(o); }, Math::log))); } /** All the ways to construct an ImmutableSet. */ enum ConstructionPathway implements Construction> { OF { @Override public ImmutableSet create(List list) { Object o1 = list.get(0); Object o2 = list.get(1); Object o3 = list.get(2); Object o4 = list.get(3); Object o5 = list.get(4); Object o6 = list.get(5); Object[] rest = list.subList(6, list.size()).toArray(); return ImmutableSet.of(o1, o2, o3, o4, o5, o6, rest); } }, COPY_OF_ARRAY { @Override public ImmutableSet create(List list) { return ImmutableSet.copyOf(list.toArray()); } }, COPY_OF_LIST { @Override public ImmutableSet create(List list) { return ImmutableSet.copyOf(list); } }, BUILDER_ADD_ONE_BY_ONE { @Override public ImmutableSet create(List list) { ImmutableSet.Builder builder = ImmutableSet.builder(); for (Object o : list) { builder.add(o); } return builder.build(); } }, BUILDER_ADD_ARRAY { @Override public ImmutableSet create(List list) { ImmutableSet.Builder builder = ImmutableSet.builder(); builder.add(list.toArray()); return builder.build(); } }, BUILDER_ADD_LIST { @Override public ImmutableSet create(List list) { ImmutableSet.Builder builder = ImmutableSet.builder(); builder.addAll(list); return builder.build(); } }; } } }