@Override protected SortedSet<String> create(String[] elements) { return ImmutableSortedSet.<String>reverseOrder() .addAll(Arrays.asList(elements).iterator()) .build(); }
public void testExplicit_contains() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "jumped", "over", "a") .build(); assertTrue(set.contains("quick")); assertTrue(set.contains("google")); assertFalse(set.contains("")); assertFalse(set.contains("california")); assertFalse(set.contains(null)); }
@GwtIncompatible // SerializableTester public void testExplicitEmpty_serialization() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH).build(); SortedSet<String> copy = SerializableTester.reserializeAndAssert(set); assertTrue(set.isEmpty()); assertTrue(copy.isEmpty()); assertSame(set.comparator(), copy.comparator()); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(elements); builder.add(AFTER_LAST); return builder.build().subSet(BEFORE_FIRST_2, AFTER_LAST).asList(); } }
public void testLegacyComparable_builder_natural() { @SuppressWarnings("unchecked") // Note: IntelliJ wrongly reports an error for this statement ImmutableSortedSet.Builder<LegacyComparable> builder = ImmutableSortedSet.<LegacyComparable>naturalOrder(); builder.addAll(LegacyComparable.VALUES_BACKWARD); builder.add(LegacyComparable.X); builder.add(LegacyComparable.Y, LegacyComparable.Z); ImmutableSortedSet<LegacyComparable> set = builder.build(); assertTrue(Iterables.elementsEqual(LegacyComparable.VALUES_FORWARD, set)); }
public void testSupertypeComparatorSubtypeElements() { SortedSet<Number> set = new ImmutableSortedSet.Builder<Number>(TO_STRING).add(3, 12, 101, 44).build(); assertThat(set).containsExactly(101, 12, 3, 44).inOrder(); }
@SuppressWarnings("CollectionIncompatibleType") // testing incompatible types public void testExplicit_containsMismatchedTypes() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "jumped", "over", "a") .build(); assertFalse(set.contains(3.7)); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(elements); builder.add(AFTER_LAST); return builder.build().asList().subList(1, elements.length + 1); } }
@GwtIncompatible // SerializableTester public void testExplicit_serialization() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "jumped", "over", "a") .build(); SortedSet<String> copy = SerializableTester.reserializeAndAssert(set); assertTrue(Iterables.elementsEqual(set, copy)); assertSame(set.comparator(), copy.comparator()); }
public void testExplicit_last() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "jumped", "over", "a") .build(); assertEquals("jumped", set.last()); }
public void testExplicit_first() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "jumped", "over", "a") .build(); assertEquals("a", set.first()); }
public void testExplicit_comparator() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "jumped", "over", "a") .build(); assertSame(STRING_LENGTH, set.comparator()); }
public void testExplicit_ordering() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "jumped", "over", "a") .build(); assertThat(set).containsExactly("a", "in", "the", "over", "quick", "jumped").inOrder(); }
public void testLegacyComparable_builder_reverse() { @SuppressWarnings("unchecked") // Note: IntelliJ wrongly reports an error for this statement ImmutableSortedSet.Builder<LegacyComparable> builder = ImmutableSortedSet.<LegacyComparable>reverseOrder(); builder.addAll(LegacyComparable.VALUES_FORWARD); builder.add(LegacyComparable.X); builder.add(LegacyComparable.Y, LegacyComparable.Z); ImmutableSortedSet<LegacyComparable> set = builder.build(); assertTrue(Iterables.elementsEqual(LegacyComparable.VALUES_BACKWARD, set)); }
public void testSupertypeComparator() { SortedSet<Integer> set = new ImmutableSortedSet.Builder<Integer>(TO_STRING).add(3, 12, 101, 44).build(); assertThat(set).containsExactly(101, 12, 3, 44).inOrder(); }
public void testExplicit_ordering_dupes() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "brown", "fox", "jumped", "over", "a", "lazy", "dog") .build(); assertThat(set).containsExactly("a", "in", "the", "over", "quick", "jumped").inOrder(); }
/** * Returns an immutable sorted set containing the given elements sorted by the given {@code * Comparator}. When multiple elements are equivalent according to {@code compareTo()}, only the * first one specified is included. * * @throws NullPointerException if {@code comparator} or any of {@code elements} is null */ public static <E> ImmutableSortedSet<E> copyOf( Comparator<? super E> comparator, Iterator<? extends E> elements) { return new Builder<E>(comparator).addAll(elements).build(); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements).reverse(); return ImmutableSortedSet.orderedBy(comparator) .add(elements) .build() .descendingSet() .asList(); } }
@Override protected SortedSet<String> create(String[] elements) { return ImmutableSortedSet.<String>reverseOrder().add(elements).build().descendingSet(); } }
@GwtIncompatible // SerializableTester public void testDifferentComparator_serialization() { // don't use Collections.reverseOrder(); it didn't reserialize to the same instance in JDK5 Comparator<Comparable<?>> comparator = Ordering.natural().reverse(); SortedSet<String> set = new ImmutableSortedSet.Builder<String>(comparator).add("a", "b", "c").build(); SortedSet<String> copy = SerializableTester.reserializeAndAssert(set); assertTrue(Iterables.elementsEqual(set, copy)); assertEquals(set.comparator(), copy.comparator()); }