@Override <E extends Comparable<E>> ImmutableSortedSet.Builder<E> builder() { return ImmutableSortedSet.naturalOrder(); }
@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(); } }
@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); } }
private void testImmutableXXX() { assertEquals(5, ImmutableList.of(1, 2, 3, 4, 5).size()); assertEquals(5, ImmutableSet.of(1, 2, 3, 4, 5).size()); assertEquals(5, ImmutableSortedSet.of(1, 2, 3, 4, 5).size()); assertEquals(3, ImmutableMap.of(1, 2, 3, 4, 5, 6).size()); assertEquals(3, ImmutableSortedMap.of(1, 2, 3, 4, 5, 6).size()); assertEquals(9, ImmutableMultiset.of(1, 1, 2, 2, 3, 3, 4, 5, 6).size()); assertEquals(6, ImmutableMultiset.of(1, 1, 2, 2, 3, 3, 4, 5, 6).elementSet().size()); assertEquals(2, ImmutableMultiset.of(1, 1, 2, 2, 3, 3, 4, 5, 6).count(1)); } }
final void check() { runTester() .assertNonNullValues( Gender.MALE, Integer.valueOf(0), 0, "", "", ImmutableList.of(), ImmutableList.of(), ImmutableMap.of(), ImmutableMap.of(), ImmutableSet.of(), ImmutableSet.of(), ImmutableSortedSet.of(), ImmutableSortedSet.of(), ImmutableMultiset.of(), ImmutableMultiset.of(), ImmutableMultimap.of(), ImmutableMultimap.of(), ImmutableTable.of(), ImmutableTable.of()); } }
ContiguousSet.create(Range.openClosed(0, 3), NOT_EQUAL_TO_INTEGERS), ContiguousSet.create(Range.open(0, 4), NOT_EQUAL_TO_INTEGERS), ImmutableSortedSet.of(1, 2, 3)) .addEqualityGroup( ContiguousSet.create(Range.closedOpen(1, 1), integers()), ContiguousSet.closedOpen(1, 1), ContiguousSet.closedOpen(Integer.MIN_VALUE, Integer.MIN_VALUE), ImmutableSortedSet.of(), ImmutableSet.of()) .testEquals();
/** * Returns an immutable sorted set containing the given elements sorted by their natural ordering. * When multiple elements are equivalent according to {@code compareTo()}, only the first one * specified is included. * * <p>This method is not type-safe, as it may be called on elements that are not mutually * comparable. * * @throws ClassCastException if the elements are not mutually comparable * @throws NullPointerException if any of {@code elements} is null */ public static <E> ImmutableSortedSet<E> copyOf(Iterator<? extends E> elements) { // Hack around E not being a subtype of Comparable. // Unsafe, see ImmutableSortedSetFauxverideShim. @SuppressWarnings("unchecked") Ordering<E> naturalOrder = (Ordering<E>) Ordering.<Comparable>natural(); return copyOf(naturalOrder, elements); }
ImmutableSortedSet.toImmutableSortedSet(Ordering.natural()); BiPredicate<ImmutableSortedSet<TypeWithDuplicates>, ImmutableSortedSet<TypeWithDuplicates>> 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; TypeWithDuplicates c = new TypeWithDuplicates(3, 1); CollectorTester.of(collector, equivalence) .expectCollects(ImmutableSortedSet.of(a, b1, c), a, b1, c, b2);
static SortedSet<NamedColumnDescription> namedColumns(TableMetadata table) { return ImmutableSortedSet.copyOf( Ordering.natural().onResultOf(col -> col.getLongName()), table.getColumns().getNamedColumns()); } }
String rawTableName = entry.getKey(); TableDefinition table = entry.getValue(); ImmutableSortedSet.Builder<IndexMetadata> indices = ImmutableSortedSet.orderedBy( Ordering.natural().onResultOf((Function<IndexMetadata, String>) IndexMetadata::getIndexName)); if (table.getGenericTableName() != null) { Preconditions.checkState(!indexesByTable.containsKey(rawTableName), } else { for (String indexName : indexesByTable.get(rawTableName)) { indices.add(indexDefinitions.get(indexName).toIndexMetadata(indexName)); tableRenderer.render(rawTableName, table, indices.build()), packageName, tableRenderer.getClassName(rawTableName, table));
public void testSubSetExclusiveExclusive() { String[] strings = NUMBER_NAMES.toArray(new String[0]); ImmutableSortedSet<String> set = ImmutableSortedSet.copyOf(strings); Arrays.sort(strings); for (int i = 0; i < strings.length; i++) { for (int j = i; j < strings.length; j++) { assertThat(set.subSet(strings[i], false, strings[j], false)) .containsExactlyElementsIn(sortedNumberNames(Math.min(i + 1, j), j)) .inOrder(); } } }
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"); }
ImmutableSortedSet.Builder<Import> imports = ImmutableSortedSet.naturalOrder(); while (i < toks.size() && tokenAt(i).equals("import")) { i++; if (isSpaceToken(i)) { i++; imports.add(new Import(importedName, trailing.toString(), isStatic)); return new ImportsAndIndex(imports.build(), afterLastImport);
public void testTailSetInclusive() { String[] strings = NUMBER_NAMES.toArray(new String[0]); ImmutableSortedSet<String> set = ImmutableSortedSet.copyOf(strings); Arrays.sort(strings); for (int i = 0; i < strings.length; i++) { assertThat(set.tailSet(strings[i], true)) .containsExactlyElementsIn(sortedNumberNames(i, strings.length)) .inOrder(); } }