@Generates private static <E extends Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet( E freshElement) { return ImmutableSortedSet.of(freshElement); }
public void testGetLast_emptySortedSet() { SortedSet<String> sortedSet = ImmutableSortedSet.of(); try { Iterables.getLast(sortedSet); fail(); } catch (NoSuchElementException e) { } }
@Override public Entry<String, Collection<String>> aboveSamplesGreater() { return Helpers.mapEntry( "~~ c", (Collection<String>) ImmutableSortedSet.of("~above")); } })
@Override public Entry<String, Collection<String>> belowSamplesLesser() { return Helpers.mapEntry( "-- a", (Collection<String>) ImmutableSortedSet.of("--below")); }
@Override public Entry<String, Collection<String>> aboveSamplesLesser() { return Helpers.mapEntry( "~~ b", (Collection<String>) ImmutableSortedSet.of("~above")); }
public void testCopyOf_copiesImmutableSortedSet() { ImmutableSortedSet<String> sortedSet = ImmutableSortedSet.of("a"); ImmutableSet<String> copy = ImmutableSet.copyOf(sortedSet); assertNotSame(sortedSet, copy); }
@Override public Entry<String, Collection<String>> belowSamplesGreater() { return Helpers.mapEntry( "-- b", (Collection<String>) ImmutableSortedSet.of("--below")); }
public void testAsList() { ImmutableSet<String> set = ImmutableSortedSet.of("a", "e", "i", "o", "u"); ImmutableList<String> list = set.asList(); assertEquals(ImmutableList.of("a", "e", "i", "o", "u"), list); assertSame(list, ImmutableList.copyOf(set)); }
@GwtIncompatible // NavigableMap public void testAsMapNavigableEmpty() { NavigableSet<String> strings = ImmutableSortedSet.of(); NavigableMap<String, Integer> map = Maps.asMap(strings, LENGTH_FUNCTION); assertThat(map.entrySet()).isEmpty(); assertTrue(map.isEmpty()); assertNull(map.get("five")); }
public void testSubsetAsList() { ImmutableSet<String> set = ImmutableSortedSet.of("a", "e", "i", "o", "u").subSet("c", "r"); ImmutableList<String> list = set.asList(); assertEquals(ImmutableList.of("e", "i", "o"), list); assertEquals(list, ImmutableList.copyOf(set)); }
public void testContainsAll() { Range<Integer> range = Range.closed(3, 5); assertTrue(range.containsAll(asList(3, 3, 4, 5))); assertFalse(range.containsAll(asList(3, 3, 4, 5, 6))); // We happen to know that natural-order sorted sets use a different code // path, so we test that separately assertTrue(range.containsAll(ImmutableSortedSet.of(3, 3, 4, 5))); assertTrue(range.containsAll(ImmutableSortedSet.of(3))); assertTrue(range.containsAll(ImmutableSortedSet.<Integer>of())); assertFalse(range.containsAll(ImmutableSortedSet.of(3, 3, 4, 5, 6))); assertTrue(Range.openClosed(3, 3).containsAll(Collections.<Integer>emptySet())); }
@GwtIncompatible // SerializableTester, ImmutableSortedAsList public void testAsListReturnTypeAndSerialization() { ImmutableSet<String> set = ImmutableSortedSet.of("a", "e", "i", "o", "u"); ImmutableList<String> list = set.asList(); assertTrue(list instanceof ImmutableSortedAsList); ImmutableList<String> copy = SerializableTester.reserializeAndAssert(list); assertTrue(copy instanceof ImmutableSortedAsList); }
public void testAsSet() { ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17); ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers()); assertEquals(expectedSet, asSet); assertThat(asSet).containsExactlyElementsIn(expectedSet).inOrder(); assertTrue(asSet.containsAll(expectedSet)); SerializableTester.reserializeAndAssert(asSet); }
@GwtIncompatible // SerializableTester, ImmutableSortedAsList public void testSubsetAsListReturnTypeAndSerialization() { ImmutableSet<String> set = ImmutableSortedSet.of("a", "e", "i", "o", "u").subSet("c", "r"); ImmutableList<String> list = set.asList(); assertTrue(list instanceof ImmutableSortedAsList); ImmutableList<String> copy = SerializableTester.reserializeAndAssert(list); assertTrue(copy instanceof ImmutableSortedAsList); }
public void testToImmutableSortedSet() { Collector<String, ?, ImmutableSortedSet<String>> collector = ImmutableSortedSet.toImmutableSortedSet(Ordering.natural()); BiPredicate<ImmutableSortedSet<String>, ImmutableSortedSet<String>> equivalence = Equivalence.equals() .onResultOf(ImmutableSortedSet<String>::comparator) .and(Equivalence.equals().onResultOf(ImmutableSortedSet::asList)) .and(Equivalence.equals()); CollectorTester.of(collector, equivalence) .expectCollects( ImmutableSortedSet.of("a", "b", "c", "d"), "a", "b", "a", "c", "b", "b", "d"); }
public void testAsSetHeadSet() { ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17); ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers()); for (int i = 0; i <= 20; i++) { assertEquals(asSet.headSet(i, false), expectedSet.headSet(i, false)); assertEquals(asSet.headSet(i, true), expectedSet.headSet(i, true)); } }
public void testAsSetTailSet() { ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17); ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers()); for (int i = 0; i <= 20; i++) { assertEquals(asSet.tailSet(i, false), expectedSet.tailSet(i, false)); assertEquals(asSet.tailSet(i, true), expectedSet.tailSet(i, true)); } }
public void testAsSetSubSet() { ImmutableSortedSet<Integer> expectedSet = ImmutableSortedSet.of(2, 3, 4, 8, 9, 16, 17); ImmutableSortedSet<Integer> asSet = RANGE_SET_ONE.asSet(DiscreteDomain.integers()); for (int i = 0; i <= 20; i++) { for (int j = i + 1; j <= 20; j++) { assertEquals(expectedSet.subSet(i, false, j, false), asSet.subSet(i, false, j, false)); assertEquals(expectedSet.subSet(i, true, j, false), asSet.subSet(i, true, j, false)); assertEquals(expectedSet.subSet(i, false, j, true), asSet.subSet(i, false, j, true)); assertEquals(expectedSet.subSet(i, true, j, true), asSet.subSet(i, true, j, true)); } } }