target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void test_with() { ConstSortedSet<Integer> set; set = new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}); compare_sorted_sets(newSortedSet(null, 1, 2, 3, 4, 5, 6, 7), set.with(7)); compare_sorted_sets(newSortedSet(null, 0, 1, 2, 3, 4, 5, 6), set.with(0)); compare_sorted_sets(newSortedSet(null, 1, 2, 3, 4, 5, 6, 7, 8), set.with(8).with(7)); assertSame(set, set.with(6)); set = new BasicSortedSetN<>(reverseOrder(), new Object[] {6, 5, 4, 3, 2, 1}); compare_sorted_sets(newSortedSet(reverseOrder(), 7, 6, 5, 4, 3, 2, 1), set.with(7)); compare_sorted_sets(newSortedSet(reverseOrder(), 6, 5, 4, 3, 2, 1, 0), set.with(0)); compare_sorted_sets(newSortedSet(reverseOrder(), 8, 7, 6, 5, 4, 3, 2, 1), set.with(8).with(7)); assertSame(set, set.with(6)); } | @Override public ConstSortedSet<E> with(E e) { int index = indexOf(e); return index >= 0 ? this : new BasicSortedSetN<>(comparator, insert(elements, flip(index), e)); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> with(E e) { int index = indexOf(e); return index >= 0 ? this : new BasicSortedSetN<>(comparator, insert(elements, flip(index), e)); } } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> with(E e) { int index = indexOf(e); return index >= 0 ? this : new BasicSortedSetN<>(comparator, insert(elements, flip(index), e)); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> with(E e) { int index = indexOf(e); return index >= 0 ? this : new BasicSortedSetN<>(comparator, insert(elements, flip(index), e)); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> with(E e) { int index = indexOf(e); return index >= 0 ? this : new BasicSortedSetN<>(comparator, insert(elements, flip(index), e)); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } |
@Test public void test_withAll() { ConstSortedSet<Integer> set; set = new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 7}); compare_sorted_sets( newSortedSet(null, 0, 1, 2, 3, 4, 5, 6, 7, 8), set.withAll(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1, 0))); assertSame(set, set.withAll(Arrays.asList(1, 1, 1, 2, 2, 3, 3))); assertSame(set, set.withAll(Collections.<Integer>emptyList())); set = new BasicSortedSetN<>(reverseOrder(), new Object[] {7, 5, 4, 3, 2, 1}); compare_sorted_sets( newSortedSet(reverseOrder(), 8, 7, 6, 5, 4, 3, 2, 1, 0), set.withAll(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1, 0))); assertSame(set, set.withAll(Arrays.asList(1, 1, 1, 2, 2, 3, 3))); assertSame(set, set.withAll(Collections.<Integer>emptyList())); } | @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } |
@Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}).withAll(null); } | @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } |
@Test public void test_without() { ConstSortedSet<Integer> set; set = new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}); compare_sorted_sets(newSortedSet(null, 2, 3, 4, 5, 6), set.without(1)); compare_sorted_sets(newSortedSet(null, 1, 3, 4, 5, 6), set.without(2)); compare_sorted_sets(newSortedSet(null, 1, 2, 3, 4, 5), set.without(6)); assertSame(set, set.without(-1)); assertSame(set, set.without(7)); set = new BasicSortedSetN<>(reverseOrder(), new Object[] {6, 5, 4, 3, 2, 1}); compare_sorted_sets(newSortedSet(reverseOrder(), 6, 5, 4, 3, 2), set.without(1)); compare_sorted_sets(newSortedSet(reverseOrder(), 6, 5, 4, 3, 1), set.without(2)); compare_sorted_sets(newSortedSet(reverseOrder(), 5, 4, 3, 2, 1), set.without(6)); assertSame(set, set.without(-1)); assertSame(set, set.without(7)); } | @Override public ConstSortedSet<E> without(Object o) { int index = indexOf(o); return index < 0 ? this : condenseToSortedSet(comparator, delete(elements, index)); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> without(Object o) { int index = indexOf(o); return index < 0 ? this : condenseToSortedSet(comparator, delete(elements, index)); } } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> without(Object o) { int index = indexOf(o); return index < 0 ? this : condenseToSortedSet(comparator, delete(elements, index)); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> without(Object o) { int index = indexOf(o); return index < 0 ? this : condenseToSortedSet(comparator, delete(elements, index)); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> without(Object o) { int index = indexOf(o); return index < 0 ? this : condenseToSortedSet(comparator, delete(elements, index)); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } |
@Test public void test_withoutAll() { ConstSortedSet<Integer> set; set = new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}); compare_sorted_sets(newSortedSet(null, 2, 4, 5), set.withoutAll(Arrays.asList(1, 3, 6))); compare_sorted_sets(newSortedSet(null, 2, 4, 5), set.withoutAll(Arrays.asList(1, 3, 9, -1, 6))); assertSame(set, set.withoutAll(Arrays.asList(7))); assertSame(set, set.withoutAll(Arrays.asList())); assertEquals(BasicSortedSet0.<Integer>instance(null), set.withoutAll(set)); set = new BasicSortedSetN<>(reverseOrder(), new Object[] {6, 5, 4, 3, 2, 1}); compare_sorted_sets(newSortedSet(reverseOrder(), 5, 4, 2), set.withoutAll(Arrays.asList(1, 3, 6))); compare_sorted_sets(newSortedSet(reverseOrder(), 5, 4, 2), set.withoutAll(Arrays.asList(1, 3, 9, -1, 6))); assertSame(set, set.withoutAll(Arrays.asList(7))); assertSame(set, set.withoutAll(Arrays.asList())); assertEquals(BasicSortedSet0.<Integer>instance(reverseOrder()), set.withoutAll(set)); } | @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } |
@Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}).withoutAll(null); } | @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get() { new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}).get(7); } | @Override E get(int index) { return elements[index]; } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override E get(int index) { return elements[index]; } } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override E get(int index) { return elements[index]; } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override E get(int index) { return elements[index]; } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } | BasicSortedSetN extends BasicConstSortedSet<E> { @Override E get(int index) { return elements[index]; } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); } |
@Test public void test_with() { ConstSet<Integer> set; set = new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}); compare_sets(newSet(1, 2, 3, 4, 5, 6, 7), set.with(7)); compare_sets(newSet(1, 2, 3, 4, 5, 6, null), set.with(null)); assertSame(set, set.with(6)); set = new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, null}); assertSame(set, set.with(null)); } | @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(insert(elements, elements.length, e)); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(insert(elements, elements.length, e)); } } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(insert(elements, elements.length, e)); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(insert(elements, elements.length, e)); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(insert(elements, elements.length, e)); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test public void test_withAll() { ConstSet<Integer> set = new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}); compare_sets(newSet(1, 2, 3, 4, 5, 6, 7), set.withAll(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1))); assertSame(set, set.withAll(Arrays.asList(1, 1, 1, 2, 2, 2, 3, 3))); assertSame(set, set.withAll(Collections.<Integer>emptyList())); } | @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}).withAll(null); } | @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray()); return expanded.length == size() ? this : new BasicSetN<E>(expanded); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test public void test_schema_types() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); Map<String, Type> schemaTypes = table.schemaTypes(Foo.class); assertSame(Foo.class, schemaTypes.get("targetSchema")); assertEquals("interface com.test.FooGrain", schemaTypes.get("targetGrain").toString()); assertEquals("interface com.test.FooBuilder", schemaTypes.get("targetBuilder").toString()); assertEquals("class com.test.FooFactory", schemaTypes.get("targetFactory").toString()); assertEquals("class com.test.FooFactory$FooGrainImpl", schemaTypes.get("targetGrainImpl").toString()); assertEquals("class com.test.FooFactory$FooGrainProxy", schemaTypes.get("targetGrainProxy").toString()); assertEquals("class com.test.FooFactory$FooBuilderImpl", schemaTypes.get("targetBuilderImpl").toString()); } | synchronized Map<String, Type> schemaTypes(Class<?> schema) { Map<String, Type> map = new HashMap<>(); Map<Name, String> names = namingPolicy.getNames(schema); Map<Name, String> simpleNames = namingPolicy.getSimpleNames(schema); Class<?> targetGrain = getGrainClass(schema); Class<?> targetBuilder = getGrainBuilderClass(schema); map.put("targetSchema", schema); map.put("targetGrain", targetGrain); map.put("targetBuilder", targetBuilder); ClassHandle targetFactory = loadOrCreateClass(names.get(Name.factory), Enum.class); ClassHandle targetGrainImpl = loadOrCreateNested(names.get(Name.grainImpl), simpleNames.get(Name.grainImpl), targetFactory); ClassHandle targetGrainProxy = loadOrCreateNested(names.get(Name.grainProxy), simpleNames.get(Name.grainProxy), targetFactory); ClassHandle targetBuilderImpl = loadOrCreateNested(names.get(Name.builderImpl), simpleNames.get(Name.builderImpl), targetFactory); map.put("targetFactory", targetFactory.toClass()); map.put("targetGrainImpl", targetGrainImpl.toClass()); map.put("targetGrainProxy", targetGrainProxy.toClass()); map.put("targetBuilderImpl", targetBuilderImpl.toClass()); return map; } | TypeTable { synchronized Map<String, Type> schemaTypes(Class<?> schema) { Map<String, Type> map = new HashMap<>(); Map<Name, String> names = namingPolicy.getNames(schema); Map<Name, String> simpleNames = namingPolicy.getSimpleNames(schema); Class<?> targetGrain = getGrainClass(schema); Class<?> targetBuilder = getGrainBuilderClass(schema); map.put("targetSchema", schema); map.put("targetGrain", targetGrain); map.put("targetBuilder", targetBuilder); ClassHandle targetFactory = loadOrCreateClass(names.get(Name.factory), Enum.class); ClassHandle targetGrainImpl = loadOrCreateNested(names.get(Name.grainImpl), simpleNames.get(Name.grainImpl), targetFactory); ClassHandle targetGrainProxy = loadOrCreateNested(names.get(Name.grainProxy), simpleNames.get(Name.grainProxy), targetFactory); ClassHandle targetBuilderImpl = loadOrCreateNested(names.get(Name.builderImpl), simpleNames.get(Name.builderImpl), targetFactory); map.put("targetFactory", targetFactory.toClass()); map.put("targetGrainImpl", targetGrainImpl.toClass()); map.put("targetGrainProxy", targetGrainProxy.toClass()); map.put("targetBuilderImpl", targetBuilderImpl.toClass()); return map; } } | TypeTable { synchronized Map<String, Type> schemaTypes(Class<?> schema) { Map<String, Type> map = new HashMap<>(); Map<Name, String> names = namingPolicy.getNames(schema); Map<Name, String> simpleNames = namingPolicy.getSimpleNames(schema); Class<?> targetGrain = getGrainClass(schema); Class<?> targetBuilder = getGrainBuilderClass(schema); map.put("targetSchema", schema); map.put("targetGrain", targetGrain); map.put("targetBuilder", targetBuilder); ClassHandle targetFactory = loadOrCreateClass(names.get(Name.factory), Enum.class); ClassHandle targetGrainImpl = loadOrCreateNested(names.get(Name.grainImpl), simpleNames.get(Name.grainImpl), targetFactory); ClassHandle targetGrainProxy = loadOrCreateNested(names.get(Name.grainProxy), simpleNames.get(Name.grainProxy), targetFactory); ClassHandle targetBuilderImpl = loadOrCreateNested(names.get(Name.builderImpl), simpleNames.get(Name.builderImpl), targetFactory); map.put("targetFactory", targetFactory.toClass()); map.put("targetGrainImpl", targetGrainImpl.toClass()); map.put("targetGrainProxy", targetGrainProxy.toClass()); map.put("targetBuilderImpl", targetBuilderImpl.toClass()); return map; } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { synchronized Map<String, Type> schemaTypes(Class<?> schema) { Map<String, Type> map = new HashMap<>(); Map<Name, String> names = namingPolicy.getNames(schema); Map<Name, String> simpleNames = namingPolicy.getSimpleNames(schema); Class<?> targetGrain = getGrainClass(schema); Class<?> targetBuilder = getGrainBuilderClass(schema); map.put("targetSchema", schema); map.put("targetGrain", targetGrain); map.put("targetBuilder", targetBuilder); ClassHandle targetFactory = loadOrCreateClass(names.get(Name.factory), Enum.class); ClassHandle targetGrainImpl = loadOrCreateNested(names.get(Name.grainImpl), simpleNames.get(Name.grainImpl), targetFactory); ClassHandle targetGrainProxy = loadOrCreateNested(names.get(Name.grainProxy), simpleNames.get(Name.grainProxy), targetFactory); ClassHandle targetBuilderImpl = loadOrCreateNested(names.get(Name.builderImpl), simpleNames.get(Name.builderImpl), targetFactory); map.put("targetFactory", targetFactory.toClass()); map.put("targetGrainImpl", targetGrainImpl.toClass()); map.put("targetGrainProxy", targetGrainProxy.toClass()); map.put("targetBuilderImpl", targetBuilderImpl.toClass()); return map; } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { synchronized Map<String, Type> schemaTypes(Class<?> schema) { Map<String, Type> map = new HashMap<>(); Map<Name, String> names = namingPolicy.getNames(schema); Map<Name, String> simpleNames = namingPolicy.getSimpleNames(schema); Class<?> targetGrain = getGrainClass(schema); Class<?> targetBuilder = getGrainBuilderClass(schema); map.put("targetSchema", schema); map.put("targetGrain", targetGrain); map.put("targetBuilder", targetBuilder); ClassHandle targetFactory = loadOrCreateClass(names.get(Name.factory), Enum.class); ClassHandle targetGrainImpl = loadOrCreateNested(names.get(Name.grainImpl), simpleNames.get(Name.grainImpl), targetFactory); ClassHandle targetGrainProxy = loadOrCreateNested(names.get(Name.grainProxy), simpleNames.get(Name.grainProxy), targetFactory); ClassHandle targetBuilderImpl = loadOrCreateNested(names.get(Name.builderImpl), simpleNames.get(Name.builderImpl), targetFactory); map.put("targetFactory", targetFactory.toClass()); map.put("targetGrainImpl", targetGrainImpl.toClass()); map.put("targetGrainProxy", targetGrainProxy.toClass()); map.put("targetBuilderImpl", targetBuilderImpl.toClass()); return map; } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } |
@Test public void test_without() { ConstSet<Integer> set = new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}); compare_sets(newSet(2, 3, 4, 5, 6), set.without(1)); compare_sets(newSet(1, 3, 4, 5, 6), set.without(2)); compare_sets(newSet(1, 2, 3, 4, 5), set.without(6)); assertSame(set, set.without(7)); assertSame(set, set.without(null)); } | @Override public ConstSet<E> without(Object o) { int index = ArrayTools.indexOf(o, elements); return index < 0 ? this : BasicCollections.<E>condenseToSet(delete(elements, index)); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> without(Object o) { int index = ArrayTools.indexOf(o, elements); return index < 0 ? this : BasicCollections.<E>condenseToSet(delete(elements, index)); } } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> without(Object o) { int index = ArrayTools.indexOf(o, elements); return index < 0 ? this : BasicCollections.<E>condenseToSet(delete(elements, index)); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> without(Object o) { int index = ArrayTools.indexOf(o, elements); return index < 0 ? this : BasicCollections.<E>condenseToSet(delete(elements, index)); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> without(Object o) { int index = ArrayTools.indexOf(o, elements); return index < 0 ? this : BasicCollections.<E>condenseToSet(delete(elements, index)); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test public void test_withoutAll() { ConstSet<Integer> set = new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}); compare_sets(newSet(3, 4, 5, 6), set.withoutAll(Arrays.asList(1, 2))); compare_sets(newSet(3, 4, 5, 6), set.withoutAll(Arrays.asList(1, 2, 9))); assertSame(set, set.withoutAll(Arrays.asList(7))); assertSame(set, set.withoutAll(Arrays.asList())); assertSame(BasicSet0.instance(), set.withoutAll(set)); } | @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}).withoutAll(null); } | @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSetN extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToSet(shrunk); } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get() { new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}).get(7); } | @Override E get(int index) { return elements[index]; } | BasicSetN extends BasicConstSet<E> { @Override E get(int index) { return elements[index]; } } | BasicSetN extends BasicConstSet<E> { @Override E get(int index) { return elements[index]; } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); } | BasicSetN extends BasicConstSet<E> { @Override E get(int index) { return elements[index]; } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSetN extends BasicConstSet<E> { @Override E get(int index) { return elements[index]; } @SuppressWarnings("unchecked") BasicSetN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test public void test_comparison() { compare_sets(Collections.emptySet(), BasicSet0.instance()); } | @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); @Override int size(); @Override boolean isEmpty(); @Override Iterator<E> iterator(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); @Override int size(); @Override boolean isEmpty(); @Override Iterator<E> iterator(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_immutable() { assert_set_immutable(BasicSet0.instance()); } | @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); @Override int size(); @Override boolean isEmpty(); @Override Iterator<E> iterator(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); @Override int size(); @Override boolean isEmpty(); @Override Iterator<E> iterator(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_serialization() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); out.writeObject(BasicSet0.instance()); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0%net.nullschool.collect.basic.SetProxy00000001300xpw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); assertSame(BasicSet0.instance(), in.readObject()); } | @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); @Override int size(); @Override boolean isEmpty(); @Override Iterator<E> iterator(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicSet0 extends BasicConstSet<E> { @SuppressWarnings("unchecked") static <E> BasicSet0<E> instance() { return INSTANCE; } private BasicSet0(); @Override int size(); @Override boolean isEmpty(); @Override Iterator<E> iterator(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_with() { ConstSortedMap<Object, Object> map; map = new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "e"}, new Object[] {1, 2, 3, 5}); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2, "c", 3, "d", 4, "e", 5), map.with("d", 4)); compare_sorted_maps(newSortedMap(null, "+", 0, "a", 1, "b", 2, "c", 3, "e", 5), map.with("+", 0)); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2, "c", 3, "e", 5, "f", 6), map.with("f", 6)); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 9, "c", 3, "e", 5), map.with("b", 9)); assertSame(map, map.with("b", 2)); map = new BasicSortedMapN<>(reverseOrder(), new Object[] {"e", "c", "b", "a"}, new Object[] {5, 3, 2, 1}); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "d", 4, "c", 3, "b", 2, "a", 1), map.with("d", 4)); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "c", 3, "b", 2, "a", 1, "+", 0), map.with("+", 0)); compare_sorted_maps(newSortedMap(reverseOrder(), "f", 6, "e", 5, "c", 3, "b", 2, "a", 1), map.with("f", 6)); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "c", 3, "b", 9, "a", 1), map.with("b", 9)); assertSame(map, map.with("b", 2)); } | @Override public ConstSortedMap<K, V> with(K key, V value) { int index = indexOf(key); if (index >= 0) { if (Objects.equals(value, values[index])) { return this; } return new BasicSortedMapN<>(comparator, keys, replace(values, index, value)); } index = flip(index); return new BasicSortedMapN<>(comparator, insert(keys, index, key), insert(values, index, value)); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> with(K key, V value) { int index = indexOf(key); if (index >= 0) { if (Objects.equals(value, values[index])) { return this; } return new BasicSortedMapN<>(comparator, keys, replace(values, index, value)); } index = flip(index); return new BasicSortedMapN<>(comparator, insert(keys, index, key), insert(values, index, value)); } } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> with(K key, V value) { int index = indexOf(key); if (index >= 0) { if (Objects.equals(value, values[index])) { return this; } return new BasicSortedMapN<>(comparator, keys, replace(values, index, value)); } index = flip(index); return new BasicSortedMapN<>(comparator, insert(keys, index, key), insert(values, index, value)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> with(K key, V value) { int index = indexOf(key); if (index >= 0) { if (Objects.equals(value, values[index])) { return this; } return new BasicSortedMapN<>(comparator, keys, replace(values, index, value)); } index = flip(index); return new BasicSortedMapN<>(comparator, insert(keys, index, key), insert(values, index, value)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> with(K key, V value) { int index = indexOf(key); if (index >= 0) { if (Objects.equals(value, values[index])) { return this; } return new BasicSortedMapN<>(comparator, keys, replace(values, index, value)); } index = flip(index); return new BasicSortedMapN<>(comparator, insert(keys, index, key), insert(values, index, value)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } |
@Test public void test_withAll() { ConstSortedMap<Object, Object> map; map = new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "e"}, new Object[] {1, 2, 3, 5}); compare_sorted_maps( newSortedMap(null, "+", 0, "a", 1, "b", 9, "c", 3, "d", 4, "e", 5, "f", 6), map.withAll(newMap("+", 0, "f", 6, "b", 9, "d", 4))); compare_sorted_maps(map, map.withAll(newMap("a", 1, "b", 2))); assertSame(map, map.withAll(newMap())); map = new BasicSortedMapN<>(reverseOrder(), new Object[] {"e", "c", "b", "a"}, new Object[] {5, 3, 2, 1}); compare_sorted_maps( newSortedMap(reverseOrder(), "f", 6, "e", 5, "d", 4, "c", 3, "b", 9, "a", 1, "+", 0), map.withAll(newMap("+", 0, "f", 6, "b", 9, "d", 4))); compare_sorted_maps(map, map.withAll(newMap("a", 1, "b", 2))); assertSame(map, map.withAll(newMap())); } | @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } |
@Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "d"}, new Object[] {1, 2, 3, 4}).withAll(null); } | @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } |
@Test public void test_cook() { Cook cook = new Cook(); assertEquals( new TypeToken<Integer>(){}.asType(), cook.apply(new TypeToken<Integer>(){}.asType())); assertEquals( new TypeToken<Integer[]>(){}.asType(), cook.apply(new TypeToken<Integer[]>(){}.asType())); assertEquals( new TypeToken<int[]>(){}.asType(), cook.apply(new TypeToken<int[]>(){}.asType())); assertEquals( new TypeToken<List<?>>(){}.asType(), cook.apply(new TypeToken<List>(){}.asType())); assertEquals( new TypeToken<List<?>[]>(){}.asType(), cook.apply(new TypeToken<List[]>(){}.asType())); assertEquals( new TypeToken<Enum<?>[]>(){}.asType(), cook.apply(new TypeToken<Enum<?>[]>(){}.asType())); assertEquals( new TypeToken<List<?>[][]>(){}.asType(), cook.apply(new TypeToken<List[][]>(){}.asType())); assertEquals( new TypeToken<Map<?, ?>>(){}.asType(), cook.apply(new TypeToken<Map>(){}.asType())); assertEquals( new TypeToken<Enum>(){}.asType(), cook.apply(new TypeToken<Enum>(){}.asType())); assertEquals( new TypeToken<EnumSet<? extends Enum>>(){}.asType(), cook.apply(new TypeToken<EnumSet>(){}.asType())); assertEquals( new TypeToken<ComparatorMap<? extends Comparator, ? extends Comparator>>(){}.asType(), cook.apply(new TypeToken<ComparatorMap>(){}.asType())); assertEquals( new TypeToken<NumberMap<? extends Number, ? extends Number>>(){}.asType(), cook.apply(new TypeToken<NumberMap>(){}.asType())); assertEquals( new TypeToken<NumbersMap<? extends Number, ? extends List<? extends Number>>>(){}.asType(), cook.apply(new TypeToken<NumbersMap>(){}.asType())); assertEquals( new TypeToken<ComplexList1<? extends ComplexList1>>(){}.asType(), cook.apply(new TypeToken<ComplexList1>(){}.asType())); assertEquals( new TypeToken<ComplexList2<? extends List<? extends List>>>(){}.asType(), cook.apply(new TypeToken<ComplexList2>(){}.asType())); assertEquals( new TypeToken<ComplexMap1<? extends List<? extends List>, ? extends List<? extends List>>>(){}.asType(), cook.apply(new TypeToken<ComplexMap1>(){}.asType())); assertEquals( new TypeToken<ComplexMap2<? extends List<? extends List>, ? extends List<? extends List>>>(){}.asType(), cook.apply(new TypeToken<ComplexMap2>(){}.asType())); assertEquals( new TypeToken<ComplexMap5<? extends Number, ? extends Map<? extends Number, ? extends List<? extends Number>>>>(){}.asType(), cook.apply(new TypeToken<ComplexMap5>(){}.asType())); assertEquals( new TypeToken<ComplexMap6<? extends Number, ? extends Map<? super Number, ? super List<? extends Number>>>>(){}.asType(), cook.apply(new TypeToken<ComplexMap6>(){}.asType())); assertEquals( new TypeToken<Outer<? extends Number>.Inner0>(){}.asType(), cook.apply(new TypeToken<Outer.Inner0>(){}.asType())); assertEquals( new TypeToken<Outer<? extends Number>.Inner1<? extends Number>>(){}.asType(), cook.apply(new TypeToken<Outer.Inner1>(){}.asType())); } | @Override public Type apply(Class<?> clazz) { if (clazz.isArray()) { Type componentType = apply(clazz.getComponentType()); if (!(componentType instanceof Class)) { return new LateGenericArrayType(componentType); } } else if (clazz == Enum.class) { return Enum.class; } else { Type ownerType = isInnerClass(clazz) ? apply(clazz.getEnclosingClass()) : clazz.getEnclosingClass(); TypeVariable<?>[] typeParameters = clazz.getTypeParameters(); if (typeParameters.length > 0 || ownerType instanceof ParameterizedType) { return apply(new LateParameterizedType(clazz, ownerType, typeParameters)); } } return clazz; } | Cook extends AbstractTypeOperator<Type> { @Override public Type apply(Class<?> clazz) { if (clazz.isArray()) { Type componentType = apply(clazz.getComponentType()); if (!(componentType instanceof Class)) { return new LateGenericArrayType(componentType); } } else if (clazz == Enum.class) { return Enum.class; } else { Type ownerType = isInnerClass(clazz) ? apply(clazz.getEnclosingClass()) : clazz.getEnclosingClass(); TypeVariable<?>[] typeParameters = clazz.getTypeParameters(); if (typeParameters.length > 0 || ownerType instanceof ParameterizedType) { return apply(new LateParameterizedType(clazz, ownerType, typeParameters)); } } return clazz; } } | Cook extends AbstractTypeOperator<Type> { @Override public Type apply(Class<?> clazz) { if (clazz.isArray()) { Type componentType = apply(clazz.getComponentType()); if (!(componentType instanceof Class)) { return new LateGenericArrayType(componentType); } } else if (clazz == Enum.class) { return Enum.class; } else { Type ownerType = isInnerClass(clazz) ? apply(clazz.getEnclosingClass()) : clazz.getEnclosingClass(); TypeVariable<?>[] typeParameters = clazz.getTypeParameters(); if (typeParameters.length > 0 || ownerType instanceof ParameterizedType) { return apply(new LateParameterizedType(clazz, ownerType, typeParameters)); } } return clazz; } } | Cook extends AbstractTypeOperator<Type> { @Override public Type apply(Class<?> clazz) { if (clazz.isArray()) { Type componentType = apply(clazz.getComponentType()); if (!(componentType instanceof Class)) { return new LateGenericArrayType(componentType); } } else if (clazz == Enum.class) { return Enum.class; } else { Type ownerType = isInnerClass(clazz) ? apply(clazz.getEnclosingClass()) : clazz.getEnclosingClass(); TypeVariable<?>[] typeParameters = clazz.getTypeParameters(); if (typeParameters.length > 0 || ownerType instanceof ParameterizedType) { return apply(new LateParameterizedType(clazz, ownerType, typeParameters)); } } return clazz; } @Override Type apply(Class<?> clazz); @Override Type apply(ParameterizedType pt); @Override Type apply(GenericArrayType gat); @Override Type apply(WildcardType wt); @Override Type apply(TypeVariable<?> tv); } | Cook extends AbstractTypeOperator<Type> { @Override public Type apply(Class<?> clazz) { if (clazz.isArray()) { Type componentType = apply(clazz.getComponentType()); if (!(componentType instanceof Class)) { return new LateGenericArrayType(componentType); } } else if (clazz == Enum.class) { return Enum.class; } else { Type ownerType = isInnerClass(clazz) ? apply(clazz.getEnclosingClass()) : clazz.getEnclosingClass(); TypeVariable<?>[] typeParameters = clazz.getTypeParameters(); if (typeParameters.length > 0 || ownerType instanceof ParameterizedType) { return apply(new LateParameterizedType(clazz, ownerType, typeParameters)); } } return clazz; } @Override Type apply(Class<?> clazz); @Override Type apply(ParameterizedType pt); @Override Type apply(GenericArrayType gat); @Override Type apply(WildcardType wt); @Override Type apply(TypeVariable<?> tv); } |
@Test public void test_without() { ConstSortedMap<Object, Object> map; map = new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "e"}, new Object[] {1, 2, 3, 5}); compare_sorted_maps(newSortedMap(null, "b", 2, "c", 3, "e", 5), map.without("a")); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2, "e", 5), map.without("c")); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2, "c", 3), map.without("e")); assertSame(map, map.without("+")); assertSame(map, map.without("d")); assertSame(map, map.without("f")); map = new BasicSortedMapN<>(reverseOrder(), new Object[] {"e", "c", "b", "a"}, new Object[] {5, 3, 2, 1}); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "c", 3, "b", 2), map.without("a")); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "b", 2, "a", 1), map.without("c")); compare_sorted_maps(newSortedMap(reverseOrder(), "c", 3, "b", 2, "a", 1), map.without("e")); assertSame(map, map.without("+")); assertSame(map, map.without("d")); assertSame(map, map.without("f")); } | @Override public ConstSortedMap<K, V> without(Object key) { int index = indexOf(key); return index < 0 ? this : BasicCollections.<K, V>condenseToSortedMap(comparator, delete(keys, index), delete(values, index)); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> without(Object key) { int index = indexOf(key); return index < 0 ? this : BasicCollections.<K, V>condenseToSortedMap(comparator, delete(keys, index), delete(values, index)); } } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> without(Object key) { int index = indexOf(key); return index < 0 ? this : BasicCollections.<K, V>condenseToSortedMap(comparator, delete(keys, index), delete(values, index)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> without(Object key) { int index = indexOf(key); return index < 0 ? this : BasicCollections.<K, V>condenseToSortedMap(comparator, delete(keys, index), delete(values, index)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> without(Object key) { int index = indexOf(key); return index < 0 ? this : BasicCollections.<K, V>condenseToSortedMap(comparator, delete(keys, index), delete(values, index)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } |
@Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "d"}, new Object[] {1, 2, 3, 4}).withoutAll(null); } | @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete) { if (keysToDelete.isEmpty()) { return this; } return condenseToSortedMap(comparator, deleteAll(keys, values, keysToDelete)); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete) { if (keysToDelete.isEmpty()) { return this; } return condenseToSortedMap(comparator, deleteAll(keys, values, keysToDelete)); } } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete) { if (keysToDelete.isEmpty()) { return this; } return condenseToSortedMap(comparator, deleteAll(keys, values, keysToDelete)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete) { if (keysToDelete.isEmpty()) { return this; } return condenseToSortedMap(comparator, deleteAll(keys, values, keysToDelete)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete) { if (keysToDelete.isEmpty()) { return this; } return condenseToSortedMap(comparator, deleteAll(keys, values, keysToDelete)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_key() { new BasicSortedMapN<>(null, new Object[] {"1", "2", "3", "4"}, new Object[] {1, 2, 3, 4}).getKey(5); } | @Override K getKey(int index) { return keys[index]; } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override K getKey(int index) { return keys[index]; } } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override K getKey(int index) { return keys[index]; } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override K getKey(int index) { return keys[index]; } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override K getKey(int index) { return keys[index]; } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_value() { new BasicSortedMapN<>(null, new Object[] {"1", "2", "3", "4"}, new Object[] {1, 2, 3, 4}).getValue(5); } | @Override V getValue(int index) { return values[index]; } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override V getValue(int index) { return values[index]; } } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override V getValue(int index) { return values[index]; } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override V getValue(int index) { return values[index]; } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } | BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override V getValue(int index) { return values[index]; } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); } |
@Test public void test_comparison() { compare_maps(Collections.emptyMap(), BasicMap0.instance()); } | @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override ConstSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstMap<K, V> with(K key, V value); @Override ConstMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstMap<K, V> without(Object key); @Override ConstMap<K, V> withoutAll(Collection<?> keys); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override ConstSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstMap<K, V> with(K key, V value); @Override ConstMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstMap<K, V> without(Object key); @Override ConstMap<K, V> withoutAll(Collection<?> keys); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_immutable() { assert_map_immutable(BasicMap0.instance()); } | @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override ConstSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstMap<K, V> with(K key, V value); @Override ConstMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstMap<K, V> without(Object key); @Override ConstMap<K, V> withoutAll(Collection<?> keys); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override ConstSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstMap<K, V> with(K key, V value); @Override ConstMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstMap<K, V> without(Object key); @Override ConstMap<K, V> withoutAll(Collection<?> keys); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_serialization() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); out.writeObject(BasicMap0.instance()); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0%net.nullschool.collect.basic.MapProxy00000001300xpw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); assertSame(BasicMap0.instance(), in.readObject()); } | @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override ConstSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstMap<K, V> with(K key, V value); @Override ConstMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstMap<K, V> without(Object key); @Override ConstMap<K, V> withoutAll(Collection<?> keys); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicMap0 extends BasicConstMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicMap0<K, V> instance() { return INSTANCE; } private BasicMap0(); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override ConstSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstMap<K, V> with(K key, V value); @Override ConstMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstMap<K, V> without(Object key); @Override ConstMap<K, V> withoutAll(Collection<?> keys); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_publicInterfaceRef_annotation_present() { Map<Integer, Integer> map = new HashMap<>(); for (int i = 0; i < 15; i++) { assertSame( BasicConstMap.class, asMap(map).getClass().getAnnotation(PublicInterfaceRef.class).value()); map.put(i, i); } } | @Deprecated @Override public final V put(K key, V value) { throw unsupported(); } | BasicConstMap extends AbstractIterableMap<K, V> implements ConstMap<K, V>, Serializable { @Deprecated @Override public final V put(K key, V value) { throw unsupported(); } } | BasicConstMap extends AbstractIterableMap<K, V> implements ConstMap<K, V>, Serializable { @Deprecated @Override public final V put(K key, V value) { throw unsupported(); } BasicConstMap(); } | BasicConstMap extends AbstractIterableMap<K, V> implements ConstMap<K, V>, Serializable { @Deprecated @Override public final V put(K key, V value) { throw unsupported(); } BasicConstMap(); @Override MapIterator<K, V> iterator(); @Override abstract ConstSet<K> keySet(); @Override abstract ConstCollection<V> values(); @Override abstract ConstSet<Map.Entry<K, V>> entrySet(); @Deprecated @Override final V put(K key, V value); @Deprecated @Override final void putAll(Map<? extends K, ? extends V> map); @Deprecated @Override final V remove(Object key); @Deprecated @Override final void clear(); } | BasicConstMap extends AbstractIterableMap<K, V> implements ConstMap<K, V>, Serializable { @Deprecated @Override public final V put(K key, V value) { throw unsupported(); } BasicConstMap(); @Override MapIterator<K, V> iterator(); @Override abstract ConstSet<K> keySet(); @Override abstract ConstCollection<V> values(); @Override abstract ConstSet<Map.Entry<K, V>> entrySet(); @Deprecated @Override final V put(K key, V value); @Deprecated @Override final void putAll(Map<? extends K, ? extends V> map); @Deprecated @Override final V remove(Object key); @Deprecated @Override final void clear(); } |
@Test public void test_comparison() { compare_sorted_maps(newSortedMap(null), BasicSortedMap0.instance(null), "a", "b"); compare_sorted_maps(newSortedMap(reverseOrder()), BasicSortedMap0.instance(reverseOrder()), "a", "b"); } | @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_immutable() { assert_sorted_map_immutable(BasicSortedMap0.instance(null)); } | @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_factoryFor() { assertSame(MockGrainFactory.INSTANCE, factoryFor(MockGrain.class)); assertSame(MockGrainFactory.INSTANCE, factoryFor(MockGrainFactory.class)); assertSame(MyFactory.FACTORY, factoryFor(MyFactory.class)); } | public static GrainFactory factoryFor(Class<?> clazz) { GrainFactoryRef ref = clazz.getAnnotation(GrainFactoryRef.class); if (ref != null) { return factoryInstance(ref.value()); } if (GrainFactory.class.isAssignableFrom(clazz)) { return factoryInstance(clazz.asSubclass(GrainFactory.class)); } throw new IllegalArgumentException("cannot find factory for " + clazz); } | GrainTools { public static GrainFactory factoryFor(Class<?> clazz) { GrainFactoryRef ref = clazz.getAnnotation(GrainFactoryRef.class); if (ref != null) { return factoryInstance(ref.value()); } if (GrainFactory.class.isAssignableFrom(clazz)) { return factoryInstance(clazz.asSubclass(GrainFactory.class)); } throw new IllegalArgumentException("cannot find factory for " + clazz); } } | GrainTools { public static GrainFactory factoryFor(Class<?> clazz) { GrainFactoryRef ref = clazz.getAnnotation(GrainFactoryRef.class); if (ref != null) { return factoryInstance(ref.value()); } if (GrainFactory.class.isAssignableFrom(clazz)) { return factoryInstance(clazz.asSubclass(GrainFactory.class)); } throw new IllegalArgumentException("cannot find factory for " + clazz); } private GrainTools(); } | GrainTools { public static GrainFactory factoryFor(Class<?> clazz) { GrainFactoryRef ref = clazz.getAnnotation(GrainFactoryRef.class); if (ref != null) { return factoryInstance(ref.value()); } if (GrainFactory.class.isAssignableFrom(clazz)) { return factoryInstance(clazz.asSubclass(GrainFactory.class)); } throw new IllegalArgumentException("cannot find factory for " + clazz); } private GrainTools(); static String targetPackageOf(Class<?> schema); static GrainFactory factoryFor(Class<?> clazz); static ConstMap<String, GrainProperty> asPropertyMap(GrainProperty... properties); } | GrainTools { public static GrainFactory factoryFor(Class<?> clazz) { GrainFactoryRef ref = clazz.getAnnotation(GrainFactoryRef.class); if (ref != null) { return factoryInstance(ref.value()); } if (GrainFactory.class.isAssignableFrom(clazz)) { return factoryInstance(clazz.asSubclass(GrainFactory.class)); } throw new IllegalArgumentException("cannot find factory for " + clazz); } private GrainTools(); static String targetPackageOf(Class<?> schema); static GrainFactory factoryFor(Class<?> clazz); static ConstMap<String, GrainProperty> asPropertyMap(GrainProperty... properties); } |
@Test public void test_serialization() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); ConstSortedMap<Object, Object> map = BasicSortedMap0.instance(null); out.writeObject(map); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0+net.nullschool.collect.basic.SortedMapProxy00000001300xppw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); assertSame(map, in.readObject()); } | @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_serialization_with_comparator() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); ConstSortedMap<Object, Object> map = BasicSortedMap0.instance(reverseOrder()); out.writeObject(map); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0+net.nullschool.collect.basic.SortedMapProxy00000001300xpsr0'" + "java.util.Collections$ReverseComparatord48af0SNJd0200xpw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); ConstSortedMap<?, ?> read = (ConstSortedMap)in.readObject(); compare_sorted_maps(map, read); assertSame(map.getClass(), read.getClass()); } | @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_with() { ConstSet<Integer> set; set = new BasicSet1<>(1); compare_sets(newSet(1, 2), set.with(2)); compare_sets(newSet(1, null), set.with(null)); assertSame(set, set.with(1)); set = new BasicSet1<>(null); assertSame(set, set.with(null)); } | @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(new Object[] {e0, e}); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(new Object[] {e0, e}); } } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(new Object[] {e0, e}); } @SuppressWarnings("unchecked") BasicSet1(Object e0); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(new Object[] {e0, e}); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> with(E e) { return contains(e) ? this : new BasicSetN<E>(new Object[] {e0, e}); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test public void test_withAll() { ConstSet<Integer> set = new BasicSet1<>(1); compare_sets(newSet(1, 2, 3), set.withAll(Arrays.asList(1, 2, 3, 3, 2, 1))); assertSame(set, set.withAll(Arrays.asList(1, 1, 1, 1, 1, 1))); assertSame(set, set.withAll(Collections.<Integer>emptyList())); } | @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } @SuppressWarnings("unchecked") BasicSet1(Object e0); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSet1<>(1).withAll(null); } | @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } @SuppressWarnings("unchecked") BasicSet1(Object e0); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray()); return expanded.length == size() ? this : BasicCollections.<E>condenseToSet(expanded); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test public void test_without() { ConstSet<Integer> set = new BasicSet1<>(1); assertSame(BasicSet0.instance(), set.without(1)); assertSame(set, set.without(2)); assertSame(set, set.without(null)); } | @Override public ConstSet<E> without(Object o) { return !contains(o) ? this : BasicCollections.<E>emptySet(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> without(Object o) { return !contains(o) ? this : BasicCollections.<E>emptySet(); } } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> without(Object o) { return !contains(o) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> without(Object o) { return !contains(o) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> without(Object o) { return !contains(o) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test public void test_withoutAll() { ConstSet<Integer> set = new BasicSet1<>(1); assertSame(BasicSet0.instance(), set.withoutAll(Arrays.asList(1))); assertSame(BasicSet0.instance(), set.withoutAll(Arrays.asList(2, 1))); assertSame(set, set.withoutAll(Arrays.asList(2))); assertSame(set, set.withoutAll(Arrays.asList())); } | @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSet1<>(1).withoutAll(null); } | @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSet1 extends BasicConstSet<E> { @Override public ConstSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : BasicCollections.<E>emptySet(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test public void test_get() { assertEquals(1, new BasicSet1<>(1).get(0)); } | @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } | BasicSet1 extends BasicConstSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } } | BasicSet1 extends BasicConstSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); } | BasicSet1 extends BasicConstSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSet1 extends BasicConstSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get() { new BasicSet1<>(1).get(1); } | @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } | BasicSet1 extends BasicConstSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } } | BasicSet1 extends BasicConstSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); } | BasicSet1 extends BasicConstSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } | BasicSet1 extends BasicConstSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSet1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override ConstSet<E> with(E e); @Override ConstSet<E> withAll(Collection<? extends E> c); @Override ConstSet<E> without(Object o); @Override ConstSet<E> withoutAll(Collection<?> c); @Override int hashCode(); } |
@Test(expected = IllegalArgumentException.class) public void test_bad_mapping_not_related() { ConfigurableTypePolicy.EMPTY.withImmutableMapping(Set.class, ConstMap.class); } | public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } | ConfigurableTypePolicy implements TypePolicy { public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } } | ConfigurableTypePolicy implements TypePolicy { public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); } | ConfigurableTypePolicy implements TypePolicy { public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); } | ConfigurableTypePolicy implements TypePolicy { public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); static final ConfigurableTypePolicy EMPTY; static final ConfigurableTypePolicy STANDARD; } |
@Test public void test_map_put() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); put(expected, actual, "d", 4); compare_maps(expected, actual); put(expected, actual, "a", -1); compare_maps(expected, actual); put(expected, actual, null, 10); compare_maps(expected, actual); put(expected, actual, null, 11); compare_maps(expected, actual); put(expected, actual, "e", null); compare_maps(expected, actual); put(expected, actual, "e", 5); compare_maps(expected, actual); } | @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_map_put_null_entry() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); put(expected, actual, null, null); compare_maps(expected, actual); } | @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_map_putAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); putAll(expected, actual, "a", -1, "d", 4); compare_maps(expected, actual); putAll(expected, actual, "e", null, null, 10); compare_maps(expected, actual); expected.putAll(Collections.<String, Integer>emptyMap()); actual.putAll(Collections.<String, Integer>emptyMap()); compare_maps(expected, actual); } | @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_map_putAll_iterableMap() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); IterableMap<String, Integer> im = new MockIterableMap<>(singletonMap("x", 0)); expected.putAll(im); actual.putAll(im); compare_maps(expected, actual); } | @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = NullPointerException.class) public void test_map_null_putAll() { new MockIterableMap<>().putAll(null); } | @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_map_remove() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, null, 4); Map<String, Integer> actual = new MockIterableMap<>(expected); remove(expected, actual, "c"); compare_maps(expected, actual); remove(expected, actual, "x"); compare_maps(expected, actual); remove(expected, actual, null); compare_maps(expected, actual); } | @Override public V remove(Object key) { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { if (Objects.equals(key, iter.next())) { V value = iter.value(); iter.remove(); return value; } } return null; } | AbstractIterableMap implements IterableMap<K, V> { @Override public V remove(Object key) { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { if (Objects.equals(key, iter.next())) { V value = iter.value(); iter.remove(); return value; } } return null; } } | AbstractIterableMap implements IterableMap<K, V> { @Override public V remove(Object key) { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { if (Objects.equals(key, iter.next())) { V value = iter.value(); iter.remove(); return value; } } return null; } } | AbstractIterableMap implements IterableMap<K, V> { @Override public V remove(Object key) { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { if (Objects.equals(key, iter.next())) { V value = iter.value(); iter.remove(); return value; } } return null; } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public V remove(Object key) { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { if (Objects.equals(key, iter.next())) { V value = iter.value(); iter.remove(); return value; } } return null; } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_map_clear() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); expected.clear(); actual.clear(); compare_maps(expected, actual); } | @Override public void clear() { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { iter.next(); iter.remove(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void clear() { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { iter.next(); iter.remove(); } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void clear() { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { iter.next(); iter.remove(); } } } | AbstractIterableMap implements IterableMap<K, V> { @Override public void clear() { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { iter.next(); iter.remove(); } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public void clear() { for (MapIterator<K, V> iter = iterator(); iter.hasNext();) { iter.next(); iter.remove(); } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_map_entry_setValue() { IterableMap<String, Integer> map = new MockIterableMap<>(singletonMap("a", 1)); for (MapIterator<String, Integer> iter = map.iterator(); iter.hasNext();) { iter.next(); iter.entry().setValue(9); } compare_maps(singletonMap("a", 9), map); } | @Override public abstract MapIterator<K, V> iterator(); | AbstractIterableMap implements IterableMap<K, V> { @Override public abstract MapIterator<K, V> iterator(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public abstract MapIterator<K, V> iterator(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public abstract MapIterator<K, V> iterator(); @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public abstract MapIterator<K, V> iterator(); @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = UnsupportedOperationException.class) public void test_map_put_throws() { @SuppressWarnings("unchecked") IterableMap<Object, Object> map = mock(AbstractIterableMap.class); given(map.put(any(), any())).willCallRealMethod(); map.put(new Object(), new Object()); } | @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public V put(K key, V value) { throw new UnsupportedOperationException(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_keySet_removeAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, null, 4); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); removeAll(expected.keySet(), actual.keySet(), "a", "c", null, "d"); compare_maps(expected, actual); removeAll(expected.keySet(), actual.keySet(), new String[0]); compare_maps(expected, actual); } | @Override public Set<K> keySet() { return new KeysView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = IllegalArgumentException.class) public void test_bad_mapping_not_narrowing() { ConfigurableTypePolicy.EMPTY.withImmutableMapping(ConstSet.class, Set.class); } | public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } | ConfigurableTypePolicy implements TypePolicy { public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } } | ConfigurableTypePolicy implements TypePolicy { public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); } | ConfigurableTypePolicy implements TypePolicy { public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); } | ConfigurableTypePolicy implements TypePolicy { public ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to) { if (!from.isAssignableFrom(to)) { throw new IllegalArgumentException(String.format("%s is not a supertype of %s", from, to)); } ConfigurableTypePolicy result = new ConfigurableTypePolicy(this); result.mappings.put(from, to); return result.registerTypes(Arrays.asList(to)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); static final ConfigurableTypePolicy EMPTY; static final ConfigurableTypePolicy STANDARD; } |
@Test(expected = NullPointerException.class) public void test_keySet_removeAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).keySet().removeAll(null); } | @Override public Set<K> keySet() { return new KeysView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_keySet_retainAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, null, 4); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); retainAll(expected.keySet(), actual.keySet(), "a", "c", null, "d"); compare_maps(expected, actual); } | @Override public Set<K> keySet() { return new KeysView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = NullPointerException.class) public void test_keySet_retainAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).keySet().retainAll(null); } | @Override public Set<K> keySet() { return new KeysView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = UnsupportedOperationException.class) public void test_keySet_add_throws() { new MockIterableMap<>().keySet().add("a"); } | @Override public Set<K> keySet() { return new KeysView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = UnsupportedOperationException.class) public void test_keySet_addAll_throws() { new MockIterableMap<>().keySet().addAll(Arrays.asList("a")); } | @Override public Set<K> keySet() { return new KeysView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_values_removeAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, "d", null, "x", 1); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); removeAll(expected.values(), actual.values(), 1, 3, null, 5); compare_maps(expected, actual); removeAll(expected.values(), actual.values(), new Integer[0]); compare_maps(expected, actual); } | @Override public Collection<V> values() { return new ValuesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = NullPointerException.class) public void test_values_removeAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).values().removeAll(null); } | @Override public Collection<V> values() { return new ValuesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_values_retainAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, "d", null, "x", 1); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); retainAll(expected.values(), actual.values(), 1, 3, null, 5); compare_maps(expected, actual); } | @Override public Collection<V> values() { return new ValuesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = NullPointerException.class) public void test_values_retainAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).values().retainAll(null); } | @Override public Collection<V> values() { return new ValuesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = UnsupportedOperationException.class) public void test_values_add_throws() { new MockIterableMap<>().values().add(1); } | @Override public Collection<V> values() { return new ValuesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_class_transform() { ConfigurableTypePolicy policy = ConfigurableTypePolicy.EMPTY; Transform<Long> transform = policy.newTransform(new TypeToken<Long>(){}); Object o = transform.apply(1L); assertEquals(1L, o); try { transform.apply(1); fail(); } catch (ClassCastException expected) {} } | @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } | ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } } | ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); } | ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); } | ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); static final ConfigurableTypePolicy EMPTY; static final ConfigurableTypePolicy STANDARD; } |
@Test(expected = UnsupportedOperationException.class) public void test_values_addAll_throws() { new MockIterableMap<>().values().addAll(Arrays.asList(1)); } | @Override public Collection<V> values() { return new ValuesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_entrySet_removeAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, "d", null, null, 5); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); removeAll( expected.entrySet(), actual.entrySet(), newEntry("a", 1), newEntry("d", (Integer)null), newEntry((String)null, 5), newEntry("c", 4), newEntry("x", 2), newEntry("z", 9)); compare_maps(expected, actual); removeAll(expected.entrySet(), actual.entrySet()); compare_maps(expected, actual); } | @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = NullPointerException.class) public void test_entrySet_removeAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).entrySet().removeAll(null); } | @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_entrySet_retainAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, "d", null, null, 5); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); retainAll( expected.entrySet(), actual.entrySet(), newEntry("a", 1), newEntry("d", (Integer)null), newEntry((String)null, 5), newEntry("c", 4), newEntry("x", 2), newEntry("z", 9)); compare_maps(expected, actual); } | @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = NullPointerException.class) public void test_entrySet_retainAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).entrySet().retainAll(null); } | @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = UnsupportedOperationException.class) public void test_entrySet_add_throws() { new MockIterableMap<String, Integer>().entrySet().add(newEntry("a", 1)); } | @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test(expected = UnsupportedOperationException.class) public void test_entrySet_addAll_throws() { new MockIterableMap<String, Integer>().entrySet().addAll(Arrays.asList(newEntry("a", 1))); } | @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } | AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); } |
@Test public void test_hashCode() { assertEquals(new SimpleImmutableEntry<>("a", 1).hashCode(), AbstractEntry.hashCode("a", 1)); assertEquals(new SimpleImmutableEntry<>("a", 1).hashCode(), mockEntry("a", 1).hashCode()); assertEquals(new SimpleImmutableEntry<>(null, null).hashCode(), AbstractEntry.hashCode(null, null)); assertEquals(new SimpleImmutableEntry<>(null, null).hashCode(), mockEntry(null, null).hashCode()); } | public static int hashCode(Object key, Object value) { return Objects.hashCode(key) ^ Objects.hashCode(value); } | AbstractEntry implements Map.Entry<K, V> { public static int hashCode(Object key, Object value) { return Objects.hashCode(key) ^ Objects.hashCode(value); } } | AbstractEntry implements Map.Entry<K, V> { public static int hashCode(Object key, Object value) { return Objects.hashCode(key) ^ Objects.hashCode(value); } } | AbstractEntry implements Map.Entry<K, V> { public static int hashCode(Object key, Object value) { return Objects.hashCode(key) ^ Objects.hashCode(value); } static int hashCode(Object key, Object value); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | AbstractEntry implements Map.Entry<K, V> { public static int hashCode(Object key, Object value) { return Objects.hashCode(key) ^ Objects.hashCode(value); } static int hashCode(Object key, Object value); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_toString() { assertEquals(new SimpleImmutableEntry<>("a", 1).toString(), mockEntry("a", 1).toString()); assertEquals(new SimpleImmutableEntry<>(null, null).toString(), mockEntry(null, null).toString()); } | @Override public String toString() { return Objects.toString(getKey()) + '=' + Objects.toString(getValue()); } | AbstractEntry implements Map.Entry<K, V> { @Override public String toString() { return Objects.toString(getKey()) + '=' + Objects.toString(getValue()); } } | AbstractEntry implements Map.Entry<K, V> { @Override public String toString() { return Objects.toString(getKey()) + '=' + Objects.toString(getValue()); } } | AbstractEntry implements Map.Entry<K, V> { @Override public String toString() { return Objects.toString(getKey()) + '=' + Objects.toString(getValue()); } static int hashCode(Object key, Object value); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } | AbstractEntry implements Map.Entry<K, V> { @Override public String toString() { return Objects.toString(getKey()) + '=' + Objects.toString(getValue()); } static int hashCode(Object key, Object value); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); } |
@Test public void test_interleave() { assertEquals("{a=1}", interleave(new String[] {"a"}, new Integer[] {1}).toString()); assertEquals("{a=1, b=2}", interleave(new String[] {"a", "b"}, new Integer[] {1, 2}).toString()); assertEquals("{a=2}", interleave(new String[] {"a", "a"}, new Integer[] {1, 2}).toString()); assertEquals("{a=1}", interleave(new String[] {"a", "b"}, new Integer[] {1}).toString()); assertEquals("{a=1}", interleave(new String[] {"a"}, new Integer[] {1, 2}).toString()); assertEquals("{}", interleave(new String[] {}, new Integer[] {}).toString()); } | public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } |
@Test public void test_list_transform() { ConfigurableTypePolicy policy = ConfigurableTypePolicy.EMPTY; Transform<List<String>> transform = policy.newTransform(new TypeToken<List<String>>(){}); Object o = transform.apply(listOf("a")); assertEquals(listOf("a"), o); try { transform.apply(setOf("a")); fail(); } catch (ClassCastException expected) {} List<String> list = transform.apply(listOf(1)); try { System.out.println(list.get(0)); fail(); } catch (ClassCastException darn) {} } | @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } | ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } } | ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); } | ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); } | ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); static final ConfigurableTypePolicy EMPTY; static final ConfigurableTypePolicy STANDARD; } |
@Test public void test_collectProperties_multiple_levels() throws IntrospectionException { List<GrainProperty> result; result = collectProperties(Organism.class); assertEquals(1, result.size()); assertEquals("id", result.get(0).getName()); assertEquals(int.class, result.get(0).getType()); assertTrue(result.get(0).getFlags().isEmpty()); result = collectProperties(Animal.class); assertEquals(3, result.size()); assertEquals("vertebrate", result.get(0).getName()); assertEquals(boolean.class, result.get(0).getType()); assertEquals(GrainProperty.Flag.IS_PROPERTY, result.get(0).getFlags().iterator().next()); assertEquals("id", result.get(1).getName()); assertEquals(int.class, result.get(1).getType()); assertTrue(result.get(1).getFlags().isEmpty()); assertEquals("parent", result.get(2).getName()); assertEquals(UUID.class, result.get(2).getType()); assertTrue(result.get(2).getFlags().isEmpty()); } | static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } | SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } } | SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } SymbolTable(Class<?> schema, TypeTable typeTable, TypePrinterFactory printerFactory, Member typePolicyMember); } | SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } SymbolTable(Class<?> schema, TypeTable typeTable, TypePrinterFactory printerFactory, Member typePolicyMember); } | SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } SymbolTable(Class<?> schema, TypeTable typeTable, TypePrinterFactory printerFactory, Member typePolicyMember); } |
@Test(expected = NullPointerException.class) public void test_bad_interleave() { interleave(new String[] {}, null); } | public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } |
@Test(expected = NullPointerException.class) public void test_bad_interleave_2() { interleave(null, new Integer[] {}); } | public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } | MapTools { public static <K, V> Map<K, V> interleave(K[] keys, V[] values) { int length = min(keys.length, values.length); LinkedHashMap<K, V> map = new LinkedHashMap<>(goodInitialCapacity(length)); for (int i = 0; i < length; i++) { map.put(keys[i], values[i]); } return map; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } |
@Test public void test_putAll() { Map<String, Integer> map = new HashMap<>(); Map<String, Integer> source = new HashMap<>(); source.put("a", 1); source.put("b", 2); assertSame(map, putAll(map, source)); assertEquals(source, map); try { putAll(map, null); fail(); } catch (NullPointerException ignored) {} try { putAll(null, source); fail(); } catch (NullPointerException ignored) {} } | public static <K, V, T extends Map<K, V>> T putAll(T dest, Map<? extends K, ? extends V> map) { dest.putAll(map); return dest; } | MapTools { public static <K, V, T extends Map<K, V>> T putAll(T dest, Map<? extends K, ? extends V> map) { dest.putAll(map); return dest; } } | MapTools { public static <K, V, T extends Map<K, V>> T putAll(T dest, Map<? extends K, ? extends V> map) { dest.putAll(map); return dest; } private MapTools(); } | MapTools { public static <K, V, T extends Map<K, V>> T putAll(T dest, Map<? extends K, ? extends V> map) { dest.putAll(map); return dest; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } | MapTools { public static <K, V, T extends Map<K, V>> T putAll(T dest, Map<? extends K, ? extends V> map) { dest.putAll(map); return dest; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } |
@Test public void test_removeAll() { Map<String, Integer> map = new HashMap<>(); map.put("a", 1); map.put("b", 2); map.put("c", 3); Collection<String> keys = Arrays.asList("a", "b"); assertSame(map, removeAll(map, keys)); Map<String, Integer> expected = new HashMap<>(); expected.put("c", 3); assertEquals(expected, map); try { removeAll(map, null); fail(); } catch (NullPointerException ignored) {} try { removeAll(null, keys); fail(); } catch (NullPointerException ignored) {} } | public static <T extends Map<?, ?>> T removeAll(T map, Collection<?> keys) { map.keySet().removeAll(keys); return map; } | MapTools { public static <T extends Map<?, ?>> T removeAll(T map, Collection<?> keys) { map.keySet().removeAll(keys); return map; } } | MapTools { public static <T extends Map<?, ?>> T removeAll(T map, Collection<?> keys) { map.keySet().removeAll(keys); return map; } private MapTools(); } | MapTools { public static <T extends Map<?, ?>> T removeAll(T map, Collection<?> keys) { map.keySet().removeAll(keys); return map; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } | MapTools { public static <T extends Map<?, ?>> T removeAll(T map, Collection<?> keys) { map.keySet().removeAll(keys); return map; } private MapTools(); static Map<K, V> interleave(K[] keys, V[] values); static T putAll(T dest, Map<? extends K, ? extends V> map); static T removeAll(T map, Collection<?> keys); } |
@Test public void test_empty_map_iterator() { assertFalse(emptyMapIterator().hasNext()); try { emptyMapIterator().next(); fail(); } catch (NoSuchElementException ignored) {} try { emptyMapIterator().value(); fail(); } catch (IllegalStateException ignored) {} try { emptyMapIterator().entry(); fail(); } catch (IllegalStateException ignored) {} try { emptyMapIterator().remove(); fail(); } catch (IllegalStateException ignored) {} assertSame(emptyMapIterator(), emptyMapIterator()); } | @SuppressWarnings("unchecked") public static <K, V> MapIterator<K, V> emptyMapIterator() { return (MapIterator<K, V>)EmptyMapIterator.INSTANCE; } | IteratorTools { @SuppressWarnings("unchecked") public static <K, V> MapIterator<K, V> emptyMapIterator() { return (MapIterator<K, V>)EmptyMapIterator.INSTANCE; } } | IteratorTools { @SuppressWarnings("unchecked") public static <K, V> MapIterator<K, V> emptyMapIterator() { return (MapIterator<K, V>)EmptyMapIterator.INSTANCE; } private IteratorTools(); } | IteratorTools { @SuppressWarnings("unchecked") public static <K, V> MapIterator<K, V> emptyMapIterator() { return (MapIterator<K, V>)EmptyMapIterator.INSTANCE; } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } | IteratorTools { @SuppressWarnings("unchecked") public static <K, V> MapIterator<K, V> emptyMapIterator() { return (MapIterator<K, V>)EmptyMapIterator.INSTANCE; } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } |
@Test public void test_newMapIterator_adapter() { Map map = mock(Map.class); Set entrySet = mock(Set.class); Iterator entrySetIter = mock(Iterator.class); Map.Entry entry1 = new AbstractMap.SimpleImmutableEntry<>("a", 1); Map.Entry entry2 = new AbstractMap.SimpleImmutableEntry<>("b", 2); when(map.isEmpty()).thenReturn(false); when(map.entrySet()).thenReturn(entrySet); when(entrySet.iterator()).thenReturn(entrySetIter); when(entrySetIter.hasNext()).thenReturn(true, true, false); when(entrySetIter.next()).thenReturn(entry1, entry2); MapIterator iter = newMapIterator((Map<?, ?>)map); try { iter.value(); fail(); } catch (IllegalStateException ignored) {} try { iter.entry(); fail(); } catch (IllegalStateException ignored) {} assertTrue(iter.hasNext()); assertEquals(entry1.getKey(), iter.next()); assertEquals(entry1.getValue(), iter.value()); assertSame(entry1, iter.entry()); iter.remove(); try { iter.value(); fail(); } catch (IllegalStateException ignored) {} try { iter.entry(); fail(); } catch (IllegalStateException ignored) {} assertTrue(iter.hasNext()); assertEquals(entry2.getKey(), iter.next()); assertEquals(entry2.getValue(), iter.value()); assertSame(entry2, iter.entry()); iter.remove(); try { iter.value(); fail(); } catch (IllegalStateException ignored) {} try { iter.entry(); fail(); } catch (IllegalStateException ignored) {} verify(entrySetIter, times(2)).hasNext(); verify(entrySetIter, times(2)).next(); verify(entrySetIter, times(2)).remove(); assertFalse(iter.hasNext()); } | public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } |
@Test public void test_newMapIterator_on_iterableMap() { IterableMap map = mock(IterableMap.class); MapIterator iter = mock(MapIterator.class); when(map.isEmpty()).thenReturn(false); when(map.iterator()).thenReturn(iter); assertSame(iter, newMapIterator((Map<?, ?>)map)); } | public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } |
@Test(expected = NullPointerException.class) public void test_newMapIterator_throws() { newMapIterator(null); } | public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } | IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } |
@Test @SuppressWarnings("unchecked") public void test_chainMapIterators() { MapIterator first = mock(MapIterator.class); MapIterator second = mock(MapIterator.class); Map.Entry entry1 = newEntry("a", 1); Map.Entry entry2 = newEntry("b", 2); Map.Entry entry3 = newEntry("c", 3); Map.Entry entry4 = newEntry("d", 4); when(first.hasNext()).thenReturn(true, true, false); when(first.next()).thenReturn(entry1.getKey(), entry2.getKey()); when(first.value()).thenReturn(entry1.getValue(), entry2.getValue()); when(first.entry()).thenReturn(entry1, entry2); when(second.hasNext()).thenReturn(true, true, false); when(second.next()).thenReturn(entry3.getKey(), entry4.getKey()).thenThrow(NoSuchElementException.class); when(second.value()).thenReturn(entry3.getValue(), entry4.getValue()); when(second.entry()).thenReturn(entry3, entry4); MapIterator iter = chainMapIterators(first, second); assertTrue(iter.hasNext()); assertEquals(entry1.getKey(), iter.next()); assertEquals(entry1.getValue(), iter.value()); assertSame(entry1, iter.entry()); assertTrue(iter.hasNext()); assertEquals(entry2.getKey(), iter.next()); assertEquals(entry2.getValue(), iter.value()); assertSame(entry2, iter.entry()); iter.remove(); assertTrue(iter.hasNext()); assertEquals(entry3.getKey(), iter.next()); assertEquals(entry3.getValue(), iter.value()); assertSame(entry3, iter.entry()); assertTrue(iter.hasNext()); assertEquals(entry4.getKey(), iter.next()); assertEquals(entry4.getValue(), iter.value()); assertSame(entry4, iter.entry()); assertFalse(iter.hasNext()); try { iter.next(); fail(); } catch (NoSuchElementException ignored) {} iter.remove(); verify(first, times(3)).hasNext(); verify(first, times(2)).next(); verify(first, times(2)).value(); verify(first, times(2)).entry(); verify(first, times(1)).remove(); verify(second, times(3)).hasNext(); verify(second, times(3)).next(); verify(second, times(2)).value(); verify(second, times(2)).entry(); verify(second, times(1)).remove(); } | public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } | IteratorTools { public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } } | IteratorTools { public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } private IteratorTools(); } | IteratorTools { public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } | IteratorTools { public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } |
@Test @SuppressWarnings("unchecked") public void test_chainMapIterators_without_calling_hasNext() { MapIterator first = mock(MapIterator.class); MapIterator second = mock(MapIterator.class); Map.Entry entry1 = newEntry("a", 1); Map.Entry entry2 = newEntry("b", 2); when(first.next()).thenReturn(entry1.getKey()).thenThrow(NoSuchElementException.class); when(first.value()).thenReturn(entry1.getValue()); when(first.entry()).thenReturn(entry1); when(second.next()).thenReturn(entry2.getKey()).thenThrow(NoSuchElementException.class); when(second.value()).thenReturn(entry2.getValue()); when(second.entry()).thenReturn(entry2); MapIterator iter = chainMapIterators(first, second); assertEquals(entry1.getKey(), iter.next()); assertEquals(entry1.getValue(), iter.value()); assertSame(entry1, iter.entry()); assertEquals(entry2.getKey(), iter.next()); assertEquals(entry2.getValue(), iter.value()); assertSame(entry2, iter.entry()); try { iter.next(); fail(); } catch (NoSuchElementException ignored) {} verify(first, times(0)).hasNext(); verify(first, times(2)).next(); verify(first, times(1)).value(); verify(first, times(1)).entry(); verify(second, times(0)).hasNext(); verify(second, times(2)).next(); verify(second, times(1)).value(); verify(second, times(1)).entry(); } | public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } | IteratorTools { public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } } | IteratorTools { public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } private IteratorTools(); } | IteratorTools { public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } | IteratorTools { public static <K, V> MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second) { if (first == null || second == null) { throw new NullPointerException(); } return second == EmptyMapIterator.INSTANCE ? first : first == EmptyMapIterator.INSTANCE ? second : new DualMapIterator<>(first, second); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); } |
@Test public void test_remove() { GrainBuilder builder = new MockGrainBuilder("a"); builder.put("a", 1); builder.put("b", 2); compare_maps(newMap("a", 1, "b", 2), builder); builder.remove("a"); compare_maps(newMap("a", null, "b", 2), builder); builder.remove("b"); compare_maps(newMap("a", null), builder); } | @Override public abstract Object remove(Object key); | AbstractGrainBuilder extends AbstractIterableMap<String, Object> implements GrainBuilder { @Override public abstract Object remove(Object key); } | AbstractGrainBuilder extends AbstractIterableMap<String, Object> implements GrainBuilder { @Override public abstract Object remove(Object key); } | AbstractGrainBuilder extends AbstractIterableMap<String, Object> implements GrainBuilder { @Override public abstract Object remove(Object key); @Override abstract Grain build(); @Override abstract Object get(Object key); @Override abstract Object remove(Object key); } | AbstractGrainBuilder extends AbstractIterableMap<String, Object> implements GrainBuilder { @Override public abstract Object remove(Object key); @Override abstract Grain build(); @Override abstract Object get(Object key); @Override abstract Object remove(Object key); } |
@Test public void test_iterator_remove() { GrainBuilder builder = new MockGrainBuilder("a", "x", "y"); builder.put("x", 8); builder.put("y", 9); builder.put("a", 1); builder.put("c", 3); builder.put("b", 2); compare_maps(newMap("a", 1, "x", 8, "y", 9, "b", 2, "c", 3), builder); for (MapIterator<String, Object> iter = builder.iterator(); iter.hasNext();) { iter.next(); iter.remove(); } compare_maps(newMap("a", null, "x", null, "y", null), builder); } | @Override public abstract Object remove(Object key); | AbstractGrainBuilder extends AbstractIterableMap<String, Object> implements GrainBuilder { @Override public abstract Object remove(Object key); } | AbstractGrainBuilder extends AbstractIterableMap<String, Object> implements GrainBuilder { @Override public abstract Object remove(Object key); } | AbstractGrainBuilder extends AbstractIterableMap<String, Object> implements GrainBuilder { @Override public abstract Object remove(Object key); @Override abstract Grain build(); @Override abstract Object get(Object key); @Override abstract Object remove(Object key); } | AbstractGrainBuilder extends AbstractIterableMap<String, Object> implements GrainBuilder { @Override public abstract Object remove(Object key); @Override abstract Grain build(); @Override abstract Object get(Object key); @Override abstract Object remove(Object key); } |
@Test public void test_iteration_without_calling_hasNext() { Set<String> keys = new LinkedHashSet<>(); Grain grain = new MockGrain(sortedMapOf(null, "a", (Object)1), sortedMapOf(null, "b", (Object)2)); MapIterator<String, Object> iter = grain.iterator(); for (int i = 0; i < grain.size(); i++) { keys.add(iter.next()); } try { iter.next(); fail(); } catch (NoSuchElementException expected) {} assertArrayEquals(grain.keySet().toArray(), keys.toArray()); } | @Override public ConstSet<String> keySet() { return new ConstKeysView(); } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<String> keySet() { return new ConstKeysView(); } } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<String> keySet() { return new ConstKeysView(); } } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<String> keySet() { return new ConstKeysView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<String> keySet() { return new ConstKeysView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); } |
@Test public void test_keySet_modify() { Grain grain = new MockGrain(sortedMapOf(null, "a", (Object)1), sortedMapOf(null, "b", (Object)2)); ConstSet<String> keySet = grain.keySet(); assertSame(keySet, keySet.with("a")); assertSame(keySet, keySet.with("b")); compare_sets(newSet("a", "b", "+"), keySet.with("+")); compare_sets(newSet("a", "b", "+", "c"), keySet.withAll(Arrays.asList("+", "c"))); assertSame(keySet, keySet.withAll(Arrays.<String>asList())); assertSame(keySet, keySet.without("+")); compare_sets(newSet("b"), keySet.without("a")); compare_sets(newSet("a"), keySet.without("b")); compare_sets(newSet("a"), keySet.withoutAll(Arrays.asList("b", "c"))); compare_sets(newSet(), keySet.withoutAll(keySet)); assertSame(keySet, keySet.withoutAll(Arrays.asList())); } | @Override public ConstSet<String> keySet() { return new ConstKeysView(); } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<String> keySet() { return new ConstKeysView(); } } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<String> keySet() { return new ConstKeysView(); } } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<String> keySet() { return new ConstKeysView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<String> keySet() { return new ConstKeysView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); } |
@Test public void test_values_modify() { Grain grain = new MockGrain(sortedMapOf(null, "a", (Object)1), sortedMapOf(null, "b", (Object)2)); ConstCollection<Object> values = grain.values(); assertSame(values, values.with(1)); assertSame(values, values.with(2)); compare_collections(Arrays.asList(1, 2, 3), values.with(3)); compare_collections(Arrays.asList(1, 2, 0, 3), values.withAll(Arrays.asList(0, 3))); assertSame(values, values.withAll(Arrays.asList())); assertSame(values, values.without(0)); compare_collections(Arrays.asList(2), values.without(1)); compare_collections(Arrays.asList(1), values.without(2)); compare_collections(Arrays.asList(1), values.withoutAll(Arrays.asList(2, 3))); compare_collections(Arrays.asList(), values.withoutAll(values)); assertSame(values, values.withoutAll(Arrays.asList())); } | @Override public ConstCollection<Object> values() { return new ConstValuesView(); } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstCollection<Object> values() { return new ConstValuesView(); } } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstCollection<Object> values() { return new ConstValuesView(); } } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstCollection<Object> values() { return new ConstValuesView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstCollection<Object> values() { return new ConstValuesView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); } |
@Test public void test_entrySet_modify() { Grain grain = new MockGrain(sortedMapOf(null, "a", (Object)1), sortedMapOf(null, "b", (Object)2)); ConstSet<Entry<String, Object>> entrySet = grain.entrySet(); assertSame(entrySet, entrySet.with(newEntry("a", (Object)1))); assertSame(entrySet, entrySet.with(newEntry("b", (Object)2))); compare_sets( newSet(newEntry("a", 1), newEntry("b", 2), newEntry("a", 3)), entrySet.with(newEntry("a", (Object)3))); compare_sets( newSet(newEntry("a", 1), newEntry("b", 2), newEntry("a", 3), newEntry("c", 3)), entrySet.withAll(Arrays.asList(newEntry("a", (Object)3), newEntry("c", (Object)3)))); assertSame(entrySet, entrySet.withAll(Arrays.<Entry<String, Object>>asList())); assertSame(entrySet, entrySet.without(newEntry("a", 2))); compare_sets(newSet(newEntry("b", 2)), entrySet.without(newEntry("a", 1))); compare_sets(newSet(newEntry("a", 1)), entrySet.without(newEntry("b", 2))); compare_sets( newSet(newEntry("a", 1)), entrySet.withoutAll(Arrays.asList(newEntry("b", (Object)2), newEntry("c", (Object)3)))); compare_sets(newSet(), entrySet.withoutAll(entrySet)); assertSame(entrySet, entrySet.withoutAll(Arrays.asList())); } | @Override public ConstSet<Entry<String, Object>> entrySet() { return new ConstEntriesView(); } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<Entry<String, Object>> entrySet() { return new ConstEntriesView(); } } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<Entry<String, Object>> entrySet() { return new ConstEntriesView(); } } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<Entry<String, Object>> entrySet() { return new ConstEntriesView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); } | AbstractGrain extends AbstractIterableMap<String, Object> implements Grain { @Override public ConstSet<Entry<String, Object>> entrySet() { return new ConstEntriesView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); } |
@Test public void test_indexOf() { assertEquals(0, indexOf(10, new Integer[] {10})); assertEquals(-1, indexOf(9, new Integer[] {10})); assertEquals(-1, indexOf(null, new Integer[] {10})); assertEquals(1, indexOf(null, new Integer[] {10, null, null})); assertEquals(3, indexOf(13, new Integer[] {10, null, null, 13})); } | public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); static final Object[] EMPTY_OBJECT_ARRAY; static final Class<?>[] EMPTY_CLASS_ARRAY; static final Type[] EMPTY_TYPE_ARRAY; } |
@Test(expected = NullPointerException.class) public void test_indexOf_illegal_arg() { indexOf(10, null); } | public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); static final Object[] EMPTY_OBJECT_ARRAY; static final Class<?>[] EMPTY_CLASS_ARRAY; static final Type[] EMPTY_TYPE_ARRAY; } |
@Test public void test_bounded_indexOf() { Integer[] ary = new Integer[] {10, 11, 12, 13, null, 10, 11, 12, 13, null}; assertEquals(0, indexOf(10, ary, 0, 10)); assertEquals(5, indexOf(10, ary, 1, 10)); assertEquals(-1, indexOf(10, ary, 1, 5)); assertEquals(4, indexOf(null, ary, 0, 10)); assertEquals(4, indexOf(null, ary, 4, 10)); assertEquals(9, indexOf(null, ary, 5, 10)); assertEquals(-1, indexOf(null, ary, 5, 9)); assertEquals(-1, indexOf(10, ary, 0, 0)); assertEquals(-1, indexOf(10, ary, 10, 10)); } | public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); static final Object[] EMPTY_OBJECT_ARRAY; static final Class<?>[] EMPTY_CLASS_ARRAY; static final Type[] EMPTY_TYPE_ARRAY; } |
@Test public void test_bounded_indexOf_illegal_arg() { Integer[] ary = new Integer[] {10, 11, 12, 13, null, 10, 11, 12, 13, null}; try { indexOf(0, null, 2, 1); fail(); } catch (NullPointerException ignored) {} try { indexOf(0, ary, -2, -1); fail(); } catch (IndexOutOfBoundsException ignored) {} try { indexOf(0, ary, -1, 0); fail(); } catch (IndexOutOfBoundsException ignored) {} try { indexOf(0, ary, 10, 11); fail(); } catch (IndexOutOfBoundsException ignored) {} try { indexOf(0, ary, 2, 1); fail(); } catch (IllegalArgumentException ignored) {} } | public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); static final Object[] EMPTY_OBJECT_ARRAY; static final Class<?>[] EMPTY_CLASS_ARRAY; static final Type[] EMPTY_TYPE_ARRAY; } |
@Test public void test_collectProperties_multiple_level_raw_generic() throws IntrospectionException { List<GrainProperty> result; result = collectProperties(RawDescendant.class); assertEquals(1, result.size()); assertEquals("parent", result.get(0).getName()); assertEquals(new LateTypeVariable<>("T", Descendant.class), result.get(0).getType()); assertTrue(result.get(0).getFlags().isEmpty()); } | static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } | SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } } | SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } SymbolTable(Class<?> schema, TypeTable typeTable, TypePrinterFactory printerFactory, Member typePolicyMember); } | SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } SymbolTable(Class<?> schema, TypeTable typeTable, TypePrinterFactory printerFactory, Member typePolicyMember); } | SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } SymbolTable(Class<?> schema, TypeTable typeTable, TypePrinterFactory printerFactory, Member typePolicyMember); } |
@Test public void test_comparator_indexOf() { String[] ary = new String[] {"a", "b", "c", "d", "B"}; assertEquals(1, indexOf("b", ary, String.CASE_INSENSITIVE_ORDER)); assertEquals(1, indexOf("B", ary, String.CASE_INSENSITIVE_ORDER)); assertEquals(-1, indexOf("e", ary, String.CASE_INSENSITIVE_ORDER)); assertEquals(1, indexOf("b", ary, null)); assertEquals(4, indexOf("B", ary, null)); assertEquals(-1, indexOf("e", ary, null)); } | public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); } | ArrayTools { public static <T> int indexOf(T element, T[] array) { if (element == null) { for (int i = 0; i < array.length; i++) { if (array[i] == null) { return i; } } } else { for (int i = 0; i < array.length; i++) { if (element.equals(array[i])) { return i; } } } return -1; } private ArrayTools(); static int indexOf(T element, T[] array); static int indexOf(T element, T[] array, int fromIndex, int toIndex); static int indexOf(T element, T[] array, Comparator<? super T> comparator); static int indexOf(T element, T[] array, int fromIndex, int toIndex, Comparator<? super T> comparator); static int lastIndexOf(T element, T[] array); static void checkRange(int fromIndex, int toIndex, int length); static T[] sort(T[] a); static T[] sort(T[] a, Comparator<? super T> c); static final Object[] EMPTY_OBJECT_ARRAY; static final Class<?>[] EMPTY_CLASS_ARRAY; static final Type[] EMPTY_TYPE_ARRAY; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.