Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: BasicMapN extends BasicConstMap<K, V> { @Override public ConstMap<K, V> without(Object key) { int index = ArrayTools.indexOf(key, keys); return index < 0 ? this : BasicCollections.<K, V>condenseToMap(delete(keys, index), delete(values, index)); } @SuppressWarnings("unchecked") BasicMapN(Object[] keys, Object[] values); @Override int size(); @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<?> keysToDelete); @Override int hashCode(); }### Answer: @Test public void test_without() { ConstMap<Object, Object> map = new BasicMapN<>(new Object[] {"a", "b", "c", "d"}, new Object[] {1, 2, 3, 4}); compare_maps(newMap("a", 1, "b", 2, "c", 3), map.without("d")); assertSame(map, map.without("e")); assertSame(map, map.without(null)); }
### Question: BasicMapN extends BasicConstMap<K, V> { @Override public ConstMap<K, V> withoutAll(Collection<?> keysToDelete) { if (keysToDelete.isEmpty()) { return this; } return condenseToMap(deleteAll(keys, values, keysToDelete)); } @SuppressWarnings("unchecked") BasicMapN(Object[] keys, Object[] values); @Override int size(); @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<?> keysToDelete); @Override int hashCode(); }### Answer: @Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicMapN<>(new Object[] {"a", "b", "c", "d"}, new Object[] {1, 2, 3, 4}).withoutAll(null); }
### Question: BasicMapN extends BasicConstMap<K, V> { @Override K getKey(int index) { return keys[index]; } @SuppressWarnings("unchecked") BasicMapN(Object[] keys, Object[] values); @Override int size(); @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<?> keysToDelete); @Override int hashCode(); }### Answer: @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_key() { new BasicMapN<>(new Object[] {"1", "2", "3", "4"}, new Object[] {1, 2, 3, 4}).getKey(5); }
### Question: BasicMapN extends BasicConstMap<K, V> { @Override V getValue(int index) { return values[index]; } @SuppressWarnings("unchecked") BasicMapN(Object[] keys, Object[] values); @Override int size(); @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<?> keysToDelete); @Override int hashCode(); }### Answer: @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_value() { new BasicMapN<>(new Object[] {"1", "2", "3", "4"}, new Object[] {1, 2, 3, 4}).getValue(5); }
### Question: BasicList0 extends BasicConstList<E> { @SuppressWarnings("unchecked") static <E> BasicList0<E> instance() { return INSTANCE; } private BasicList0(); @Override int size(); @Override boolean isEmpty(); @Override Iterator<E> iterator(); @Override ListIterator<E> listIterator(); @Override ListIterator<E> listIterator(int index); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override E get(int index); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstList<E> with(E e); @Override ConstList<E> with(int index, E e); @Override ConstList<E> withAll(Collection<? extends E> c); @Override ConstList<E> withAll(int index, Collection<? extends E> c); @Override ConstList<E> replace(int index, E e); @Override ConstList<E> without(Object o); @Override ConstList<E> delete(int index); @Override ConstList<E> withoutAll(Collection<?> c); @Override ConstList<E> subList(int fromIndex, int toIndex); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void test_comparison() { compare_lists(Collections.emptyList(), BasicList0.instance()); } @Test public void test_immutable() { assert_list_immutable(BasicList0.instance()); } @Test public void test_serialization() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); out.writeObject(BasicList0.instance()); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0&net.nullschool.collect.basic.ListProxy00000001300xpw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); assertSame(BasicList0.instance(), in.readObject()); }
### Question: BasicTools { static Object[] insert(Object[] original, int index, Object e) { Object[] result = new Object[original.length + 1]; System.arraycopy(original, 0, result, 0, index); result[index] = e; System.arraycopy(original, index, result, index + 1, original.length - index); return result; } private BasicTools(); }### Answer: @Test public void test_insert() { Object[] src = new Object[] {1, 2, 3}; assertArrayEquals(new Object[] {4, 1, 2, 3}, insert(src, 0, 4)); assertArrayEquals(new Object[] {1, 4, 2, 3}, insert(src, 1, 4)); assertArrayEquals(new Object[] {1, 2, 4, 3}, insert(src, 2, 4)); assertArrayEquals(new Object[] {1, 2, 3, 4}, insert(src, 3, 4)); assertArrayEquals(new Object[] {"a"}, insert(EMPTY_OBJECT_ARRAY, 0, "a")); assertArrayEquals(new Object[] {null}, insert(EMPTY_OBJECT_ARRAY, 0, null)); } @Test public void test_insert_result_type_is_object_array() { assertSame(Object[].class, insert(new Integer[] {1, 2, 3}, 3, 4).getClass()); } @Test(expected = NullPointerException.class) public void test_insert_null() { insert(null, 0, null); } @Test(expected = ArrayIndexOutOfBoundsException.class) public void test_insert_out_of_bounds_low() { insert(EMPTY_OBJECT_ARRAY, -1, "a"); } @Test(expected = ArrayIndexOutOfBoundsException.class) public void test_insert_out_of_bounds_high() { insert(EMPTY_OBJECT_ARRAY, 1, "a"); }
### Question: GrainGenerator implements Callable<Void> { public static void main(String[] args) throws Exception { Thread.currentThread().setName("main"); Configuration config = new Configuration(); config.setOutput(Paths.get(args[0])); config.setSearchPackages(asSet(Arrays.asList(args).subList(1, args.length))); new GrainGenerator(config).call(); Thread.sleep(10); } GrainGenerator(Configuration configuration); @Override Void call(); static void main(String[] args); }### Answer: @Ignore @Test public void test_generator_driver() throws Exception { GrainGenerator.main( new String[] { System.getProperty("user.home") + "/code/grains/generate/src/test/java", "net.nullschool.grains.generate.model"}); }
### Question: BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); }### Answer: @Test public void test_replace() { Integer[] src = new Integer[] {1, 2, 3}; assertArrayEquals(new Object[] {9, 2, 3}, replace(src, 0, 9)); assertArrayEquals(new Object[] {1, 9, 3}, replace(src, 1, 9)); assertArrayEquals(new Object[] {1, 2, 9}, replace(src, 2, 9)); assertEquals(Object[].class, replace(src, 0, 1).getClass()); } @Test(expected = IndexOutOfBoundsException.class) public void test_replace_out_of_bounds_low() { replace(EMPTY_OBJECT_ARRAY, -1, null); } @Test(expected = IndexOutOfBoundsException.class) public void test_replace_out_of_bounds_high() { replace(EMPTY_OBJECT_ARRAY, 0, null); } @Test(expected = NullPointerException.class) public void test_replace_null() { replace(null, 0, null); }
### Question: SimpleNameWriter extends TypeWriter { @Override protected TypePrinter apply(Class<?> clazz, Type enclosing) { return printer.print(clazz); } SimpleNameWriter(); }### Answer: @Test public void test_parameterized_type() { Type type = new TypeToken<Set<Map.Entry<Map.Entry, Integer>>>(){}.asType(); assertEquals("Set<Map.Entry<Map.Entry, Integer>>", TypeTools.print(type, new SimpleNamePrinter())); assertEquals("Set<Entry<Entry, Integer>>", new SimpleNameWriter().apply(type).toString()); }
### Question: BasicTools { static Object[] delete(Object[] original, int index) { final int resultLength = original.length - 1; Object[] result = new Object[resultLength]; System.arraycopy(original, 0, result, 0, index); System.arraycopy(original, index + 1, result, index, resultLength - index); return result; } private BasicTools(); }### Answer: @Test public void test_delete() { Integer[] src = new Integer[] {1, 2, 3, 4}; assertArrayEquals(new Object[] {2, 3, 4}, delete(src, 0)); assertArrayEquals(new Object[] {1, 3, 4}, delete(src, 1)); assertArrayEquals(new Object[] {1, 2, 4}, delete(src, 2)); assertArrayEquals(new Object[] {1, 2, 3}, delete(src, 3)); assertArrayEquals(EMPTY_OBJECT_ARRAY, delete(new Object[] {"a"}, 0)); assertArrayEquals(EMPTY_OBJECT_ARRAY, delete(new Object[] {null}, 0)); } @Test public void test_delete_result_type_is_object_array() { assertSame(Object[].class, delete(new Integer[] {1, 2, 3}, 1).getClass()); } @Test(expected = ArrayIndexOutOfBoundsException.class) public void test_delete_out_of_bounds_low() { delete(new Object[] {"a"}, -1); } @Test(expected = ArrayIndexOutOfBoundsException.class) public void test_delete_out_of_bounds_high() { delete(new Object[] {"a"}, 1); } @Test(expected = NegativeArraySizeException.class) public void test_delete_out_of_bounds() { delete(EMPTY_OBJECT_ARRAY, 0); } @Test(expected = NullPointerException.class) public void test_delete_null() { delete(null, 0); }
### Question: BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> without(Object key) { return !containsKey(key) ? this : BasicCollections.<K, V>emptySortedMap(comparator); } @SuppressWarnings("unchecked") BasicSortedMap1(Comparator<? super K> comparator, Object k0, Object v0); @Override int size(); @Override boolean isEmpty(); @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 int hashCode(); }### Answer: @Test public void test_without() { ConstSortedMap<Object, Object> map; map = new BasicSortedMap1<>(null, "a", 1); compare_sorted_maps(BasicSortedMap0.instance(null), map.without("a")); assertSame(map, map.without("b")); map = new BasicSortedMap1<>(reverseOrder(), "a", 1); compare_sorted_maps(BasicSortedMap0.instance(reverseOrder()), map.without("a")); assertSame(map, map.without("b")); }
### Question: BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override K getKey(int index) { if (index == 0) { return k0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSortedMap1(Comparator<? super K> comparator, Object k0, Object v0); @Override int size(); @Override boolean isEmpty(); @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 int hashCode(); }### Answer: @Test public void test_get_key() { assertEquals("a", new BasicSortedMap1<>(null, "a", 1).getKey(0)); } @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_key() { new BasicSortedMap1<>(null, "a", 1).getKey(1); }
### Question: BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override V getValue(int index) { if (index == 0) { return v0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSortedMap1(Comparator<? super K> comparator, Object k0, Object v0); @Override int size(); @Override boolean isEmpty(); @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 int hashCode(); }### Answer: @Test public void test_get_value() { assertEquals(1, new BasicSortedMap1<>(null, "a", 1).getValue(0)); } @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_value() { new BasicSortedMap1<>(null, "a", 1).getValue(1); }
### Question: BasicConstList extends AbstractList<E> implements ConstList<E>, RandomAccess, Serializable { @Deprecated @Override public final boolean add(E e) { throw unsupported(); } BasicConstList(); @Override Iterator<E> iterator(); @Override ListIterator<E> listIterator(int start); @Override abstract ConstList<E> subList(int fromIndex, int toIndex); @Deprecated @Override final boolean add(E e); @Deprecated @Override final void add(int index, E element); @Deprecated @Override final boolean addAll(Collection<? extends E> c); @Deprecated @Override final boolean addAll(int index, Collection<? extends E> c); @Deprecated @Override final E set(int index, E element); @Deprecated @Override final boolean retainAll(Collection<?> c); @Deprecated @Override final boolean remove(Object o); @Deprecated @Override final E remove(int index); @Deprecated @Override final boolean removeAll(Collection<?> c); @Deprecated @Override final void clear(); }### Answer: @Test public void test_publicInterfaceRef_annotation_present() { Collection<Integer> elements = new ArrayList<>(); for (int i = 0; i < 15; i++) { assertSame( BasicConstList.class, asList(elements).getClass().getAnnotation(PublicInterfaceRef.class).value()); elements.add(i); } }
### Question: BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { @Override public Comparator<? super K> comparator() { return comparator; } BasicConstSortedMap(Comparator<? super K> comparator); @Override Comparator<? super K> comparator(); @Override abstract ConstSortedSet<K> keySet(); @Override abstract ConstCollection<V> values(); @Override abstract ConstSet<Map.Entry<K, V>> entrySet(); }### Answer: @Test public void test_emptySortedMap() { assertSame(BasicSortedMap0.instance(null), emptySortedMap(null)); Comparator<Object> reverse = reverseOrder(); assertSame(BasicSortedSet0.instance(reverse).comparator(), emptySortedMap(reverse).comparator()); }
### Question: BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Deprecated @Override public final boolean add(E e) { throw unsupported(); } BasicConstSet(); @Override Iterator<E> iterator(); @Deprecated @Override final boolean add(E e); @Deprecated @Override final boolean addAll(Collection<? extends E> c); @Deprecated @Override final boolean remove(Object o); @Deprecated @Override final boolean removeAll(Collection<?> c); @Deprecated @Override final boolean retainAll(Collection<?> c); @Deprecated @Override final void clear(); }### Answer: @Test public void test_publicInterfaceRef_annotation_present() { Collection<Integer> elements = new ArrayList<>(); for (int i = 0; i < 15; i++) { assertSame( BasicConstSet.class, asSet(elements).getClass().getAnnotation(PublicInterfaceRef.class).value()); elements.add(i); } }
### Question: BasicListN extends BasicConstList<E> { @Override public ConstList<E> replace(int index, E e) { return new BasicListN<>(BasicTools.replace(elements, index, e)); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override E get(int index); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstList<E> with(E e); @Override ConstList<E> with(int index, E e); @Override ConstList<E> withAll(Collection<? extends E> c); @Override ConstList<E> withAll(int index, Collection<? extends E> c); @Override ConstList<E> replace(int index, E e); @Override ConstList<E> without(Object o); @Override ConstList<E> delete(int index); @Override ConstList<E> withoutAll(Collection<?> c); @Override ConstList<E> subList(int fromIndex, int toIndex); @Override int hashCode(); }### Answer: @Test public void test_replace() { ConstList<Integer> list = new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}); compare_lists(Arrays.asList(9, 2, 3, 4, 5, 6), list.replace(0, 9)); compare_lists(Arrays.asList(1, 2, 3, 9, 5, 6), list.replace(3, 9)); compare_lists(Arrays.asList(1, 2, 3, 4, 5, 9), list.replace(5, 9)); } @Test(expected = IndexOutOfBoundsException.class) public void test_replace_out_of_bounds() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).replace(6, 9); }
### Question: BasicListN extends BasicConstList<E> { @Override public ConstList<E> without(Object o) { int index = ArrayTools.indexOf(o, elements); return index < 0 ? this : delete(index); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override E get(int index); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstList<E> with(E e); @Override ConstList<E> with(int index, E e); @Override ConstList<E> withAll(Collection<? extends E> c); @Override ConstList<E> withAll(int index, Collection<? extends E> c); @Override ConstList<E> replace(int index, E e); @Override ConstList<E> without(Object o); @Override ConstList<E> delete(int index); @Override ConstList<E> withoutAll(Collection<?> c); @Override ConstList<E> subList(int fromIndex, int toIndex); @Override int hashCode(); }### Answer: @Test public void test_without() { ConstList<Integer> list = new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6, 1}); compare_lists(Arrays.asList(2, 3, 4, 5, 6, 1), list.without(1)); compare_lists(Arrays.asList(1, 3, 4, 5, 6, 1), list.without(2)); assertSame(list, list.without(7)); assertSame(list, list.without(null)); }
### Question: BasicListN extends BasicConstList<E> { @Override public ConstList<E> delete(int index) { return condenseToList(BasicTools.delete(elements, index)); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override E get(int index); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstList<E> with(E e); @Override ConstList<E> with(int index, E e); @Override ConstList<E> withAll(Collection<? extends E> c); @Override ConstList<E> withAll(int index, Collection<? extends E> c); @Override ConstList<E> replace(int index, E e); @Override ConstList<E> without(Object o); @Override ConstList<E> delete(int index); @Override ConstList<E> withoutAll(Collection<?> c); @Override ConstList<E> subList(int fromIndex, int toIndex); @Override int hashCode(); }### Answer: @Test public void test_delete() { ConstList<Integer> list = new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}); compare_lists(Arrays.asList(2, 3, 4, 5, 6), list.delete(0)); compare_lists(Arrays.asList(1, 2, 3, 5, 6), list.delete(3)); compare_lists(Arrays.asList(1, 2, 3, 4, 5), list.delete(5)); } @Test(expected = IndexOutOfBoundsException.class) public void test_delete_out_of_bounds() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).delete(6); }
### Question: BasicListN extends BasicConstList<E> { @Override public ConstList<E> subList(int fromIndex, int toIndex) { return condenseToList(Arrays.copyOfRange(elements, fromIndex, toIndex)); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override E get(int index); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override ConstList<E> with(E e); @Override ConstList<E> with(int index, E e); @Override ConstList<E> withAll(Collection<? extends E> c); @Override ConstList<E> withAll(int index, Collection<? extends E> c); @Override ConstList<E> replace(int index, E e); @Override ConstList<E> without(Object o); @Override ConstList<E> delete(int index); @Override ConstList<E> withoutAll(Collection<?> c); @Override ConstList<E> subList(int fromIndex, int toIndex); @Override int hashCode(); }### Answer: @Test public void test_subList() { ConstList<Integer> list = new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}); assertSame(BasicList0.instance(), list.subList(0, 0)); assertSame(BasicList0.instance(), list.subList(6, 6)); }
### Question: 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(); }### Answer: @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get() { new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}).get(7); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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())); } @Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}).withAll(null); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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)); } @Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}).withoutAll(null); }
### Question: 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(); }### Answer: @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get() { new BasicSetN<>(new Object[] {1, 2, 3, 4, 5, 6}).get(7); }
### Question: 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(); }### Answer: @Test public void test_comparison() { compare_sets(Collections.emptySet(), BasicSet0.instance()); } @Test public void test_immutable() { assert_set_immutable(BasicSet0.instance()); } @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()); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @Test public void test_comparison() { compare_maps(Collections.emptyMap(), BasicMap0.instance()); } @Test public void test_immutable() { assert_map_immutable(BasicMap0.instance()); } @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()); }
### Question: 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(); }### Answer: @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); } }
### Question: 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); }### Answer: @Test public void test_factoryFor() { assertSame(MockGrainFactory.INSTANCE, factoryFor(MockGrain.class)); assertSame(MockGrainFactory.INSTANCE, factoryFor(MockGrainFactory.class)); assertSame(MyFactory.FACTORY, factoryFor(MyFactory.class)); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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())); } @Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSet1<>(1).withAll(null); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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())); } @Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSet1<>(1).withoutAll(null); }
### Question: 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(); }### Answer: @Test public void test_get() { assertEquals(1, new BasicSet1<>(1).get(0)); } @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get() { new BasicSet1<>(1).get(1); }
### Question: 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; }### Answer: @Test(expected = IllegalArgumentException.class) public void test_bad_mapping_not_related() { ConfigurableTypePolicy.EMPTY.withImmutableMapping(Set.class, ConstMap.class); } @Test(expected = IllegalArgumentException.class) public void test_bad_mapping_not_narrowing() { ConfigurableTypePolicy.EMPTY.withImmutableMapping(ConstSet.class, Set.class); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @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()); }
### Question: 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); }### Answer: @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()); } @Test(expected = NullPointerException.class) public void test_bad_interleave() { interleave(new String[] {}, null); } @Test(expected = NullPointerException.class) public void test_bad_interleave_2() { interleave(null, new Integer[] {}); }
### Question: 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); }### Answer: @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) {} }
### Question: 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); }### Answer: @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) {} }
### Question: 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); }### Answer: @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()); }
### Question: 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); }### Answer: @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); } @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); }
### Question: 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(); }### Answer: @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())); }
### Question: ArrayTools { public static <T> int lastIndexOf(T element, T[] array) { if (element == null) { for (int i = array.length - 1; i >= 0; i--) { if (array[i] == null) { return i; } } } else { for (int i = array.length - 1; i >= 0; 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; }### Answer: @Test public void test_lastIndexOf() { Integer[] ary = new Integer[] {10, 11, 12, 13, null, 10, 11, 12, 13, null}; assertEquals(9, lastIndexOf(null, ary)); assertEquals(6, lastIndexOf(11, ary)); assertEquals(-1, lastIndexOf(42, ary)); assertEquals(-1, lastIndexOf(null, new Integer[] {1, 2, 3})); } @Test(expected = NullPointerException.class) public void test_lastIndexOf_illegal_arg() { lastIndexOf(10, null); }
### Question: ArrayTools { public static void checkRange(int fromIndex, int toIndex, int length) { if (fromIndex < 0 \|\| toIndex > length) { throw new IndexOutOfBoundsException( String.format("range [%d, %d) is outside bounds [%d, %d)", fromIndex, toIndex, 0, length)); } if (fromIndex > toIndex) { throw new IllegalArgumentException( String.format("fromIndex %d cannot be greater than toIndex %d", fromIndex, toIndex)); } } 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; }### Answer: @Test public void test_check_range() { checkRange(0, 0, 2); checkRange(0, 2, 2); checkRange(2, 2, 2); try { checkRange(-1, 2, 2); fail(); } catch (IndexOutOfBoundsException ignored) {} try { checkRange( 0, 3, 2); fail(); } catch (IndexOutOfBoundsException ignored) {} try { checkRange( 7, 6, 2); fail(); } catch (IndexOutOfBoundsException ignored) {} try { checkRange( 1, 0, 2); fail(); } catch (IllegalArgumentException ignored) {} }
### Question: ArrayTools { public static <T> T[] sort(T[] a) { Arrays.sort(a); return a; } 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; }### Answer: @Test public void test_sort() { Integer[] a = new Integer[] {3, 2, 1}; assertArrayEquals(new Integer[] {1, 2, 3}, sort(a)); assertSame(a, sort(a)); } @Test(expected = NullPointerException.class) public void test_sort_nulls() { Integer[] a = new Integer[] {null, null}; sort(a); } @Test public void test_sort_comparator() { Integer[] a = new Integer[] {2, 1, 3}; assertArrayEquals(new Integer[] {1, 2, 3}, sort(a, null)); assertSame(a, sort(a, null)); assertArrayEquals(new Integer[] {3, 2, 1}, sort(a, Collections.reverseOrder())); assertSame(a, sort(a, Collections.reverseOrder())); } @Test(expected = NullPointerException.class) public void test_sort_comparator_nulls() { String[] a = new String[] {null, null}; sort(a, String.CASE_INSENSITIVE_ORDER); }
### Question: ThreadTools { public static ThreadFactory newDaemonThreadFactory(final ThreadFactory wrapped) { Objects.requireNonNull(wrapped); return new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread t = wrapped.newThread(r); if (!t.isDaemon()) { t.setDaemon(true); } return t; } }; } private ThreadTools(); static ThreadFactory newDaemonThreadFactory(final ThreadFactory wrapped); static ThreadFactory newNamingThreadFactory(final String format, final ThreadFactory wrapped); static ThreadFactory newContextThreadFactory(final ClassLoader classLoader, final ThreadFactory wrapped); }### Answer: @Test public void test_daemon_thread_factory() { Runnable r = mock(Runnable.class); Thread thread = new Thread(r); thread.setDaemon(false); ThreadFactory factory = mock(ThreadFactory.class); when(factory.newThread(any(Runnable.class))).thenReturn(thread); assertSame(thread, newDaemonThreadFactory(factory).newThread(r)); assertTrue(thread.isDaemon()); verify(factory).newThread(r); }
### Question: ThreadTools { public static ThreadFactory newNamingThreadFactory(final String format, final ThreadFactory wrapped) { String.format(format, 0, "test name"); Objects.requireNonNull(wrapped); final AtomicInteger threadNumber = new AtomicInteger(0); return new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread t = wrapped.newThread(r); t.setName(String.format(format, threadNumber.getAndIncrement(), t.getName())); return t; } }; } private ThreadTools(); static ThreadFactory newDaemonThreadFactory(final ThreadFactory wrapped); static ThreadFactory newNamingThreadFactory(final String format, final ThreadFactory wrapped); static ThreadFactory newContextThreadFactory(final ClassLoader classLoader, final ThreadFactory wrapped); }### Answer: @Test public void test_naming_thread_factory() { Runnable r = mock(Runnable.class); Thread thread = new Thread(r); thread.setName("Foo"); ThreadFactory factory = mock(ThreadFactory.class); when(factory.newThread(any(Runnable.class))).thenReturn(thread); assertSame(thread, newNamingThreadFactory("#%d %s", factory).newThread(r)); assertEquals("#0 Foo", thread.getName()); verify(factory).newThread(r); }
### Question: ThreadTools { public static ThreadFactory newContextThreadFactory(final ClassLoader classLoader, final ThreadFactory wrapped) { Objects.requireNonNull(wrapped); return new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread t = wrapped.newThread(r); t.setContextClassLoader(classLoader); return t; } }; } private ThreadTools(); static ThreadFactory newDaemonThreadFactory(final ThreadFactory wrapped); static ThreadFactory newNamingThreadFactory(final String format, final ThreadFactory wrapped); static ThreadFactory newContextThreadFactory(final ClassLoader classLoader, final ThreadFactory wrapped); }### Answer: @Test public void test_context_thread_factory() { Runnable r = mock(Runnable.class); Thread thread = new Thread(r); ThreadFactory factory = mock(ThreadFactory.class); when(factory.newThread(any(Runnable.class))).thenReturn(thread); ClassLoader cl = new URLClassLoader(new URL[] {}); assertSame(thread, newContextThreadFactory(cl, factory).newThread(r)); assertSame(cl, thread.getContextClassLoader()); verify(factory).newThread(r); }
### Question: StringTools { public static String capitalize(String s) { return s == null \|\| s.isEmpty() ? s : s.substring(0, 1).toUpperCase(Locale.ENGLISH) + s.substring(1); } private StringTools(); static String capitalize(String s); }### Answer: @Test public void test_capitalize() { assertEquals("HellO", capitalize("hellO")); assertEquals("HellO", capitalize("HellO")); assertEquals("A", capitalize("a")); assertEquals("", capitalize("")); assertNull(capitalize(null)); }
### Question: ObjectTools { public static <T> T coalesce(T x, T y) { return x != null ? x : y; } private ObjectTools(); static T coalesce(T x, T y); static int compare(T left, T right, Comparator<? super T> comparator); }### Answer: @Test public void test_coalesce() { Object x = new Object(); Object y = new Object(); assertSame(x, coalesce(x, y)); assertSame(x, coalesce(x, null)); assertNull(coalesce(null, null)); assertSame(y, coalesce(null, y)); }
### Question: ObjectTools { public static <T> int compare(T left, T right, Comparator<? super T> comparator) { if (comparator == null) { @SuppressWarnings("unchecked") Comparable<T> leftComparable = (Comparable<T>)left; return leftComparable.compareTo(right); } return comparator.compare(left, right); } private ObjectTools(); static T coalesce(T x, T y); static int compare(T left, T right, Comparator<? super T> comparator); }### Answer: @Test public void test_compare() { assertEquals( 0, compare(1, 1, null)); assertEquals(-1, compare(0, 1, null)); assertEquals( 1, compare(1, 0, null)); assertEquals( 0, compare(1, 1, Collections.reverseOrder())); assertEquals( 1, compare(0, 1, Collections.reverseOrder())); assertEquals(-1, compare(1, 0, Collections.reverseOrder())); } @Test public void test_compare_nulls() { @SuppressWarnings("unchecked") Comparator<Object> c = (Comparator<Object>)mock(Comparator.class); when(c.compare(any(), any())).thenReturn(5); assertEquals(5, compare(null, null, c)); } @Test(expected = NullPointerException.class) public void test_natural_compare_nulls() { compare(null, 5, null); } @Test(expected = ClassCastException.class) public void test_compare_not_comparable() { compare(int.class, int.class, null); }
### Question: LateTypeVariable implements TypeVariable<D> { @Override public Type[] getBounds() { if (bounds != null) { return bounds.clone(); } throw new IllegalStateException("bounds have not yet been assigned"); } LateTypeVariable(String name, D genericDeclaration, Type... bounds); static LateTypeVariable<D> copyOf(TypeVariable<D> tv); @Override String getName(); @Override D getGenericDeclaration(); @Override Type[] getBounds(); synchronized void assignBounds(Type... bounds); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void test_recursive_type_variable() { compare(MY_ENUM.getE(), new LateTypeVariable<Class>("E", MyEnum.class, MY_ENUM.getE().getBounds()[0])); }
### Question: TypeToken { @Override public final int hashCode() { return type.hashCode(); } protected TypeToken(); final Type asType(); final T asNull(); @Override final boolean equals(Object that); @Override final int hashCode(); @Override final String toString(); }### Answer: @Test public void test_equality() { TypeToken<Set<String>> setOfString1 = new TypeToken<Set<String>>(){}; TypeToken<Set<String>> setOfString2 = new TypeToken<Set<String>>(){}; TypeToken<Set<Long>> setOfLong = new TypeToken<Set<Long>>(){}; assertEquals(setOfString1, setOfString2); assertEquals(setOfString1.hashCode(), setOfString2.hashCode()); assertNotEquals(setOfString1, setOfLong); assertNotEquals(setOfString1.hashCode(), setOfLong.hashCode()); assertNotEquals(setOfString1, new Object()); }
### Question: TypeToken { public final T asNull() { return null; } protected TypeToken(); final Type asType(); final T asNull(); @Override final boolean equals(Object that); @Override final int hashCode(); @Override final String toString(); }### Answer: @Test public void test_typed_null() { TypeToken<Long> token = new TypeToken<Long>(){}; assertEquals(42, invoke(token.asNull())); }
### Question: LateParameterizedType implements ParameterizedType { @Override public String toString() { return print(this); } LateParameterizedType(Type rawType, Type ownerType, Type... actualTypeArguments); static LateParameterizedType copyOf(ParameterizedType pt); @Override Class<?> getRawType(); @Override Type getOwnerType(); @Override Type[] getActualTypeArguments(); Type resolve(Type type); Type[] resolve(Type[] types); Type getSuperclass(); Type[] getInterfaces(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void test_nested_print() { assertEquals( "net.nullschool.reflect.Outer<java.lang.Short>.Inner1<java.lang.Integer>.Inner2<java.lang.Long>", new TypeToken<Outer<Short>.Inner1<Integer>.Inner2<Long>>(){}.asType().toString()); assertEquals( "net.nullschool.reflect.Outer.$Inner3<java.lang.Integer>", new TypeToken<Outer.$Inner3<Integer>>(){}.asType().toString()); assertEquals( "net.nullschool.reflect.Outer.$Inner3<java.lang.Integer>.$Inner4<java.lang.Long>", new TypeToken<Outer.$Inner3<Integer>.$Inner4<Long>>(){}.asType().toString()); }
### Question: LateParameterizedType implements ParameterizedType { public Type getSuperclass() { return resolve(rawType.getGenericSuperclass()); } LateParameterizedType(Type rawType, Type ownerType, Type... actualTypeArguments); static LateParameterizedType copyOf(ParameterizedType pt); @Override Class<?> getRawType(); @Override Type getOwnerType(); @Override Type[] getActualTypeArguments(); Type resolve(Type type); Type[] resolve(Type[] types); Type getSuperclass(); Type[] getInterfaces(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void test_superclass() { LateParameterizedType lpc = new LateParameterizedType(ArrayList.class, null, Long.class); compare( new JavaToken<AbstractList<Long>>(){}.asParameterizedType(), lpc = (LateParameterizedType)lpc.getSuperclass()); compare( new JavaToken<AbstractCollection<Long>>(){}.asParameterizedType(), lpc = (LateParameterizedType)lpc.getSuperclass()); assertSame(Object.class, lpc.getSuperclass()); LateParameterizedType listOfLong = new LateParameterizedType(List.class, null, Long.class); assertNull(listOfLong.getSuperclass()); }
### Question: LateParameterizedType implements ParameterizedType { public Type[] getInterfaces() { return resolve(rawType.getGenericInterfaces()); } LateParameterizedType(Type rawType, Type ownerType, Type... actualTypeArguments); static LateParameterizedType copyOf(ParameterizedType pt); @Override Class<?> getRawType(); @Override Type getOwnerType(); @Override Type[] getActualTypeArguments(); Type resolve(Type type); Type[] resolve(Type[] types); Type getSuperclass(); Type[] getInterfaces(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void test_interfaces() { LateParameterizedType lpc = new LateParameterizedType(ArrayList.class, null, Long.class); Type[] result = lpc.getInterfaces(); assertEquals(4, result.length); compare(new JavaToken<List<Long>>(){}.asParameterizedType(), lpc = (LateParameterizedType)result[0]); assertSame(RandomAccess.class, result[1]); assertSame(Cloneable.class, result[2]); assertSame(Serializable.class, result[3]); result = lpc.getInterfaces(); assertEquals(1, result.length); compare(new JavaToken<Collection<Long>>(){}.asParameterizedType(), lpc = (LateParameterizedType)result[0]); result = lpc.getInterfaces(); assertEquals(1, result.length); compare(new JavaToken<Iterable<Long>>(){}.asParameterizedType(), lpc = (LateParameterizedType)result[0]); result = lpc.getInterfaces(); assertEquals(0, result.length); }
### Question: TypeTools { public static Class<?> buildArrayType(Class<?> componentType) { return Array.newInstance(componentType, 0).getClass(); } private TypeTools(); static boolean isInnerClass(Class<?> clazz); static Class<?> buildArrayType(Class<?> componentType); static Class<?> erase(Type type); static String print(Type type); static String print(Type type, TypePrinter printer); static Type[] apply(TypeOperator<? extends Type> operator, Type[] types); static Class<?> publicInterfaceOf(Class<?> type); }### Answer: @Test public void test_buildArrayType() { assertSame(int[].class, buildArrayType(int.class)); assertSame(int[][].class, buildArrayType(int[].class)); assertSame(Integer[].class, buildArrayType(Integer.class)); assertSame(Map[].class, buildArrayType(Map.class)); }
### Question: TypeTools { public static Class<?> erase(Type type) { return Eraser.INSTANCE.apply(type); } private TypeTools(); static boolean isInnerClass(Class<?> clazz); static Class<?> buildArrayType(Class<?> componentType); static Class<?> erase(Type type); static String print(Type type); static String print(Type type, TypePrinter printer); static Type[] apply(TypeOperator<? extends Type> operator, Type[] types); static Class<?> publicInterfaceOf(Class<?> type); }### Answer: @Test public void test_erasure() { assertSame(int.class, erase(int.class)); assertSame(Object.class, erase(Object.class)); assertSame(Object[].class, erase(Object[].class)); assertSame(Set[].class, erase(new JavaToken<Set<?>[]>(){}.asGenericArrayType())); assertSame(Object.class, erase(new JavaToken<Set<?>>(){}.asWildcardType())); assertSame(Object.class, erase(new JavaToken<Set<? super Comparable>>(){}.asWildcardType())); assertSame(Comparable.class, erase(new JavaToken<Set<? extends Comparable>>(){}.asWildcardType())); assertSame(Map.class, erase(new LateWildcardType("? extends", Map.class, HashMap.class))); assertSame(Set.class, erase(new JavaToken<Set<Integer>>(){}.asParameterizedType())); assertSame(Set.class, erase(new JavaToken<Set<?>>(){}.asParameterizedType())); assertSame(Object.class, erase(new LateTypeVariable<Class>("E", Set.class))); assertSame(Map.class, erase(new LateTypeVariable<Class>("E", Set.class, Map.class))); assertSame(Map.class, erase(new LateTypeVariable<Class>("E", Set.class, Map.class, HashMap.class))); assertNull(erase(null)); try { erase(new Type(){}); fail(); } catch (IllegalArgumentException expected) {} }
### Question: TypeTools { public static String print(Type type) { return print(type, new FullNamePrinter()); } private TypeTools(); static boolean isInnerClass(Class<?> clazz); static Class<?> buildArrayType(Class<?> componentType); static Class<?> erase(Type type); static String print(Type type); static String print(Type type, TypePrinter printer); static Type[] apply(TypeOperator<? extends Type> operator, Type[] types); static Class<?> publicInterfaceOf(Class<?> type); }### Answer: @Test public void test_print() { assertEquals("java.util.List", print(List.class)); assertEquals("java.util.List[]", print(List[].class)); assertEquals( "java.util.List<? extends java.lang.Integer>", print(new JavaToken<List<? extends Integer>>(){}.asType())); assertEquals( "java.util.List<? extends java.lang.Integer>[][]", print(new JavaToken<List<? extends Integer>[][]>(){}.asType())); assertEquals("java.util.Map.Entry", print(Map.Entry.class)); assertEquals("int", print(int.class)); assertEquals("int[]", print(int[].class)); } @Test public void test_print_with_custom_printer() { assertEquals("~List", print(List.class, new PrependTildePrinter())); assertEquals("~List[]", print(List[].class, new PrependTildePrinter())); assertEquals( "~List<? extends ~Integer>", print(new JavaToken<List<? extends Integer>>(){}.asType(), new PrependTildePrinter())); assertEquals( "~List<? extends ~Integer>[][]", print(new JavaToken<List<? extends Integer>[][]>(){}.asType(), new PrependTildePrinter())); assertEquals("~Map.Entry", print(Map.Entry.class, new PrependTildePrinter())); assertEquals("~int", print(int.class, new PrependTildePrinter())); assertEquals("~int[]", print(int[].class, new PrependTildePrinter())); }
### Question: TypeTools { public static Type[] apply(TypeOperator<? extends Type> operator, Type[] types) { Type[] result = types.length > 0 ? new Type[types.length] : types; for (int i = 0; i < types.length; i++) { result[i] = operator.apply(types[i]); } return result; } private TypeTools(); static boolean isInnerClass(Class<?> clazz); static Class<?> buildArrayType(Class<?> componentType); static Class<?> erase(Type type); static String print(Type type); static String print(Type type, TypePrinter printer); static Type[] apply(TypeOperator<? extends Type> operator, Type[] types); static Class<?> publicInterfaceOf(Class<?> type); }### Answer: @Test public void test_apply() { @SuppressWarnings("unchecked") TypeOperator<Type> operator = (TypeOperator<Type>)mock(TypeOperator.class); when(operator.apply((Type)String.class)).thenReturn(Character.class); when(operator.apply((Type)Integer.class)).thenReturn(Byte.class); Type[] result = apply(operator, new Type[] {String.class, Integer.class}); assertArrayEquals(new Type[] {Character.class, Byte.class}, result); }
### Question: TypeTools { static Type copyOf(Type type) { return LateTypeConverter.INSTANCE.apply(type); } private TypeTools(); static boolean isInnerClass(Class<?> clazz); static Class<?> buildArrayType(Class<?> componentType); static Class<?> erase(Type type); static String print(Type type); static String print(Type type, TypePrinter printer); static Type[] apply(TypeOperator<? extends Type> operator, Type[] types); static Class<?> publicInterfaceOf(Class<?> type); }### Answer: @Test public void test_copyOf() { assertEquals(Class.class, copyOf(Object.class).getClass()); assertEquals(LateParameterizedType.class, copyOf(new JavaToken<Set<Byte>>(){}.asParameterizedType()).getClass()); assertEquals(LateGenericArrayType.class, copyOf(new JavaToken<Set<Byte>[]>(){}.asGenericArrayType()).getClass()); assertEquals(LateWildcardType.class, copyOf(new JavaToken<Set<?>>(){}.asWildcardType()).getClass()); }
### Question: LateWildcardType implements WildcardType { @Override public String toString() { return print(this); } private LateWildcardType(Type[] upperBounds, Type[] lowerBounds); LateWildcardType(String keyword, Type... bounds); static LateWildcardType copyOf(WildcardType wt); @Override Type[] getUpperBounds(); @Override Type[] getLowerBounds(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void test_extra_linguistic_wildcard_bounds() { assertEquals( "? extends java.io.Serializable & java.lang.Comparable", new LateWildcardType("? extends", Serializable.class, Comparable.class).toString()); assertEquals( "? extends java.lang.Class & java.lang.Class", new LateWildcardType("? extends", Class.class, Class.class).toString()); assertEquals( "? super java.io.Serializable & java.lang.Comparable", new LateWildcardType("? super", Serializable.class, Comparable.class).toString()); }
### Question: AbstractTypeOperator implements TypeOperator<T> { @Override public T apply(Type type) { if (type instanceof Class) { return apply((Class<?>)type); } else if (type instanceof ParameterizedType) { return apply((ParameterizedType)type); } else if (type instanceof WildcardType) { return apply((WildcardType)type); } else if (type instanceof GenericArrayType) { return apply((GenericArrayType)type); } else if (type instanceof TypeVariable) { return apply((TypeVariable<?>)type); } else if (type == null) { return null; } throw new IllegalArgumentException("Unsupported Type implementation: " + type.getClass()); } @Override T apply(Type type); }### Answer: @Test public void test_invoke() { TypeOperator<?> operator = mock(AbstractTypeOperator.class); given(operator.apply(any(Type.class))).willCallRealMethod(); operator.apply((Type)Object.class); operator.apply((Type)new LateParameterizedType(Set.class, null, Integer.class)); operator.apply((Type)new LateGenericArrayType(new LateTypeVariable<Class>("E", Set.class))); operator.apply((Type)new LateWildcardType("?")); operator.apply((Type)new LateTypeVariable<Class>("E", Set.class)); assertNull(operator.apply((Type)null)); verify(operator, times(1)).apply(any(Class.class)); verify(operator, times(1)).apply(any(ParameterizedType.class)); verify(operator, times(1)).apply(any(GenericArrayType.class)); verify(operator, times(1)).apply(any(WildcardType.class)); verify(operator, times(1)).apply(any(TypeVariable.class)); verify(operator, times(6)).apply(any(Type.class)); } @Test(expected = IllegalArgumentException.class) public void test_invoke_unknown() { TypeOperator<?> operator = mock(AbstractTypeOperator.class); given(operator.apply(any(Type.class))).willCallRealMethod(); operator.apply(new Type(){}); }
### Question: BasicList1 extends BasicConstList<E> { @Override public ConstList<E> with(E e) { return listOf(e0, e); } @SuppressWarnings("unchecked") BasicList1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override E get(int index); @Override Object[] toArray(); @Override ConstList<E> with(E e); @Override ConstList<E> with(int index, E e); @Override ConstList<E> withAll(Collection<? extends E> c); @Override ConstList<E> withAll(int index, Collection<? extends E> c); @Override ConstList<E> replace(int index, E e); @Override ConstList<E> without(Object o); @Override ConstList<E> delete(int index); @Override ConstList<E> withoutAll(Collection<?> c); @Override ConstList<E> subList(int fromIndex, int toIndex); @Override boolean equals(Object that); @Override int hashCode(); }### Answer: @Test public void test_with() { compare_lists(Arrays.asList(1, 1), new BasicList1<>(1).with(1)); compare_lists(Arrays.asList(1, null), new BasicList1<>(1).with(null)); } @Test public void test_with_index() { compare_lists(Arrays.asList(2, 1), new BasicList1<>(1).with(0, 2)); compare_lists(Arrays.asList(1, 2), new BasicList1<>(1).with(1, 2)); } @Test(expected = IndexOutOfBoundsException.class) public void test_with_index_out_of_bounds() { new BasicList1<>(1).with(2, 1); }
### Question: BasicList1 extends BasicConstList<E> { @Override public ConstList<E> replace(int index, E e) { if (index == 0) { return listOf(e); } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicList1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override E get(int index); @Override Object[] toArray(); @Override ConstList<E> with(E e); @Override ConstList<E> with(int index, E e); @Override ConstList<E> withAll(Collection<? extends E> c); @Override ConstList<E> withAll(int index, Collection<? extends E> c); @Override ConstList<E> replace(int index, E e); @Override ConstList<E> without(Object o); @Override ConstList<E> delete(int index); @Override ConstList<E> withoutAll(Collection<?> c); @Override ConstList<E> subList(int fromIndex, int toIndex); @Override boolean equals(Object that); @Override int hashCode(); }### Answer: @Test public void test_replace() { compare_lists(Collections.singletonList(9), new BasicList1<>(1).replace(0, 9)); } @Test(expected = IndexOutOfBoundsException.class) public void test_replace_out_of_bounds() { new BasicList1<>(1).replace(1, 1); }
### Question: BasicList1 extends BasicConstList<E> { @Override public ConstList<E> without(Object o) { return !contains(o) ? this : BasicCollections.<E>emptyList(); } @SuppressWarnings("unchecked") BasicList1(Object e0); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override E get(int index); @Override Object[] toArray(); @Override ConstList<E> with(E e); @Override ConstList<E> with(int index, E e); @Override ConstList<E> withAll(Collection<? extends E> c); @Override ConstList<E> withAll(int index, Collection<? extends E> c); @Override ConstList<E> replace(int index, E e); @Override ConstList<E> without(Object o); @Override ConstList<E> delete(int index); @Override ConstList<E> withoutAll(Collection<?> c); @Override ConstList<E> subList(int fromIndex, int toIndex); @Override boolean equals(Object that); @Override int hashCode(); }### Answer: @Test public void test_without() { ConstList<Integer> list = new BasicList1<>(1); assertSame(BasicList0.instance(), list.without(1)); assertSame(list, list.without(2)); assertSame(list, list.without(null)); }
### Question: EmailQueries { public ExecutionResult suspectBehaviour() { String query = "MATCH (bob:User {username:'Bob'})-[:SENT]->(email)-[:CC]->(alias),\n" + " (alias)-[:ALIAS_OF]->(bob)\n" + "RETURN email.id"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } EmailQueries( GraphDatabaseService db, ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult suspectBehaviour(); ExecutionResult suspectBehaviour2(); ExecutionResult suspectBehaviour3(); ExecutionResult lossyDb(); }### Answer: @Test public void suspectBehaviour() throws Exception { GraphDatabaseService db = createDatabase(); EmailQueries queries = new EmailQueries( db, new PrintingExecutionEngineWrapper( db, "email", name ) ); ExecutionResult result = queries.suspectBehaviour(); Iterator<Map<String, Object>> iterator = result.iterator(); Map<String, Object> next = iterator.next(); assertEquals( "1", next.get( "email.id" )); assertFalse( iterator.hasNext() ); db.shutdown(); }
### Question: EmailQueries { public ExecutionResult suspectBehaviour2() { String query = "MATCH p=(email:Email {id:'6'})<-[:REPLY_TO*1..4]-()<-[:SENT]-(replier)\n" + "RETURN replier.username AS replier, length(p) - 1 AS depth ORDER BY depth"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } EmailQueries( GraphDatabaseService db, ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult suspectBehaviour(); ExecutionResult suspectBehaviour2(); ExecutionResult suspectBehaviour3(); ExecutionResult lossyDb(); }### Answer: @Test public void suspectBehaviour2() throws Exception { GraphDatabaseService db = createDatabase2(); EmailQueries queries = new EmailQueries( db, new PrintingExecutionEngineWrapper( db, "email", name ) ); ExecutionResult result = queries.suspectBehaviour2(); Iterator<Map<String, Object>> iterator = result.iterator(); Map<String, Object> next = iterator.next(); assertEquals( 1L, next.get( "depth" ) ); assertEquals( "Davina", next.get( "replier" ) ); next = iterator.next(); assertEquals( 1L, next.get( "depth" ) ); assertEquals( "Bob", next.get( "replier" ) ); next = iterator.next(); assertEquals( 2L, next.get( "depth" ) ); assertEquals( "Charlie", next.get( "replier" ) ); next = iterator.next(); assertEquals( 3L, next.get( "depth" ) ); assertEquals( "Bob", next.get( "replier" ) ); assertFalse( iterator.hasNext() ); db.shutdown(); }
### Question: ShakespeareQueries { public ExecutionResult theatreCityBard() { String query = "MATCH (theater:Venue {name:'Theatre Royal'}), \n" + " (newcastle:City {name:'Newcastle'}), \n" + " (bard:Author {lastname:'Shakespeare'})\n" + "RETURN theater.name AS theater, newcastle.name AS city, bard.lastname AS bard"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } ShakespeareQueries( ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult theatreCityBard(); ExecutionResult allPlays(); ExecutionResult latePeriodPlays(); ExecutionResult orderedByPerformance(); ExecutionResult exampleOfWith(); }### Answer: @Test public void theatreCityBard() throws Exception { try ( Transaction tx = db.beginTx() ) { assertTheatreCityBard( queries.theatreCityBard() ); assertTheatreCityBard( queries2.theatreCityBard() ); assertTheatreCityBard( queriesUsingAutoIndexes.theatreCityBard() ); tx.success(); } }
### Question: EmailQueries { public ExecutionResult suspectBehaviour3() { String query = "MATCH (email:Email {id:'11'})<-[f:FORWARD_OF*]-() \n" + "RETURN count(f)"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } EmailQueries( GraphDatabaseService db, ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult suspectBehaviour(); ExecutionResult suspectBehaviour2(); ExecutionResult suspectBehaviour3(); ExecutionResult lossyDb(); }### Answer: @Test public void suspectBehaviour3() throws Exception { GraphDatabaseService db = createDatabase3(); EmailQueries queries = new EmailQueries( db, new PrintingExecutionEngineWrapper( db, "email", name ) ); ExecutionResult result = queries.suspectBehaviour3(); Iterator<Object> objectIterator = result.columnAs( "count(f)" ); assertEquals( 2L, objectIterator.next() ); assertFalse( objectIterator.hasNext() ); db.shutdown(); }
### Question: ShakespeareQueries { public ExecutionResult exampleOfWith() { String query = "MATCH (bard:Author {lastname:'Shakespeare'})\n" + "MATCH (bard)-[w:WROTE_PLAY]->(play)\n" + "WITH play \n" + "ORDER BY w.year DESC \n" + "RETURN collect(play.title) AS plays"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } ShakespeareQueries( ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult theatreCityBard(); ExecutionResult allPlays(); ExecutionResult latePeriodPlays(); ExecutionResult orderedByPerformance(); ExecutionResult exampleOfWith(); }### Answer: @Test public void exampleOfWith() throws Exception { try ( Transaction tx = db.beginTx() ) { assertExampleOfWith( queries.exampleOfWith() ); assertExampleOfWith( queries2.exampleOfWith() ); assertExampleOfWith( queriesUsingAutoIndexes.exampleOfWith() ); tx.success(); } }
### Question: ShakespeareQueries { public ExecutionResult allPlays() { String query = "MATCH (theater:Venue {name:'Theatre Royal'}), \n" + " (newcastle:City {name:'Newcastle'}), \n" + " (bard:Author {lastname:'Shakespeare'})\n" + "MATCH (newcastle)<-[:STREET\|CITY*1..2]-(theater)\n" + " <-[:VENUE]-()-[:PERFORMANCE_OF]->()-[:PRODUCTION_OF]->\n" + " (play)<-[:WROTE_PLAY]-(bard)\n" + "RETURN DISTINCT play.title AS play"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } ShakespeareQueries( ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult theatreCityBard(); ExecutionResult allPlays(); ExecutionResult latePeriodPlays(); ExecutionResult orderedByPerformance(); ExecutionResult exampleOfWith(); }### Answer: @Test public void shouldReturnAllPlays() throws Exception { try ( Transaction tx = db.beginTx() ) { assertAllPlays( queries.allPlays() ); assertAllPlays( queries2.allPlays() ); assertAllPlays( queriesUsingAutoIndexes.allPlays() ); } }
### Question: ShakespeareQueries { public ExecutionResult latePeriodPlays() { String query = "MATCH (theater:Venue {name:'Theatre Royal'}), \n" + " (newcastle:City {name:'Newcastle'}), \n" + " (bard:Author {lastname:'Shakespeare'})\n" + "MATCH (newcastle)<-[:STREET\|CITY*1..2]-(theater)<-[:VENUE]-()-[:PERFORMANCE_OF]->()\n" + " -[:PRODUCTION_OF]->(play)<-[w:WROTE_PLAY]-(bard)\n" + "WHERE w.year > 1608\n" + "RETURN DISTINCT play.title AS play"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } ShakespeareQueries( ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult theatreCityBard(); ExecutionResult allPlays(); ExecutionResult latePeriodPlays(); ExecutionResult orderedByPerformance(); ExecutionResult exampleOfWith(); }### Answer: @Test public void shouldReturnLatePeriodPlays() throws Exception { try ( Transaction tx = db.beginTx() ) { assertLatePeriodPlays( queries.latePeriodPlays() ); assertLatePeriodPlays( queries2.latePeriodPlays() ); assertLatePeriodPlays( queriesUsingAutoIndexes.latePeriodPlays() ); tx.success(); } }
### Question: ShakespeareQueries { public ExecutionResult orderedByPerformance() { String query = "MATCH (theater:Venue {name:'Theatre Royal'}), \n" + " (newcastle:City {name:'Newcastle'}), \n" + " (bard:Author {lastname:'Shakespeare'})\n" + "MATCH (newcastle)<-[:STREET\|CITY*1..2]-(theater)<-[:VENUE]-()-[p:PERFORMANCE_OF]->()\n" + " -[:PRODUCTION_OF]->(play)<-[:WROTE_PLAY]-(bard)\n" + "RETURN play.title AS play, count(p) AS performance_count \n" + "ORDER BY performance_count DESC"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } ShakespeareQueries( ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult theatreCityBard(); ExecutionResult allPlays(); ExecutionResult latePeriodPlays(); ExecutionResult orderedByPerformance(); ExecutionResult exampleOfWith(); }### Answer: @Test public void orderedByPerformance() throws Exception { try ( Transaction tx = db.beginTx() ) { assertOrderedByPerformance( queries.orderedByPerformance() ); assertOrderedByPerformance( queries2.orderedByPerformance() ); assertOrderedByPerformance( queriesUsingAutoIndexes.orderedByPerformance() ); tx.success(); } }
### Question: LogisticsQueries { public Iterable<Node> findShortestPathWithSimpleParcelRouteCalculator( String start, String end, Interval interval ) { return simpleParcelRouteCalculator.calculateRoute( start, end, interval ); } LogisticsQueries( GraphDatabaseService db, ExecutionEngineWrapper executionEngineWrapper ); Iterable<Node> findShortestPathWithParcelRouteCalculator( String start, String end, Interval interval ); Iterable<Node> findShortestPathWithSimpleParcelRouteCalculator( String start, String end, Interval interval ); ExecutionResult findShortestPathWithCypherReduce( String start, String end, Interval interval ); }### Answer: @Test public void parcelRoutingUsingSimpleParcelRouteCalculatorRespectsIntervals() throws Exception { DateTime startDtm = interval3.getStart().plusDays( 2 ); Interval queryInterval = new Interval( startDtm, startDtm.plusDays( 1 ) ); Iterable<Node> results = queries.findShortestPathWithSimpleParcelRouteCalculator( "DeliveryArea-1", "DeliverySegment-3", queryInterval ); Iterator<Node> iterator = results.iterator(); assertEquals( "DeliveryArea-1", iterator.next().getProperty( "name" ) ); assertEquals( "DeliveryBase-1", iterator.next().getProperty( "name" ) ); assertEquals( "ParcelCentre-1", iterator.next().getProperty( "name" ) ); assertEquals( "DeliveryBase-3", iterator.next().getProperty( "name" ) ); assertEquals( "DeliveryArea-3", iterator.next().getProperty( "name" ) ); assertEquals( "DeliverySegment-3", iterator.next().getProperty( "name" ) ); assertFalse( iterator.hasNext() ); }
### Question: EmailQueries { public ExecutionResult lossyDb() { String query = "MATCH (bob:User {username:'Bob'})-[e:EMAILED]->(charlie:User {username:'Charlie'})\n" + "RETURN e"; Map<String, Object> params = new HashMap<String, Object>(); return executionEngineWrapper.execute( query, params ); } EmailQueries( GraphDatabaseService db, ExecutionEngineWrapper executionEngineWrapper ); ExecutionResult suspectBehaviour(); ExecutionResult suspectBehaviour2(); ExecutionResult suspectBehaviour3(); ExecutionResult lossyDb(); }### Answer: @Test public void lossyDb() throws Exception { GraphDatabaseService db = createDatabase4(); EmailQueries queries = new EmailQueries( db, new PrintingExecutionEngineWrapper( db, "email", name ) ); ExecutionResult result = queries.lossyDb(); assertEquals(1, count(result.iterator())); db.shutdown(); }
### Question: SimpleSocialNetworkExtension { @GET @Path("/{name1}/{name2}") public String getDistance ( @PathParam("name1") String name1, @PathParam("name2") String name2 ) { ExecutionResult result = queries.pathBetweenTwoFriends( name1, name2 ); return String.valueOf( result.columnAs( "depth" ).next() ); } SimpleSocialNetworkExtension( @Context GraphDatabaseService db ); @GET @Path("/{name1}/{name2}") String getDistance( @PathParam("name1") String name1, @PathParam("name2") String name2 ); }### Answer: @Test public void extensionShouldReturnDistance() throws Exception { SimpleSocialNetworkExtension extension = new SimpleSocialNetworkExtension( db ); String distance = extension.getDistance( "Ben", "Mike" ); assertEquals( "4", distance ); }
### Question: SimpleSocialNetworkQueries { public ExecutionResult pathBetweenTwoFriends( String firstUser, String secondUser ) { String query = "MATCH (first:User{name:{firstUser}}),\n" + " (second:User{name:{secondUser}})\n" + "MATCH p=shortestPath(first-[*..4]-second)\n" + "RETURN length(p) AS depth"; Map<String, Object> params = new HashMap<String, Object>(); params.put( "firstUser", firstUser ); params.put( "secondUser", secondUser ); return executionEngine.execute( query, params ); } SimpleSocialNetworkQueries( GraphDatabaseService db ); ExecutionResult pathBetweenTwoFriends( String firstUser, String secondUser ); ExecutionResult friendOfAFriendToDepth4(String name); }### Answer: @Test public void shouldReturnShortestPathBetweenTwoFriends() throws Exception { ExecutionResult results = queries.pathBetweenTwoFriends( "Ben", "Mike" ); assertTrue( results.iterator().hasNext() ); assertEquals( 4, results.iterator().next().get( "depth" ) ); } @Test public void shouldReturnNoResultsWhenThereIsNotAPathBetweenTwoFriends() throws Exception { ExecutionResult results = queries.pathBetweenTwoFriends( "Ben", "Arnold" ); assertFalse( results.iterator().hasNext() ); }
### Question: SimpleSocialNetworkQueries { public ExecutionResult friendOfAFriendToDepth4(String name) { String query = "MATCH (person:User {name:{name}})-[:FRIEND]-()-[:FRIEND]-()-[:FRIEND]-()-[:FRIEND]-(friend)\n" + "RETURN friend.name AS name"; Map<String, Object> params = new HashMap<String, Object>(); params.put( "name", name ); return executionEngine.execute( query, params ); } SimpleSocialNetworkQueries( GraphDatabaseService db ); ExecutionResult pathBetweenTwoFriends( String firstUser, String secondUser ); ExecutionResult friendOfAFriendToDepth4(String name); }### Answer: @Test public void friendOfAFriendToDepth4() throws Exception { ExecutionResult results = queries.friendOfAFriendToDepth4( "Ben" ); assertTrue( results.iterator().hasNext() ); assertEquals( "Mike", results.iterator().next().get( "name" ) ); assertFalse( results.iterator().hasNext() ); }
### Question: UrlFactory extends RegexNamedEntityFactory { @Override protected List<NamedPattern> getRegexes(SpanCollection spanCollection, String lang) { return Collections.singletonList(new NamedPattern(URL, URL_PATTERN)); } }### Answer: @Test public void testRegexPattern() { Pattern p = new UrlFactory().getRegexes(null, null).get(0).getPattern(); String url1 = "http: String url2 = "Ein beispiel: https: String wrong_url1 = "khttp: String wrong_url2 = "Das ist keine URL khttp: Assert.assertTrue(p.matcher(url1).find()); Assert.assertTrue(p.matcher(url2).find()); Assert.assertFalse(p.matcher(wrong_url1).find()); Assert.assertFalse(p.matcher(wrong_url2).find()); }
### Question: Util { public static <T> T nonNull(T o) { return nonNull(o, "Require Non null object"); } private Util(); static T nonNull(T o); static T nonNull(T o, String msg); static String notBlank(String s); static String notBlank(String s, String msg); }### Answer: @Test(expected = NullPointerException.class) public void nonNull() { Util.nonNull(null); } @Test public void nonNullArg() { try { Util.nonNull(null, "test"); fail(); } catch (NullPointerException e) { assertThat(e.getMessage()).isEqualTo("test"); } }
### Question: DenbunBox { @CheckResult public static Denbun get(@NonNull String id) { checkInitialized(); DenbunId denbunId = DenbunId.of(id); if (presetAdjuster.containsKey(denbunId)) { return get(denbunId, presetAdjuster.get(denbunId)); } else { return get(denbunId, Denbun.DEFAULT_FREQUENCY_ADJUSTER); } } private DenbunBox(); static void init(@NonNull DenbunConfig config); @RestrictTo(TESTS) static void reset(); @CheckResult static Denbun get(@NonNull String id); @CheckResult static Denbun get(@NonNull String id, @NonNull FrequencyAdjuster adjuster); static void remove(@NonNull String id); static boolean exist(@NonNull String id); static void preset(@NonNull String id, @NonNull FrequencyAdjuster adjuster); static void preset(@NonNull Map<String, FrequencyAdjuster> adjusters); }### Answer: @Test(expected = IllegalStateException.class) public void notInitializedGet() { Denbun msg = DenbunBox.get("id"); }
### Question: DenbunBox { public static void preset(@NonNull String id, @NonNull FrequencyAdjuster adjuster) { notBlank(id, "Denbun ID can not be blank"); nonNull(adjuster); checkInitialized(); presetAdjuster.put(DenbunId.of(id), adjuster); } private DenbunBox(); static void init(@NonNull DenbunConfig config); @RestrictTo(TESTS) static void reset(); @CheckResult static Denbun get(@NonNull String id); @CheckResult static Denbun get(@NonNull String id, @NonNull FrequencyAdjuster adjuster); static void remove(@NonNull String id); static boolean exist(@NonNull String id); static void preset(@NonNull String id, @NonNull FrequencyAdjuster adjuster); static void preset(@NonNull Map<String, FrequencyAdjuster> adjusters); }### Answer: @Test(expected = IllegalStateException.class) public void notInitializedPresetSingle() { DenbunBox.preset("id", new CountAdjuster(1)); } @Test(expected = IllegalStateException.class) public void notInitializedPresetMulti() { Map<String, FrequencyAdjuster> map = new HashMap<>(); map.put("id", new CountAdjuster(1)); DenbunBox.preset(map); }
### Question: DenbunBox { public static void init(@NonNull DenbunConfig config) { nonNull(config, "DenbunConfig can not be null"); if (initialized()) { Log.w("DenbunBox", "DenbunBox is already initialized."); return; } DenbunBox.config = config; DenbunBox.presetAdjuster = new HashMap<>(); DenbunBox.dao = config.daoProvider().create(config.preference()); } private DenbunBox(); static void init(@NonNull DenbunConfig config); @RestrictTo(TESTS) static void reset(); @CheckResult static Denbun get(@NonNull String id); @CheckResult static Denbun get(@NonNull String id, @NonNull FrequencyAdjuster adjuster); static void remove(@NonNull String id); static boolean exist(@NonNull String id); static void preset(@NonNull String id, @NonNull FrequencyAdjuster adjuster); static void preset(@NonNull Map<String, FrequencyAdjuster> adjusters); }### Answer: @Test public void initTwice() { DenbunBox.init(config); DenbunBox.init(config); } @Test(expected = NullPointerException.class) public void initNull() { DenbunBox.init(null); }
### Question: DenbunBox { public static boolean exist(@NonNull String id) { checkInitialized(); return dao.exist(DenbunId.of(id)); } private DenbunBox(); static void init(@NonNull DenbunConfig config); @RestrictTo(TESTS) static void reset(); @CheckResult static Denbun get(@NonNull String id); @CheckResult static Denbun get(@NonNull String id, @NonNull FrequencyAdjuster adjuster); static void remove(@NonNull String id); static boolean exist(@NonNull String id); static void preset(@NonNull String id, @NonNull FrequencyAdjuster adjuster); static void preset(@NonNull Map<String, FrequencyAdjuster> adjusters); }### Answer: @Test public void exist() { SharedPreferences pref = config.preference(); DenbunBox.init(config); assertThat(pref.getAll().isEmpty()).isTrue(); Denbun msg = DenbunBox.get("id"); msg.shown(); assertThat(pref.getAll().isEmpty()).isFalse(); assertThat(DenbunBox.exist("id")).isTrue(); }
### Question: Denbun { public Denbun shown() { updateState(new State( state.id, adjuster.increment(state), Time.now(), state.count + 1)); return this; } private Denbun(@NonNull DenbunId id, @NonNull FrequencyAdjuster adjuster, @NonNull Dao dao); @NonNull String id(); boolean isSuppress(); long recent(); int count(); Denbun suppress(boolean suppress); boolean isShowable(); Denbun shown(); Denbun shown(ShowingAction action); static FrequencyAdjuster DEFAULT_FREQUENCY_ADJUSTER; }### Answer: @Test public void showingAction() { DenbunBox.init(config); Denbun.ShowingAction action = spy(new Denbun.ShowingAction() { @Override public void call() { } }); Denbun msg = DenbunBox.get("id"); msg.shown(action); verify(action, times(1)).call(); }
### Question: Util { public static String notBlank(String s) { return notBlank(s, "Require not blank"); } private Util(); static T nonNull(T o); static T nonNull(T o, String msg); static String notBlank(String s); static String notBlank(String s, String msg); }### Answer: @Test(expected = IllegalArgumentException.class) public void notBlank() { Util.notBlank(null); } @Test public void notBlankArg() { try { Util.notBlank(null, "test"); fail(); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).isEqualTo("test"); } }
### Question: State { @Override public String toString() { return "State{" + "id=" + id + ", frequency=" + frequency.value + ", recent=" + recent + ", count=" + count + '}'; } State(@NonNull DenbunId id, @NonNull Frequency frequency, long recent, int count); @CheckResult State frequency(Frequency frequency); boolean isSuppress(); boolean isShowable(); @Override String toString(); @NonNull final DenbunId id; @NonNull final Frequency frequency; final long recent; final int count; }### Answer: @Test public void toStringTest() { String s = new State(DenbunId.of("id"), Frequency.MIN, 0L, 0).toString(); }
### Question: Frequency { @CheckResult public static Frequency of(@IntRange(from = LOWER, to = UPPER) int value) { return new Frequency(value); } private Frequency(int value); @CheckResult static Frequency of(@IntRange(from = LOWER, to = UPPER) int value); @CheckResult Frequency plus(@Nullable Frequency frequency); @CheckResult Frequency plus(int value); @CheckResult Frequency minus(@Nullable Frequency frequency); @CheckResult Frequency minus(int value); boolean isLimited(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final Frequency MAX; static final Frequency MIN; final int value; }### Answer: @SuppressWarnings("Range") @Test public void init() { assertThat(Frequency.of(MAX + 1).value).isEqualTo(MAX); assertThat(Frequency.of(MIN - 1).value).isEqualTo(MIN); assertThat(Frequency.of(50).value).isEqualTo(50); }
### Question: Frequency { @CheckResult public Frequency plus(@Nullable Frequency frequency) { if (frequency == null) return this; return plus(frequency.value); } private Frequency(int value); @CheckResult static Frequency of(@IntRange(from = LOWER, to = UPPER) int value); @CheckResult Frequency plus(@Nullable Frequency frequency); @CheckResult Frequency plus(int value); @CheckResult Frequency minus(@Nullable Frequency frequency); @CheckResult Frequency minus(int value); boolean isLimited(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final Frequency MAX; static final Frequency MIN; final int value; }### Answer: @Test public void plus() { assertThat(Frequency.of(MIN).plus(5)).isEqualTo(Frequency.of(MIN + 5)); assertThat(Frequency.of(MAX).plus(1)).isEqualTo(Frequency.of(MAX)); assertThat(Frequency.of(MIN).plus(5).value).isEqualTo(MIN + 5); assertThat(Frequency.of(MAX).plus(1).value).isEqualTo(MAX); assertThat(Frequency.of(MIN).plus(Frequency.of(5))).isEqualTo(Frequency.of(MIN + 5)); assertThat(Frequency.of(MAX).plus(Frequency.of(1))).isEqualTo(Frequency.of(MAX)); Frequency freq = Frequency.of(1); assertThat(freq.plus(null)).isEqualTo(freq); }
### Question: Frequency { @CheckResult public Frequency minus(@Nullable Frequency frequency) { if (frequency == null) return this; return minus(frequency.value); } private Frequency(int value); @CheckResult static Frequency of(@IntRange(from = LOWER, to = UPPER) int value); @CheckResult Frequency plus(@Nullable Frequency frequency); @CheckResult Frequency plus(int value); @CheckResult Frequency minus(@Nullable Frequency frequency); @CheckResult Frequency minus(int value); boolean isLimited(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final Frequency MAX; static final Frequency MIN; final int value; }### Answer: @Test public void minus() { assertThat(Frequency.of(MAX).minus(5)).isEqualTo(Frequency.of(MAX - 5)); assertThat(Frequency.of(MIN).minus(5)).isEqualTo(Frequency.of(MIN)); assertThat(Frequency.of(MAX).minus(5).value).isEqualTo(MAX - 5); assertThat(Frequency.of(MIN).minus(5).value).isEqualTo(MIN); assertThat(Frequency.of(MAX).minus(Frequency.of(5))).isEqualTo(Frequency.of(MAX - 5)); assertThat(Frequency.of(MIN).minus(Frequency.of(5))).isEqualTo(Frequency.of(MIN)); Frequency freq = Frequency.of(1); assertThat(freq.minus(null)).isEqualTo(freq); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.