/** Calls the smallest subSet overload that filters out the extreme values. */ SortedSet<E> createSubSet(SortedSet<E> set, E firstExclusive, E lastExclusive) { if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) { return set.headSet(lastExclusive); } else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) { return set.tailSet(firstInclusive); } else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) { return set.subSet(firstInclusive, lastExclusive); } else { throw new IllegalArgumentException(); } }
@Override public SortedSet<E> subSet(E fromElement, E toElement) { return new FilteredSortedSet<E>( ((SortedSet<E>) unfiltered).subSet(fromElement, toElement), predicate); }
@Override public SortedSet<E> subSet(E fromElement, E toElement) { synchronized (mutex) { return sortedSet(delegate().subSet(fromElement, toElement), mutex); } }
@Override public SortedSet<E> subSet(E fromElement, E toElement) { return delegate().subSet(fromElement, toElement); }
@Override public SortedSet<E> subSet(E fromElement, E toElement) { synchronized (mutex) { return sortedSet(delegate().subSet(fromElement, toElement), mutex); } }
@Override public SortedMap<K, V> subMap(K fromKey, K toKey) { return asMap(backingSet().subSet(fromKey, toKey), function); }
public void testSingle_subSet() { SortedSet<String> set = of("e"); assertTrue(set.subSet("c", "g") instanceof ImmutableSortedSet); assertThat(set.subSet("c", "g")).contains("e"); assertThat(set.subSet("e", "g")).contains("e"); assertSame(of(), set.subSet("f", "g")); assertSame(of(), set.subSet("c", "e")); assertSame(of(), set.subSet("c", "d")); }
public void testOf_subSet() { SortedSet<String> set = of("e", "f", "b", "d", "c"); assertTrue(set.subSet("c", "e") instanceof ImmutableSortedSet); assertThat(set.subSet("c", "e")).containsExactly("c", "d").inOrder(); assertThat(set.subSet("a", "g")).containsExactly("b", "c", "d", "e", "f").inOrder(); assertSame(of(), set.subSet("a", "b")); assertSame(of(), set.subSet("g", "h")); assertSame(of(), set.subSet("c", "c")); try { set.subSet("e", "c"); fail(); } catch (IllegalArgumentException expected) { } }
public void testExplicit_subSet() { SortedSet<String> set = ImmutableSortedSet.orderedBy(STRING_LENGTH) .add("in", "the", "quick", "jumped", "over", "a") .build(); assertTrue(set.subSet("the", "quick") instanceof ImmutableSortedSet); assertTrue(set.subSet("", "b") instanceof ImmutableSortedSet); assertThat(set.subSet("the", "quick")).containsExactly("the", "over").inOrder(); assertThat(set.subSet("a", "california")) .containsExactly("a", "in", "the", "over", "quick", "jumped") .inOrder(); assertTrue(set.subSet("", "b").isEmpty()); assertTrue(set.subSet("vermont", "california").isEmpty()); assertTrue(set.subSet("aaa", "zzz").isEmpty()); try { set.subSet("quick", "the"); fail(); } catch (IllegalArgumentException expected) { } }
public void testEmpty_subSet() { SortedSet<String> set = of(); assertSame(set, set.subSet("c", "f")); }
public void testSortedKeySet() { TreeMultimap<String, Integer> multimap = createPopulate(); SortedSet<String> keySet = multimap.keySet(); assertEquals(null, keySet.first()); assertEquals("google", keySet.last()); assertEquals(StringLength.COMPARATOR, keySet.comparator()); assertEquals(Sets.newHashSet(null, "tree"), keySet.headSet("yahoo")); assertEquals(Sets.newHashSet("google"), keySet.tailSet("yahoo")); assertEquals(Sets.newHashSet("tree"), keySet.subSet("ask", "yahoo")); }
@SuppressWarnings("unchecked") public void testSubSet() { for (List<Integer> contents : SAMPLE_INPUTS) { for (int i = 0; i < 10; i++) { for (int j = i; j < 10; j++) { assertEquals( filter((C) createUnfiltered(contents).subSet(i, j), EVEN), filter(createUnfiltered(contents), EVEN).subSet(i, j)); } } } } }
public void testRowKeySetSubSet() { sortedTable = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c', "dog", 2, 'd'); Set<String> set = sortedTable.rowKeySet().subSet("cat", "egg"); assertEquals(Collections.singleton("dog"), set); set.clear(); assertTrue(set.isEmpty()); assertEquals(ImmutableSet.of("bar", "foo"), sortedTable.rowKeySet()); }
public void testCopyOf_subSet() { SortedSet<String> set = of("e", "a", "f", "b", "d", "c"); SortedSet<String> subset = set.subSet("c", "e"); SortedSet<String> copy = copyOf(subset); assertEquals(subset, copy); }
@GwtIncompatible // SerializableTester public void testOf_subSetSerialization() { SortedSet<String> set = of("e", "f", "b", "d", "c"); SerializableTester.reserializeAndAssert(set.subSet("c", "e")); }
public void testElementSetSortedSetMethods() { TreeMultiset<String> ms = TreeMultiset.create(); ms.add("c", 1); ms.add("a", 3); ms.add("b", 2); SortedSet<String> elementSet = ms.elementSet(); assertEquals("a", elementSet.first()); assertEquals("c", elementSet.last()); assertEquals(Ordering.natural(), elementSet.comparator()); assertThat(elementSet.headSet("b")).containsExactly("a"); assertThat(elementSet.tailSet("b")).containsExactly("b", "c").inOrder(); assertThat(elementSet.subSet("a", "c")).containsExactly("a", "b").inOrder(); }
public void testElementSetSubsetClear() { TreeMultiset<String> ms = TreeMultiset.create(); ms.add("a", 1); ms.add("b", 3); ms.add("c", 2); ms.add("d", 1); ms.add("e", 3); ms.add("f", 2); SortedSet<String> elementSet = ms.elementSet(); assertThat(elementSet).containsExactly("a", "b", "c", "d", "e", "f").inOrder(); SortedSet<String> subset = elementSet.subSet("b", "f"); assertThat(subset).containsExactly("b", "c", "d", "e").inOrder(); subset.clear(); assertThat(elementSet).containsExactly("a", "f").inOrder(); assertThat(subset).isEmpty(); assertEquals(3, ms.size()); }
public void testElementSetSubsetRetainAll() { TreeMultiset<String> ms = TreeMultiset.create(); ms.add("a", 1); ms.add("b", 3); ms.add("c", 2); ms.add("d", 1); ms.add("e", 3); ms.add("f", 2); SortedSet<String> elementSet = ms.elementSet(); assertThat(elementSet).containsExactly("a", "b", "c", "d", "e", "f").inOrder(); SortedSet<String> subset = elementSet.subSet("b", "f"); assertThat(subset).containsExactly("b", "c", "d", "e").inOrder(); assertTrue(subset.retainAll(Arrays.asList("a", "c"))); assertThat(elementSet).containsExactly("a", "c", "f").inOrder(); assertThat(subset).containsExactly("c"); assertEquals(5, ms.size()); }
public void testElementSetSubsetRemoveAll() { TreeMultiset<String> ms = TreeMultiset.create(); ms.add("a", 1); ms.add("b", 3); ms.add("c", 2); ms.add("d", 1); ms.add("e", 3); ms.add("f", 2); SortedSet<String> elementSet = ms.elementSet(); assertThat(elementSet).containsExactly("a", "b", "c", "d", "e", "f").inOrder(); SortedSet<String> subset = elementSet.subSet("b", "f"); assertThat(subset).containsExactly("b", "c", "d", "e").inOrder(); assertTrue(subset.removeAll(Arrays.asList("a", "c"))); assertThat(elementSet).containsExactly("a", "b", "d", "e", "f").inOrder(); assertThat(subset).containsExactly("b", "d", "e").inOrder(); assertEquals(10, ms.size()); }
public void testElementSetSubsetRemove() { TreeMultiset<String> ms = TreeMultiset.create(); ms.add("a", 1); ms.add("b", 3); ms.add("c", 2); ms.add("d", 1); ms.add("e", 3); ms.add("f", 2); SortedSet<String> elementSet = ms.elementSet(); assertThat(elementSet).containsExactly("a", "b", "c", "d", "e", "f").inOrder(); SortedSet<String> subset = elementSet.subSet("b", "f"); assertThat(subset).containsExactly("b", "c", "d", "e").inOrder(); assertTrue(subset.remove("c")); assertThat(elementSet).containsExactly("a", "b", "d", "e", "f").inOrder(); assertThat(subset).containsExactly("b", "d", "e").inOrder(); assertEquals(10, ms.size()); assertFalse(subset.remove("a")); assertThat(elementSet).containsExactly("a", "b", "d", "e", "f").inOrder(); assertThat(subset).containsExactly("b", "d", "e").inOrder(); assertEquals(10, ms.size()); }