Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: GetPutFile extends AbstractFileAnalyzer { @Override public DataSetRefs analyze(AnalysisContext context, ProvenanceEventRecord event) { final URI uri = parseUri(event.getTransitUri()); final String clusterName = context.getClusterResolver().fromHostname(uri.getHost()); final DataSetRefs refs = new DataSetRefs(event.getComponentId()); final Referenceable ref = createFileRef(clusterName, uri); ref.set(ATTR_NAME, event.getAttribute("filename")); ref.set(ATTR_PATH, event.getAttribute("path")); ref.set(ATTR_IS_FILE, true); ref.set(ATTR_FILE_SIZE, event.getFileSize()); ref.set(ATTR_FILE_GROUP, event.getAttribute("file.group")); ref.set(ATTR_FILE_OWNER, event.getAttribute("file.owner")); if (event.getComponentType().equals("GetFile")) { refs.addInput(ref); } else { refs.addOutput(ref); } return refs; } @Override DataSetRefs analyze(AnalysisContext context, ProvenanceEventRecord event); @Override String targetComponentTypePattern(); }### Answer: @Test public void testGetFile() { final String processorName = "GetFile"; final String transitUri = "file:/var/data/landing/sample_z"; final ProvenanceEventRecord record = Mockito.mock(ProvenanceEventRecord.class); when(record.getComponentType()).thenReturn(processorName); when(record.getTransitUri()).thenReturn(transitUri); when(record.getAttribute("filename")).thenReturn("sample_z"); when(record.getEventType()).thenReturn(ProvenanceEventType.RECEIVE); final ClusterResolvers clusterResolvers = Mockito.mock(ClusterResolvers.class); when(clusterResolvers.fromHostname(matches(".+\\.example\\.com"))).thenReturn("cluster1"); final AnalysisContext context = Mockito.mock(AnalysisContext.class); when(context.getClusterResolver()).thenReturn(clusterResolvers); final NiFiProvenanceEventAnalyzer analyzer = NiFiProvenanceEventAnalyzerFactory.getAnalyzer(processorName, transitUri, record.getEventType()); assertNotNull(analyzer); final DataSetRefs refs = analyzer.analyze(context, record); assertEquals(1, refs.getInputs().size()); assertEquals(0, refs.getOutputs().size()); Referenceable ref = refs.getInputs().iterator().next(); assertEquals("fs_path", ref.getTypeName()); assertEquals("sample_z", ref.get(ATTR_NAME)); assertEquals("/var/data/landing/sample_z@null", ref.get(ATTR_QUALIFIED_NAME)); } @Test public void testPutFile() { final String processorName = "PutFile"; final String transitUri = "file:/var/data/landing/sample_z"; final ProvenanceEventRecord record = Mockito.mock(ProvenanceEventRecord.class); when(record.getComponentType()).thenReturn(processorName); when(record.getTransitUri()).thenReturn(transitUri); when(record.getAttribute("filename")).thenReturn("sample_z"); when(record.getEventType()).thenReturn(ProvenanceEventType.SEND); final ClusterResolvers clusterResolvers = Mockito.mock(ClusterResolvers.class); when(clusterResolvers.fromHostname(matches(".+\\.example\\.com"))).thenReturn("cluster1"); final AnalysisContext context = Mockito.mock(AnalysisContext.class); when(context.getClusterResolver()).thenReturn(clusterResolvers); final NiFiProvenanceEventAnalyzer analyzer = NiFiProvenanceEventAnalyzerFactory.getAnalyzer(processorName, transitUri, record.getEventType()); assertNotNull(analyzer); final DataSetRefs refs = analyzer.analyze(context, record); assertEquals(0, refs.getInputs().size()); assertEquals(1, refs.getOutputs().size()); Referenceable ref = refs.getOutputs().iterator().next(); assertEquals("fs_path", ref.getTypeName()); assertEquals("sample_z", ref.get(ATTR_NAME)); assertEquals("/var/data/landing/sample_z@null", ref.get(ATTR_QUALIFIED_NAME)); }
### Question: Stats { @GET @Produces(MediaType.APPLICATION_JSON) public String getStats() { StatsManager statsManager = this.statsManager; if (this.statsManager != null) { return JSONSerializer.serializeStatistics(statsManager.getStatistics()).toJSONString(); } return new JSONObject().toJSONString(); } @GET @Produces(MediaType.APPLICATION_JSON) String getStats(); }### Answer: @Test public void testGetStats() throws ParseException { Map<String, Object> fakeStats = new HashMap<>(); fakeStats.put("stat1", "value1"); fakeStats.put("stat2", "value2"); VideobridgeStatistics videobridgeStatistics = mock(VideobridgeStatistics.class); when(videobridgeStatistics.getStats()).thenReturn(fakeStats); when(statsManager.getStatistics()).thenReturn(videobridgeStatistics); Response resp = target(BASE_URL).request().get(); assertEquals(HttpStatus.OK_200, resp.getStatus()); assertEquals(MediaType.APPLICATION_JSON_TYPE, resp.getMediaType()); JSONObject json = getJsonResult(resp); assertEquals("value1", json.get("stat1")); assertEquals("value2", json.get("stat2")); }
### Question: SymbolTable { static List<GrainProperty> collectDeclaredProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); LateParameterizedType lpt = asLateParameterizedType(type); Class<?> clazz = erase(type); BeanInfo bi = Introspector.getBeanInfo(clazz); for (PropertyDescriptor pd : bi.getPropertyDescriptors()) { if (pd instanceof IndexedPropertyDescriptor) { continue; } Method getter = pd.getReadMethod(); if (getter == null \|\| getter.getDeclaringClass() != clazz) { continue; } Type returnType = getter.getGenericReturnType(); if (lpt != null) { returnType = lpt.resolve(returnType); } results.add(new SimpleGrainProperty(pd.getName(), returnType, flagsFor(pd))); } return results; } SymbolTable(Class<?> schema, TypeTable typeTable, TypePrinterFactory printerFactory, Member typePolicyMember); }### Answer: @Test public void test_collectDeclaredProperties_one_level_only() throws IntrospectionException { List<GrainProperty> result; result = collectDeclaredProperties(Organism.class); assertEquals(1, result.size()); assertEquals("id", result.get(0).getName()); assertEquals(int.class, result.get(0).getType()); assertTrue(result.get(0).getFlags().isEmpty()); result = collectDeclaredProperties(Animal.class); assertEquals(1, result.size()); assertEquals("vertebrate", result.get(0).getName()); assertEquals(boolean.class, result.get(0).getType()); assertEquals(GrainProperty.Flag.IS_PROPERTY, result.get(0).getFlags().iterator().next()); } @Test public void test_collectDeclaredProperties_of_generic_type() throws IntrospectionException { List<GrainProperty> result; result = collectDeclaredProperties(Descendant.class); assertEquals(1, result.size()); assertEquals("parent", result.get(0).getName()); assertEquals(new LateTypeVariable<>("T", Descendant.class), result.get(0).getType()); assertTrue(result.get(0).getFlags().isEmpty()); result = collectDeclaredProperties(new TypeToken<Descendant<String>>(){}.asType()); assertEquals(1, result.size()); assertEquals("parent", result.get(0).getName()); assertEquals(String.class, result.get(0).getType()); assertTrue(result.get(0).getFlags().isEmpty()); }
### Question: BasicList1 extends BasicConstList<E> { @Override public ConstList<E> delete(int index) { if (index == 0) { return emptyList(); } 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_delete() { compare_lists(Collections.emptyList(), new BasicList1<>(1).delete(0)); } @Test(expected = IndexOutOfBoundsException.class) public void test_delete_out_of_bounds() { new BasicList1<>(1).delete(1); }
### Question: BasicList1 extends BasicConstList<E> { @Override public ConstList<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? 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_withoutAll() { ConstList<Integer> list = new BasicList1<>(1); assertSame(BasicList0.instance(), list.withoutAll(Arrays.asList(1))); assertSame(BasicList0.instance(), list.withoutAll(Arrays.asList(2, 1))); assertSame(list, list.withoutAll(Arrays.asList(2))); assertSame(list, list.withoutAll(Arrays.asList())); } @Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicList1<>(1).withoutAll(null); }
### Question: BasicList1 extends BasicConstList<E> { @Override public ConstList<E> subList(int fromIndex, int toIndex) { ArrayTools.checkRange(fromIndex, toIndex, 1); return fromIndex != toIndex ? 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_subList() { ConstList<Integer> list = new BasicList1<>(1); assertSame(BasicList0.instance(), list.subList(0, 0)); assertSame(list, list.subList(0, 1)); assertSame(BasicList0.instance(), list.subList(1, 1)); }
### Question: BasicList1 extends BasicConstList<E> { private boolean equals(List<?> that) { if (that.size() == 1) { Object o; try { o = that.get(0); } catch (IndexOutOfBoundsException e) { return false; } return Objects.equals(o, e0); } return false; } @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_non_equality() { assertFalse(new BasicList1<>(1).equals(Arrays.asList(2))); assertFalse(Arrays.asList(2).equals(new BasicList1<>(1))); ConstList<Integer> empty = BasicList0.instance(); assertFalse(new BasicList1<>(1).equals(empty)); }
### Question: BasicMap1 extends BasicConstMap<K, V> { @Override public ConstMap<K, V> with(K key, V value) { if (Objects.equals(key, k0)) { if (Objects.equals(value, v0)) { return this; } return new BasicMap1<>(k0, value); } return new BasicMapN<>(new Object[] {k0, key}, new Object[] {v0, value}); } @SuppressWarnings("unchecked") BasicMap1(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 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 int hashCode(); }### Answer: @Test public void test_with() { ConstMap<Object, Object> map; map = new BasicMap1<>("a", 1); compare_maps(newMap("a", 1, "b", 2), map.with("b", 2)); compare_maps(newMap("a", 2), map.with("a", 2)); compare_maps(newMap("a", 1, null, null), map.with(null, null)); compare_maps(newMap("a", null), map.with("a", null)); assertSame(map, map.with("a", 1)); map = new BasicMap1<>(null, null); assertSame(map, map.with(null, null)); }
### Question: BasicMap1 extends BasicConstMap<K, V> { @Override public ConstMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToMap(unionInto(new Object[] {k0}, new Object[] {v0}, mc.keys, mc.values)); } @SuppressWarnings("unchecked") BasicMap1(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 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 int hashCode(); }### Answer: @Test public void test_withAll() { ConstMap<Object, Object> map = new BasicMap1<>("a", 1); compare_maps(newMap("a", 2, "b", 2, "c", 3), map.withAll(newMap("b", 2, "c", 3, "a", 2))); compare_maps(map, map.withAll(newMap("a", 1))); assertSame(map, map.withAll(newMap())); } @Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicMap1<>("a", 1).withAll(null); }
### Question: BasicMap1 extends BasicConstMap<K, V> { @Override public ConstMap<K, V> without(Object key) { return !containsKey(key) ? this : BasicCollections.<K, V>emptyMap(); } @SuppressWarnings("unchecked") BasicMap1(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 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 int hashCode(); }### Answer: @Test public void test_without() { ConstMap<Object, Object> map = new BasicMap1<>("a", 1); assertSame(BasicMap0.instance(), map.without("a")); assertSame(map, map.without("b")); assertSame(map, map.without(null)); }
### Question: BasicMap1 extends BasicConstMap<K, V> { @Override public ConstMap<K, V> withoutAll(Collection<?> keys) { return !keys.contains(k0) ? this : BasicCollections.<K, V>emptyMap(); } @SuppressWarnings("unchecked") BasicMap1(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 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 int hashCode(); }### Answer: @Test public void test_withoutAll() { ConstMap<Object, Object> map = new BasicMap1<>("a", 1); assertSame(BasicMap0.instance(), map.withoutAll(Arrays.asList("a"))); assertSame(BasicMap0.instance(), map.withoutAll(Arrays.asList("b", "a", "b", "a"))); assertSame(map, map.withoutAll(Arrays.asList("b"))); assertSame(map, map.withoutAll(Arrays.asList())); } @Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicMap1<>("a", 1).withoutAll(null); }
### Question: BasicMap1 extends BasicConstMap<K, V> { @Override K getKey(int index) { if (index == 0) { return k0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicMap1(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 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 int hashCode(); }### Answer: @Test public void test_get_key() { assertEquals("a", new BasicMap1<>("a", 1).getKey(0)); } @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_key() { new BasicMap1<>("a", 1).getKey(1); }
### Question: BasicMap1 extends BasicConstMap<K, V> { @Override V getValue(int index) { if (index == 0) { return v0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicMap1(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 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 int hashCode(); }### Answer: @Test public void test_get_value() { assertEquals(1, new BasicMap1<>("a", 1).getValue(0)); } @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_value() { new BasicMap1<>("a", 1).getValue(1); }
### Question: BasicConstSortedSet extends BasicConstSet<E> implements ConstSortedSet<E> { @Override public Comparator<? super E> comparator() { return comparator; } BasicConstSortedSet(Comparator<? super E> comparator); @Override Comparator<? super E> comparator(); }### Answer: @Test public void test_emptySortedSet() { assertSame(BasicSortedSet0.instance(null), emptySortedSet(null)); Comparator<Object> reverse = reverseOrder(); assertSame(BasicSortedSet0.instance(reverse).comparator(), emptySortedSet(reverse).comparator()); }
### Question: BasicSortedSet1 extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> with(E e) { int cmp = compare(e, e0); return cmp == 0 ? this : cmp < 0 ? new BasicSortedSetN<>(comparator, new Object[] {e, e0}) : new BasicSortedSetN<>(comparator, new Object[] {e0, e}); } @SuppressWarnings("unchecked") BasicSortedSet1(Comparator<? super E> comparator, Object e0); @Override int size(); @Override boolean isEmpty(); @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 public void test_with() { ConstSortedSet<Integer> set; set = new BasicSortedSet1<>(null, 1); compare_sorted_sets(newSortedSet(null, 1, 2), set.with(2)); assertSame(set, set.with(1)); set = new BasicSortedSet1<>(reverseOrder(), 1); compare_sorted_sets(newSortedSet(reverseOrder(), 2, 1), set.with(2)); assertSame(set, set.with(1)); }
### Question: BasicSortedSet1 extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(new Object[] {e0}, c.toArray(), comparator); return expanded.length == size() ? this : condenseToSortedSet(comparator, expanded); } @SuppressWarnings("unchecked") BasicSortedSet1(Comparator<? super E> comparator, Object e0); @Override int size(); @Override boolean isEmpty(); @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 public void test_withAll() { ConstSortedSet<Integer> set; set = new BasicSortedSet1<>(null, 1); compare_sorted_sets(newSortedSet(null, 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())); set = new BasicSortedSet1<>(reverseOrder(), 1); compare_sorted_sets(newSortedSet(reverseOrder(), 3, 2, 1), 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 BasicSortedSet1<>(null, 1).withAll(null); }
### Question: BasicSortedSet1 extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> without(Object o) { return !contains(o) ? this : emptySortedSet(comparator); } @SuppressWarnings("unchecked") BasicSortedSet1(Comparator<? super E> comparator, Object e0); @Override int size(); @Override boolean isEmpty(); @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 public void test_without() { ConstSortedSet<Integer> set; set = new BasicSortedSet1<>(null, 1); compare_sorted_sets(BasicSortedSet0.instance(null), set.without(1)); assertSame(set, set.without(2)); set = new BasicSortedSet1<>(reverseOrder(), 1); compare_sorted_sets(BasicSortedSet0.instance(reverseOrder()), set.without(1)); assertSame(set, set.without(2)); }
### Question: BasicSortedSet1 extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { return !c.contains(e0) ? this : emptySortedSet(comparator); } @SuppressWarnings("unchecked") BasicSortedSet1(Comparator<? super E> comparator, Object e0); @Override int size(); @Override boolean isEmpty(); @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 public void test_withoutAll() { ConstSortedSet<Integer> set; set = new BasicSortedSet1<>(null, 1); compare_sorted_sets(BasicSortedSet0.instance(null), set.withoutAll(Arrays.asList(1))); compare_sorted_sets(BasicSortedSet0.instance(null), set.withoutAll(Arrays.asList(2, 1))); assertSame(set, set.withoutAll(Arrays.asList(2))); assertSame(set, set.withoutAll(Arrays.asList())); set = new BasicSortedSet1<>(reverseOrder(), 1); compare_sorted_sets(BasicSortedSet0.instance(reverseOrder()), set.withoutAll(Arrays.asList(1))); compare_sorted_sets(BasicSortedSet0.instance(reverseOrder()), 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 BasicSortedSet1<>(null, 1).withoutAll(null); }
### Question: BasicSortedSet1 extends BasicConstSortedSet<E> { @Override E get(int index) { if (index == 0) { return e0; } throw new IndexOutOfBoundsException(); } @SuppressWarnings("unchecked") BasicSortedSet1(Comparator<? super E> comparator, Object e0); @Override int size(); @Override boolean isEmpty(); @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 public void test_get() { assertEquals(1, new BasicSortedSet1<>(null, 1).get(0)); } @Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get() { new BasicSortedSet1<>(null, 1).get(1); }
### Question: BasicMapN extends BasicConstMap<K, V> { @Override public ConstMap<K, V> with(K key, V value) { final int index = ArrayTools.indexOf(key, keys); if (index >= 0) { if (Objects.equals(value, values[index])) { return this; } return new BasicMapN<>(keys, replace(values, index, value)); } final int length = keys.length; return new BasicMapN<>(insert(keys, length, key), insert(values, length, value)); } @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_with() { ConstMap<Object, Object> map; map = new BasicMapN<>(new Object[] {"a", "b", "c", "d"}, new Object[] {1, 2, 3, 4}); compare_maps(newMap("a", 1, "b", 2, "c", 3, "d", 4, "e", 5), map.with("e", 5)); compare_maps(newMap("a", 1, "b", 9, "c", 3, "d", 4), map.with("b", 9)); compare_maps(newMap("a", 1, "b", 2, "c", 3, "d", 4, "e", null), map.with("e", null)); compare_maps(newMap("a", 1, "b", 2, "c", 3, "d", 4, null, 5), map.with(null, 5)); assertSame(map, map.with("b", 2)); map = new BasicMapN<>(new Object[] {"a", "b", "c", null}, new Object[] {1, 2, 3, null}); assertSame(map, map.with(null, null)); }
### Question: BasicMapN extends BasicConstMap<K, V> { @Override public ConstMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToMap(unionInto(keys, values, mc.keys, mc.values)); } @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_withAll() { ConstMap<Object, Object> map = new BasicMapN<>(new Object[] {"a", "b", "c", "d"}, new Object[] {1, 2, 3, 4}); compare_maps( newMap("a", 1, "b", 9, "c", 3, "d", 4, "e", 5, "f", 6), map.withAll(newMap("e", 5, "f", 6, "b", 9))); compare_maps(map, map.withAll(newMap("a", 1, "b", 2))); assertSame(map, map.withAll(newMap())); } @Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicMapN<>(new Object[] {"a", "b", "c", "d"}, new Object[] {1, 2, 3, 4}).withAll(null); }
### 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[] insertAll(Object[] original, int index, Collection<?> c) { final Object[] elements = c.toArray(); Object[] result = new Object[original.length + elements.length]; System.arraycopy(original, 0, result, 0, index); System.arraycopy(elements, 0, result, index, elements.length); System.arraycopy(original, index, result, index + elements.length, original.length - index); return result; } private BasicTools(); }### Answer: @Test public void test_insertAll() { Object[] src = new Object[] {1, 2, 3}; List<Integer> extra = Arrays.asList(8, 9); assertArrayEquals(new Object[] {8, 9, 1, 2, 3}, insertAll(src, 0, extra)); assertArrayEquals(new Object[] {1, 8, 9, 2, 3}, insertAll(src, 1, extra)); assertArrayEquals(new Object[] {1, 2, 8, 9, 3}, insertAll(src, 2, extra)); assertArrayEquals(new Object[] {1, 2, 3, 8, 9}, insertAll(src, 3, extra)); assertArrayEquals(new Object[] {1, 2, 3}, insertAll(src, 0, Collections.emptyList())); assertArrayEquals(new Object[] {1, 2, 3}, insertAll(src, 1, Collections.emptyList())); assertArrayEquals(new Object[] {1, 2, 3}, insertAll(src, 2, Collections.emptyList())); assertArrayEquals(new Object[] {1, 2, 3}, insertAll(src, 3, Collections.emptyList())); assertArrayEquals(new Object[] {"a", "b"}, insertAll(EMPTY_OBJECT_ARRAY, 0, Arrays.asList("a", "b"))); assertArrayEquals(new Object[] {null, null}, insertAll(EMPTY_OBJECT_ARRAY, 0, Arrays.asList(null, null))); } @Test public void test_insertAll_result_type_is_object_array() { assertSame(Object[].class, insertAll(new Integer[] {1, 2, 3}, 3, Arrays.asList(4, 5)).getClass()); } @Test public void test_insertAll_allocates_new() { Object[] src = new Object[] {1, 2, 3}; assertNotSame(src, insertAll(src, 0, Collections.emptyList())); } @Test(expected = IndexOutOfBoundsException.class) public void test_insertAll_out_of_bounds_low() { insertAll(EMPTY_OBJECT_ARRAY, -1, Arrays.asList("a")); } @Test(expected = IndexOutOfBoundsException.class) public void test_insertAll_out_of_bounds_high() { insertAll(EMPTY_OBJECT_ARRAY, 1, Arrays.asList("a")); } @Test(expected = NullPointerException.class) public void test_insertAll_null() { insertAll(null, 0, Collections.emptyList()); } @Test(expected = NullPointerException.class) public void test_insertAll_null_collection() { insertAll(EMPTY_OBJECT_ARRAY, 0, null); }
### 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> with(K key, V value) { int cmp = compare(key, k0); if (cmp == 0) { if (Objects.equals(value, v0)) { return this; } return new BasicSortedMap1<>(comparator, k0, value); } return cmp < 0 ? new BasicSortedMapN<K, V>(comparator, new Object[] {key, k0}, new Object[] {value, v0}) : new BasicSortedMapN<K, V>(comparator, new Object[] {k0, key}, new Object[] {v0, value}); } @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_with() { ConstSortedMap<Object, Object> map; map = new BasicSortedMap1<>(null, "a", 1); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2), map.with("b", 2)); compare_sorted_maps(newSortedMap(null, "a", 2), map.with("a", 2)); assertSame(map, map.with("a", 1)); map = new BasicSortedMap1<>(reverseOrder(), "a", 1); compare_sorted_maps(newSortedMap(reverseOrder(), "a", 1, "b", 2), map.with("b", 2)); compare_sorted_maps(newSortedMap(reverseOrder(), "a", 2), map.with("a", 2)); assertSame(map, map.with("a", 1)); }
### Question: BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap( comparator, unionInto(new Object[] {k0}, new Object[] {v0}, mc.keys, mc.values, 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_withAll() { ConstSortedMap<Object, Object> map; map = new BasicSortedMap1<>(null, "a", 1); compare_sorted_maps( newSortedMap(null, "a", 2, "b", 2, "c", 3), map.withAll(newMap("c", 3, "b", 2, "a", 2))); compare_sorted_maps(map, map.withAll(newMap("a", 1))); assertSame(map, map.withAll(newMap())); map = new BasicSortedMap1<>(reverseOrder(), "a", 1); compare_sorted_maps( newSortedMap(reverseOrder(), "a", 2, "b", 2, "c", 3), map.withAll(newMap("b", 2, "c", 3, "a", 2))); compare_sorted_maps(map, map.withAll(newMap("a", 1))); assertSame(map, map.withAll(newMap())); } @Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSortedMap1<>(null, "a", 1).withAll(null); }
### 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 public ConstSortedMap<K, V> withoutAll(Collection<?> keys) { return !keys.contains(k0) ? 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_withoutAll() { ConstSortedMap<Object, Object> map; map = new BasicSortedMap1<>(null, "a", 1); compare_sorted_maps(BasicSortedMap0.instance(null), map.withoutAll(Arrays.asList("a"))); compare_sorted_maps(BasicSortedMap0.instance(null), map.withoutAll(Arrays.asList("a", "b", "a"))); assertSame(map, map.withoutAll(Arrays.asList("b"))); assertSame(map, map.withoutAll(Arrays.asList())); map = new BasicSortedMap1<>(reverseOrder(), "a", 1); compare_sorted_maps(BasicSortedMap0.instance(reverseOrder()), map.withoutAll(Arrays.asList("a"))); compare_sorted_maps(BasicSortedMap0.instance(reverseOrder()), map.withoutAll(Arrays.asList("a", "b", "a"))); assertSame(map, map.withoutAll(Arrays.asList("b"))); assertSame(map, map.withoutAll(Arrays.asList())); } @Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSortedMap1<>(null, "a", 1).withoutAll(null); }
### 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 { @Override public Iterator<E> iterator() { return new Iter(); } 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_asList_iterator() { assertSame(emptyList(), asList(Arrays.asList().iterator())); compare_lists(Arrays.asList(1), asList(Arrays.asList(1).iterator())); compare_lists(Arrays.asList(1, 2), asList(Arrays.asList(1, 2).iterator())); compare_lists(Arrays.asList(1, 2, 3), asList(Arrays.asList(1, 2, 3).iterator())); compare_lists(Arrays.asList(1, 2, 3, 4), asList(Arrays.asList(1, 2, 3, 4).iterator())); compare_lists(Arrays.asList(1, 2, 3, 4, 5), asList(Arrays.asList(1, 2, 3, 4, 5).iterator())); compare_lists(Arrays.asList(1, 2, 3, 4, 5, 6), asList(Arrays.asList(1, 2, 3, 4, 5, 6).iterator())); } @Test public void test_asList_iterator_types() { assertEquals(BasicList1.class, asList(Arrays.asList(1).iterator()).getClass()); assertEquals(BasicListN.class, asList(Arrays.asList(1, 2).iterator()).getClass()); assertEquals(BasicListN.class, asList(Arrays.asList(1, 2, 3).iterator()).getClass()); assertEquals(BasicListN.class, asList(Arrays.asList(1, 2, 3, 4).iterator()).getClass()); assertEquals(BasicListN.class, asList(Arrays.asList(1, 2, 3, 4, 5).iterator()).getClass()); assertEquals(BasicListN.class, asList(Arrays.asList(1, 2, 3, 4, 5, 6).iterator()).getClass()); assertEquals(BasicListN.class, asList(Arrays.asList(1, 2, 3, 4, 5, 6, 7).iterator()).getClass()); assertEquals(BasicListN.class, asList(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8).iterator()).getClass()); }
### 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: BasicSortedSet0 extends BasicConstSortedSet<E> { @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } private BasicSortedSet0(Comparator<? super E> comparator); @Override int size(); @Override boolean isEmpty(); @Override Iterator<E> iterator(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @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 boolean equals(Object that); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void test_comparison() { compare_sorted_sets(newSortedSet(null), BasicSortedSet0.instance(null), -1, 0, 1, 0); compare_sorted_sets(newSortedSet(reverseOrder()), BasicSortedSet0.instance(reverseOrder()), 1, 0, -1, 0); } @Test public void test_immutable() { assert_sorted_set_immutable(BasicSortedSet0.instance(null)); } @Test public void test_serialization() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); ConstSortedSet<Object> set = BasicSortedSet0.instance(null); out.writeObject(set); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0+net.nullschool.collect.basic.SortedSetProxy00000001300xppw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); assertSame(set, in.readObject()); } @Test public void test_serialization_with_comparator() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); ConstSortedSet<Object> set = BasicSortedSet0.instance(reverseOrder()); out.writeObject(set); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0+net.nullschool.collect.basic.SortedSetProxy00000001300xpsr0'" + "java.util.Collections$ReverseComparatord48af0SNJd0200xpw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); ConstSortedSet<?> read = (ConstSortedSet)in.readObject(); compare_sorted_sets(set, read); assertSame(set.getClass(), read.getClass()); }
### Question: BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } 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_construction_permutations() { for (int a = 0; a < 6; a++) { compare_order(newSet(a), setOf(a)); for (int b = 0; b < 6; b++) { compare_order(newSet(a, b), setOf(a, b)); for (int c = 0; c < 6; c++) { compare_order(newSet(a, b, c), setOf(a, b, c)); for (int d = 0; d < 6; d++) { compare_order(newSet(a, b, c, d), setOf(a, b, c, d)); for (int e = 0; e < 6; e++) { compare_order(newSet(a, b, c, d, e), setOf(a, b, c, d, e)); for (int f = 0; f < 6; f++) { Integer[] elements = new Integer[] {a, b, c, d, e, f}; Set<Integer> expected = newSet(elements); Collection<Integer> collection = Arrays.asList(elements); compare_order(expected, setOf(a, b, c, d, e, f)); compare_order(expected, asSet(elements)); compare_order(expected, asSet(collection)); compare_order(expected, asSet(collection.iterator())); } } } } } } } @Test public void test_asSet_iterator() { assertSame(emptySet(), asSet(Arrays.asList().iterator())); compare_sets(newSet(1), asSet(Arrays.asList(1).iterator())); compare_sets(newSet(1, 2), asSet(Arrays.asList(1, 2).iterator())); compare_sets(newSet(1, 2, 3), asSet(Arrays.asList(1, 2, 3).iterator())); compare_sets(newSet(1, 2, 3, 4), asSet(Arrays.asList(1, 2, 3, 4).iterator())); compare_sets(newSet(1, 2, 3, 4, 5), asSet(Arrays.asList(1, 2, 3, 4, 5).iterator())); compare_sets(newSet(1, 2, 3, 4, 5, 6), asSet(Arrays.asList(1, 2, 3, 4, 5, 6).iterator())); } @Test public void test_asSet_iterator_types() { assertEquals(BasicSet1.class, asSet(Arrays.asList(1).iterator()).getClass()); assertEquals(BasicSetN.class, asSet(Arrays.asList(1, 2).iterator()).getClass()); assertEquals(BasicSetN.class, asSet(Arrays.asList(1, 2, 3).iterator()).getClass()); assertEquals(BasicSetN.class, asSet(Arrays.asList(1, 2, 3, 4).iterator()).getClass()); assertEquals(BasicSetN.class, asSet(Arrays.asList(1, 2, 3, 4, 5).iterator()).getClass()); assertEquals(BasicSetN.class, asSet(Arrays.asList(1, 2, 3, 4, 5, 6).iterator()).getClass()); assertEquals(BasicSetN.class, asSet(Arrays.asList(1, 2, 3, 4, 5, 6, 7).iterator()).getClass()); assertEquals(BasicSetN.class, asSet(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8).iterator()).getClass()); }
### 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> with(E e) { return with(elements.length, 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_with() { compare_lists( Arrays.asList(1, 2, 3, 4, 5, 6, 7), new BasicListN<Integer>(new Object[] {1, 2, 3, 4, 5, 6}).with(7)); compare_lists( Arrays.asList(1, 2, 3, 4, 5, 6, null), new BasicListN<Integer>(new Object[] {1, 2, 3, 4, 5, 6}).with(null)); } @Test public void test_with_index() { compare_lists( Arrays.asList(7, 1, 2, 3, 4, 5, 6), new BasicListN<Integer>(new Object[] {1, 2, 3, 4, 5, 6}).with(0, 7)); compare_lists( Arrays.asList(1, 2, 3, 7, 4, 5, 6), new BasicListN<Integer>(new Object[] {1, 2, 3, 4, 5, 6}).with(3, 7)); compare_lists( Arrays.asList(1, 2, 3, 4, 5, 6, 7), new BasicListN<Integer>(new Object[] {1, 2, 3, 4, 5, 6}).with(6, 7)); } @Test(expected = IndexOutOfBoundsException.class) public void test_with_index_out_of_bounds() { new BasicListN<Integer>(new Object[] {1, 2, 3, 4, 5, 6}).with(7, 7); }
### Question: BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } @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_withAll() { ConstList<Integer> list = new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}); compare_lists(Arrays.asList(1, 2, 3, 4, 5, 6, 1, 2, 3), list.withAll(Arrays.asList(1, 2, 3))); assertSame(list, list.withAll(Collections.<Integer>emptyList())); } @Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).withAll(null); } @Test public void test_withAll_index() { ConstList<Integer> list = new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}); compare_lists(Arrays.asList(1, 2, 3, 1, 2, 3, 4, 5, 6), list.withAll(0, Arrays.asList(1, 2, 3))); compare_lists(Arrays.asList(1, 2, 3, 4, 1, 2, 3, 5, 6), list.withAll(4, Arrays.asList(1, 2, 3))); compare_lists(Arrays.asList(1, 2, 3, 4, 5, 6, 1, 2, 3), list.withAll(6, Arrays.asList(1, 2, 3))); assertSame(list, list.withAll(0, Collections.<Integer>emptyList())); } @Test(expected = IndexOutOfBoundsException.class) public void test_withAll_index_out_of_bounds() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).withAll(7, Collections.<Integer>emptyList()); } @Test(expected = NullPointerException.class) public void test_withAll_index_throws() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).withAll(0, null); }
### 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> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : BasicCollections.<E>condenseToList(shrunk); } @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_withoutAll() { ConstList<Integer> list = new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6, 1}); compare_lists(Arrays.asList(3, 4, 5, 6), list.withoutAll(Arrays.asList(1, 2))); compare_lists(Arrays.asList(3, 4, 5, 6), list.withoutAll(Arrays.asList(1, 2, 9))); assertSame(list, list.withoutAll(Arrays.asList(7))); assertSame(list, list.withoutAll(Arrays.asList())); assertSame(BasicList0.instance(), list.withoutAll(list)); } @Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).withoutAll(null); }
### 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 public ConstSortedSet<E> with(E e) { int index = indexOf(e); return index >= 0 ? this : new BasicSortedSetN<>(comparator, insert(elements, flip(index), e)); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); }### Answer: @Test public void test_with() { ConstSortedSet<Integer> set; set = new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}); compare_sorted_sets(newSortedSet(null, 1, 2, 3, 4, 5, 6, 7), set.with(7)); compare_sorted_sets(newSortedSet(null, 0, 1, 2, 3, 4, 5, 6), set.with(0)); compare_sorted_sets(newSortedSet(null, 1, 2, 3, 4, 5, 6, 7, 8), set.with(8).with(7)); assertSame(set, set.with(6)); set = new BasicSortedSetN<>(reverseOrder(), new Object[] {6, 5, 4, 3, 2, 1}); compare_sorted_sets(newSortedSet(reverseOrder(), 7, 6, 5, 4, 3, 2, 1), set.with(7)); compare_sorted_sets(newSortedSet(reverseOrder(), 6, 5, 4, 3, 2, 1, 0), set.with(0)); compare_sorted_sets(newSortedSet(reverseOrder(), 8, 7, 6, 5, 4, 3, 2, 1), set.with(8).with(7)); assertSame(set, set.with(6)); }
### Question: BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withAll(Collection<? extends E> c) { if (c.isEmpty()) { return this; } Object[] expanded = unionInto(elements, c.toArray(), comparator); return expanded.length == size() ? this : new BasicSortedSetN<>(comparator, expanded); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); }### Answer: @Test public void test_withAll() { ConstSortedSet<Integer> set; set = new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 7}); compare_sorted_sets( newSortedSet(null, 0, 1, 2, 3, 4, 5, 6, 7, 8), set.withAll(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1, 0))); assertSame(set, set.withAll(Arrays.asList(1, 1, 1, 2, 2, 3, 3))); assertSame(set, set.withAll(Collections.<Integer>emptyList())); set = new BasicSortedSetN<>(reverseOrder(), new Object[] {7, 5, 4, 3, 2, 1}); compare_sorted_sets( newSortedSet(reverseOrder(), 8, 7, 6, 5, 4, 3, 2, 1, 0), set.withAll(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1, 0))); assertSame(set, set.withAll(Arrays.asList(1, 1, 1, 2, 2, 3, 3))); assertSame(set, set.withAll(Collections.<Integer>emptyList())); } @Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}).withAll(null); }
### Question: BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> without(Object o) { int index = indexOf(o); return index < 0 ? this : condenseToSortedSet(comparator, delete(elements, index)); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); }### Answer: @Test public void test_without() { ConstSortedSet<Integer> set; set = new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}); compare_sorted_sets(newSortedSet(null, 2, 3, 4, 5, 6), set.without(1)); compare_sorted_sets(newSortedSet(null, 1, 3, 4, 5, 6), set.without(2)); compare_sorted_sets(newSortedSet(null, 1, 2, 3, 4, 5), set.without(6)); assertSame(set, set.without(-1)); assertSame(set, set.without(7)); set = new BasicSortedSetN<>(reverseOrder(), new Object[] {6, 5, 4, 3, 2, 1}); compare_sorted_sets(newSortedSet(reverseOrder(), 6, 5, 4, 3, 2), set.without(1)); compare_sorted_sets(newSortedSet(reverseOrder(), 6, 5, 4, 3, 1), set.without(2)); compare_sorted_sets(newSortedSet(reverseOrder(), 5, 4, 3, 2, 1), set.without(6)); assertSame(set, set.without(-1)); assertSame(set, set.without(7)); }
### Question: BasicSortedSetN extends BasicConstSortedSet<E> { @Override public ConstSortedSet<E> withoutAll(Collection<?> c) { if (c.isEmpty()) { return this; } Object[] shrunk = deleteAll(elements, c); return shrunk.length == size() ? this : condenseToSortedSet(comparator, shrunk); } @SuppressWarnings("unchecked") BasicSortedSetN(Comparator<? super E> comparator, Object[] elements); @Override int size(); @Override boolean contains(Object o); @Override E first(); @Override E last(); @Override Object[] toArray(); @Override ConstSortedSet<E> with(E e); @Override ConstSortedSet<E> withAll(Collection<? extends E> c); @Override ConstSortedSet<E> without(Object o); @Override ConstSortedSet<E> withoutAll(Collection<?> c); @Override ConstSortedSet<E> headSet(E toElement); @Override ConstSortedSet<E> tailSet(E fromElement); @Override ConstSortedSet<E> subSet(E fromElement, E toElement); @Override int hashCode(); }### Answer: @Test public void test_withoutAll() { ConstSortedSet<Integer> set; set = new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}); compare_sorted_sets(newSortedSet(null, 2, 4, 5), set.withoutAll(Arrays.asList(1, 3, 6))); compare_sorted_sets(newSortedSet(null, 2, 4, 5), set.withoutAll(Arrays.asList(1, 3, 9, -1, 6))); assertSame(set, set.withoutAll(Arrays.asList(7))); assertSame(set, set.withoutAll(Arrays.asList())); assertEquals(BasicSortedSet0.<Integer>instance(null), set.withoutAll(set)); set = new BasicSortedSetN<>(reverseOrder(), new Object[] {6, 5, 4, 3, 2, 1}); compare_sorted_sets(newSortedSet(reverseOrder(), 5, 4, 2), set.withoutAll(Arrays.asList(1, 3, 6))); compare_sorted_sets(newSortedSet(reverseOrder(), 5, 4, 2), set.withoutAll(Arrays.asList(1, 3, 9, -1, 6))); assertSame(set, set.withoutAll(Arrays.asList(7))); assertSame(set, set.withoutAll(Arrays.asList())); assertEquals(BasicSortedSet0.<Integer>instance(reverseOrder()), set.withoutAll(set)); } @Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSortedSetN<>(null, new Object[] {1, 2, 3, 4, 5, 6}).withoutAll(null); }
### 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: TypeTable { synchronized Map<String, Type> schemaTypes(Class<?> schema) { Map<String, Type> map = new HashMap<>(); Map<Name, String> names = namingPolicy.getNames(schema); Map<Name, String> simpleNames = namingPolicy.getSimpleNames(schema); Class<?> targetGrain = getGrainClass(schema); Class<?> targetBuilder = getGrainBuilderClass(schema); map.put("targetSchema", schema); map.put("targetGrain", targetGrain); map.put("targetBuilder", targetBuilder); ClassHandle targetFactory = loadOrCreateClass(names.get(Name.factory), Enum.class); ClassHandle targetGrainImpl = loadOrCreateNested(names.get(Name.grainImpl), simpleNames.get(Name.grainImpl), targetFactory); ClassHandle targetGrainProxy = loadOrCreateNested(names.get(Name.grainProxy), simpleNames.get(Name.grainProxy), targetFactory); ClassHandle targetBuilderImpl = loadOrCreateNested(names.get(Name.builderImpl), simpleNames.get(Name.builderImpl), targetFactory); map.put("targetFactory", targetFactory.toClass()); map.put("targetGrainImpl", targetGrainImpl.toClass()); map.put("targetGrainProxy", targetGrainProxy.toClass()); map.put("targetBuilderImpl", targetBuilderImpl.toClass()); return map; } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); }### Answer: @Test public void test_schema_types() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); Map<String, Type> schemaTypes = table.schemaTypes(Foo.class); assertSame(Foo.class, schemaTypes.get("targetSchema")); assertEquals("interface com.test.FooGrain", schemaTypes.get("targetGrain").toString()); assertEquals("interface com.test.FooBuilder", schemaTypes.get("targetBuilder").toString()); assertEquals("class com.test.FooFactory", schemaTypes.get("targetFactory").toString()); assertEquals("class com.test.FooFactory$FooGrainImpl", schemaTypes.get("targetGrainImpl").toString()); assertEquals("class com.test.FooFactory$FooGrainProxy", schemaTypes.get("targetGrainProxy").toString()); assertEquals("class com.test.FooFactory$FooBuilderImpl", schemaTypes.get("targetBuilderImpl").toString()); }
### 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> with(K key, V value) { int index = indexOf(key); if (index >= 0) { if (Objects.equals(value, values[index])) { return this; } return new BasicSortedMapN<>(comparator, keys, replace(values, index, value)); } index = flip(index); return new BasicSortedMapN<>(comparator, insert(keys, index, key), insert(values, index, value)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); }### Answer: @Test public void test_with() { ConstSortedMap<Object, Object> map; map = new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "e"}, new Object[] {1, 2, 3, 5}); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2, "c", 3, "d", 4, "e", 5), map.with("d", 4)); compare_sorted_maps(newSortedMap(null, "+", 0, "a", 1, "b", 2, "c", 3, "e", 5), map.with("+", 0)); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2, "c", 3, "e", 5, "f", 6), map.with("f", 6)); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 9, "c", 3, "e", 5), map.with("b", 9)); assertSame(map, map.with("b", 2)); map = new BasicSortedMapN<>(reverseOrder(), new Object[] {"e", "c", "b", "a"}, new Object[] {5, 3, 2, 1}); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "d", 4, "c", 3, "b", 2, "a", 1), map.with("d", 4)); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "c", 3, "b", 2, "a", 1, "+", 0), map.with("+", 0)); compare_sorted_maps(newSortedMap(reverseOrder(), "f", 6, "e", 5, "c", 3, "b", 2, "a", 1), map.with("f", 6)); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "c", 3, "b", 9, "a", 1), map.with("b", 9)); assertSame(map, map.with("b", 2)); }
### Question: BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap(comparator, unionInto(keys, values, mc.keys, mc.values, comparator)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); }### Answer: @Test public void test_withAll() { ConstSortedMap<Object, Object> map; map = new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "e"}, new Object[] {1, 2, 3, 5}); compare_sorted_maps( newSortedMap(null, "+", 0, "a", 1, "b", 9, "c", 3, "d", 4, "e", 5, "f", 6), map.withAll(newMap("+", 0, "f", 6, "b", 9, "d", 4))); compare_sorted_maps(map, map.withAll(newMap("a", 1, "b", 2))); assertSame(map, map.withAll(newMap())); map = new BasicSortedMapN<>(reverseOrder(), new Object[] {"e", "c", "b", "a"}, new Object[] {5, 3, 2, 1}); compare_sorted_maps( newSortedMap(reverseOrder(), "f", 6, "e", 5, "d", 4, "c", 3, "b", 9, "a", 1, "+", 0), map.withAll(newMap("+", 0, "f", 6, "b", 9, "d", 4))); compare_sorted_maps(map, map.withAll(newMap("a", 1, "b", 2))); assertSame(map, map.withAll(newMap())); } @Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "d"}, new Object[] {1, 2, 3, 4}).withAll(null); }
### Question: Cook extends AbstractTypeOperator<Type> { @Override public Type apply(Class<?> clazz) { if (clazz.isArray()) { Type componentType = apply(clazz.getComponentType()); if (!(componentType instanceof Class)) { return new LateGenericArrayType(componentType); } } else if (clazz == Enum.class) { return Enum.class; } else { Type ownerType = isInnerClass(clazz) ? apply(clazz.getEnclosingClass()) : clazz.getEnclosingClass(); TypeVariable<?>[] typeParameters = clazz.getTypeParameters(); if (typeParameters.length > 0 \|\| ownerType instanceof ParameterizedType) { return apply(new LateParameterizedType(clazz, ownerType, typeParameters)); } } return clazz; } @Override Type apply(Class<?> clazz); @Override Type apply(ParameterizedType pt); @Override Type apply(GenericArrayType gat); @Override Type apply(WildcardType wt); @Override Type apply(TypeVariable<?> tv); }### Answer: @Test public void test_cook() { Cook cook = new Cook(); assertEquals( new TypeToken<Integer>(){}.asType(), cook.apply(new TypeToken<Integer>(){}.asType())); assertEquals( new TypeToken<Integer[]>(){}.asType(), cook.apply(new TypeToken<Integer[]>(){}.asType())); assertEquals( new TypeToken<int[]>(){}.asType(), cook.apply(new TypeToken<int[]>(){}.asType())); assertEquals( new TypeToken<List<?>>(){}.asType(), cook.apply(new TypeToken<List>(){}.asType())); assertEquals( new TypeToken<List<?>[]>(){}.asType(), cook.apply(new TypeToken<List[]>(){}.asType())); assertEquals( new TypeToken<Enum<?>[]>(){}.asType(), cook.apply(new TypeToken<Enum<?>[]>(){}.asType())); assertEquals( new TypeToken<List<?>[][]>(){}.asType(), cook.apply(new TypeToken<List[][]>(){}.asType())); assertEquals( new TypeToken<Map<?, ?>>(){}.asType(), cook.apply(new TypeToken<Map>(){}.asType())); assertEquals( new TypeToken<Enum>(){}.asType(), cook.apply(new TypeToken<Enum>(){}.asType())); assertEquals( new TypeToken<EnumSet<? extends Enum>>(){}.asType(), cook.apply(new TypeToken<EnumSet>(){}.asType())); assertEquals( new TypeToken<ComparatorMap<? extends Comparator, ? extends Comparator>>(){}.asType(), cook.apply(new TypeToken<ComparatorMap>(){}.asType())); assertEquals( new TypeToken<NumberMap<? extends Number, ? extends Number>>(){}.asType(), cook.apply(new TypeToken<NumberMap>(){}.asType())); assertEquals( new TypeToken<NumbersMap<? extends Number, ? extends List<? extends Number>>>(){}.asType(), cook.apply(new TypeToken<NumbersMap>(){}.asType())); assertEquals( new TypeToken<ComplexList1<? extends ComplexList1>>(){}.asType(), cook.apply(new TypeToken<ComplexList1>(){}.asType())); assertEquals( new TypeToken<ComplexList2<? extends List<? extends List>>>(){}.asType(), cook.apply(new TypeToken<ComplexList2>(){}.asType())); assertEquals( new TypeToken<ComplexMap1<? extends List<? extends List>, ? extends List<? extends List>>>(){}.asType(), cook.apply(new TypeToken<ComplexMap1>(){}.asType())); assertEquals( new TypeToken<ComplexMap2<? extends List<? extends List>, ? extends List<? extends List>>>(){}.asType(), cook.apply(new TypeToken<ComplexMap2>(){}.asType())); assertEquals( new TypeToken<ComplexMap5<? extends Number, ? extends Map<? extends Number, ? extends List<? extends Number>>>>(){}.asType(), cook.apply(new TypeToken<ComplexMap5>(){}.asType())); assertEquals( new TypeToken<ComplexMap6<? extends Number, ? extends Map<? super Number, ? super List<? extends Number>>>>(){}.asType(), cook.apply(new TypeToken<ComplexMap6>(){}.asType())); assertEquals( new TypeToken<Outer<? extends Number>.Inner0>(){}.asType(), cook.apply(new TypeToken<Outer.Inner0>(){}.asType())); assertEquals( new TypeToken<Outer<? extends Number>.Inner1<? extends Number>>(){}.asType(), cook.apply(new TypeToken<Outer.Inner1>(){}.asType())); }
### Question: BasicSortedMapN extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> without(Object key) { int index = indexOf(key); return index < 0 ? this : BasicCollections.<K, V>condenseToSortedMap(comparator, delete(keys, index), delete(values, index)); } @SuppressWarnings("unchecked") BasicSortedMapN(Comparator<? super K> comparator, Object[] keys, Object[] values); @Override int size(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keysToDelete); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override int hashCode(); }### Answer: @Test public void test_without() { ConstSortedMap<Object, Object> map; map = new BasicSortedMapN<>(null, new Object[] {"a", "b", "c", "e"}, new Object[] {1, 2, 3, 5}); compare_sorted_maps(newSortedMap(null, "b", 2, "c", 3, "e", 5), map.without("a")); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2, "e", 5), map.without("c")); compare_sorted_maps(newSortedMap(null, "a", 1, "b", 2, "c", 3), map.without("e")); assertSame(map, map.without("+")); assertSame(map, map.without("d")); assertSame(map, map.without("f")); map = new BasicSortedMapN<>(reverseOrder(), new Object[] {"e", "c", "b", "a"}, new Object[] {5, 3, 2, 1}); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "c", 3, "b", 2), map.without("a")); compare_sorted_maps(newSortedMap(reverseOrder(), "e", 5, "b", 2, "a", 1), map.without("c")); compare_sorted_maps(newSortedMap(reverseOrder(), "c", 3, "b", 2, "a", 1), map.without("e")); assertSame(map, map.without("+")); assertSame(map, map.without("d")); assertSame(map, map.without("f")); }
### 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: BasicSortedMap0 extends BasicConstSortedMap<K, V> { @SuppressWarnings("unchecked") static <K, V> BasicSortedMap0<K, V> instance(Comparator<? super K> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedMap0<>(comparator); } private BasicSortedMap0(Comparator<? super K> comparator); @Override int size(); @Override boolean isEmpty(); @Override MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override K firstKey(); @Override K lastKey(); @Override ConstSortedSet<K> keySet(); @Override ConstCollection<V> values(); @Override ConstSet<Entry<K, V>> entrySet(); @Override ConstSortedMap<K, V> with(K key, V value); @Override ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map); @Override ConstSortedMap<K, V> without(Object key); @Override ConstSortedMap<K, V> withoutAll(Collection<?> keys); @Override ConstSortedMap<K, V> headMap(K toKey); @Override ConstSortedMap<K, V> tailMap(K fromKey); @Override ConstSortedMap<K, V> subMap(K fromKey, K toKey); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void test_comparison() { compare_sorted_maps(newSortedMap(null), BasicSortedMap0.instance(null), "a", "b"); compare_sorted_maps(newSortedMap(reverseOrder()), BasicSortedMap0.instance(reverseOrder()), "a", "b"); } @Test public void test_immutable() { assert_sorted_map_immutable(BasicSortedMap0.instance(null)); } @Test public void test_serialization() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); ConstSortedMap<Object, Object> map = BasicSortedMap0.instance(null); out.writeObject(map); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0+net.nullschool.collect.basic.SortedMapProxy00000001300xppw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); assertSame(map, in.readObject()); } @Test public void test_serialization_with_comparator() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(baos); ConstSortedMap<Object, Object> map = BasicSortedMap0.instance(reverseOrder()); out.writeObject(map); byte[] data = baos.toByteArray(); assertEquals( "aced05sr0+net.nullschool.collect.basic.SortedMapProxy00000001300xpsr0'" + "java.util.Collections$ReverseComparatord48af0SNJd0200xpw40000x", BasicToolsTest.asReadableString(data)); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data)); ConstSortedMap<?, ?> read = (ConstSortedMap)in.readObject(); compare_sorted_maps(map, read); assertSame(map.getClass(), read.getClass()); }
### 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 put(K key, V value) { throw new UnsupportedOperationException(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); }### Answer: @Test public void test_map_put() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); put(expected, actual, "d", 4); compare_maps(expected, actual); put(expected, actual, "a", -1); compare_maps(expected, actual); put(expected, actual, null, 10); compare_maps(expected, actual); put(expected, actual, null, 11); compare_maps(expected, actual); put(expected, actual, "e", null); compare_maps(expected, actual); put(expected, actual, "e", 5); compare_maps(expected, actual); } @Test public void test_map_put_null_entry() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); put(expected, actual, null, null); compare_maps(expected, actual); } @Test(expected = UnsupportedOperationException.class) public void test_map_put_throws() { @SuppressWarnings("unchecked") IterableMap<Object, Object> map = mock(AbstractIterableMap.class); given(map.put(any(), any())).willCallRealMethod(); map.put(new Object(), new Object()); }
### Question: AbstractIterableMap implements IterableMap<K, V> { @Override public void putAll(Map<? extends K, ? extends V> map) { if (map instanceof IterableMap) { for (MapIterator<? extends K, ? extends V> iter = iteratorFor(map); iter.hasNext();) { put(iter.next(), iter.value()); } } else { for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { put(entry.getKey(), entry.getValue()); } } } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); }### Answer: @Test public void test_map_putAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); putAll(expected, actual, "a", -1, "d", 4); compare_maps(expected, actual); putAll(expected, actual, "e", null, null, 10); compare_maps(expected, actual); expected.putAll(Collections.<String, Integer>emptyMap()); actual.putAll(Collections.<String, Integer>emptyMap()); compare_maps(expected, actual); } @Test public void test_map_putAll_iterableMap() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3); Map<String, Integer> actual = new MockIterableMap<>(expected); IterableMap<String, Integer> im = new MockIterableMap<>(singletonMap("x", 0)); expected.putAll(im); actual.putAll(im); compare_maps(expected, actual); } @Test(expected = NullPointerException.class) public void test_map_null_putAll() { new MockIterableMap<>().putAll(null); }
### 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: AbstractIterableMap implements IterableMap<K, V> { @Override public Set<K> keySet() { return new KeysView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); }### Answer: @Test public void test_keySet_removeAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, null, 4); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); removeAll(expected.keySet(), actual.keySet(), "a", "c", null, "d"); compare_maps(expected, actual); removeAll(expected.keySet(), actual.keySet(), new String[0]); compare_maps(expected, actual); } @Test(expected = NullPointerException.class) public void test_keySet_removeAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).keySet().removeAll(null); } @Test public void test_keySet_retainAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, null, 4); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); retainAll(expected.keySet(), actual.keySet(), "a", "c", null, "d"); compare_maps(expected, actual); } @Test(expected = NullPointerException.class) public void test_keySet_retainAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).keySet().retainAll(null); } @Test(expected = UnsupportedOperationException.class) public void test_keySet_add_throws() { new MockIterableMap<>().keySet().add("a"); } @Test(expected = UnsupportedOperationException.class) public void test_keySet_addAll_throws() { new MockIterableMap<>().keySet().addAll(Arrays.asList("a")); }
### Question: AbstractIterableMap implements IterableMap<K, V> { @Override public Collection<V> values() { return new ValuesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); }### Answer: @Test public void test_values_removeAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, "d", null, "x", 1); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); removeAll(expected.values(), actual.values(), 1, 3, null, 5); compare_maps(expected, actual); removeAll(expected.values(), actual.values(), new Integer[0]); compare_maps(expected, actual); } @Test(expected = NullPointerException.class) public void test_values_removeAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).values().removeAll(null); } @Test public void test_values_retainAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, "d", null, "x", 1); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); retainAll(expected.values(), actual.values(), 1, 3, null, 5); compare_maps(expected, actual); } @Test(expected = NullPointerException.class) public void test_values_retainAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).values().retainAll(null); } @Test(expected = UnsupportedOperationException.class) public void test_values_add_throws() { new MockIterableMap<>().values().add(1); } @Test(expected = UnsupportedOperationException.class) public void test_values_addAll_throws() { new MockIterableMap<>().values().addAll(Arrays.asList(1)); }
### Question: ConfigurableTypePolicy implements TypePolicy { @Override public <T> Transform<T> newTransform(TypeToken<T> token) { Type type = token.asType(); if (type instanceof Class) { @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>)type; return new CastingTransform<>(clazz); } if (type instanceof ParameterizedType) { @SuppressWarnings("unchecked") final Class<T> erasure = (Class<T>)erase(type); return new CastingTransform<>(erasure); } throw new IllegalArgumentException("Cannot create transform for: " + print(type)); } private ConfigurableTypePolicy(); private ConfigurableTypePolicy(ConfigurableTypePolicy source); Set<Class<?>> getImmutableTypes(); Map<Class<?>, Class<?>> getImmutableMappings(); ConfigurableTypePolicy withImmutableTypes(Collection<? extends Class<?>> types); ConfigurableTypePolicy withImmutableTypes(Class<?>... types); ConfigurableTypePolicy withImmutableMapping(Class<?> from, Class<?> to); @Override boolean isImmutableType(Class<?> clazz); @Override Class<?> asImmutableType(Class<?> clazz); @Override Transform<T> newTransform(TypeToken<T> token); static final ConfigurableTypePolicy EMPTY; static final ConfigurableTypePolicy STANDARD; }### Answer: @Test public void test_class_transform() { ConfigurableTypePolicy policy = ConfigurableTypePolicy.EMPTY; Transform<Long> transform = policy.newTransform(new TypeToken<Long>(){}); Object o = transform.apply(1L); assertEquals(1L, o); try { transform.apply(1); fail(); } catch (ClassCastException expected) {} } @Test public void test_list_transform() { ConfigurableTypePolicy policy = ConfigurableTypePolicy.EMPTY; Transform<List<String>> transform = policy.newTransform(new TypeToken<List<String>>(){}); Object o = transform.apply(listOf("a")); assertEquals(listOf("a"), o); try { transform.apply(setOf("a")); fail(); } catch (ClassCastException expected) {} List<String> list = transform.apply(listOf(1)); try { System.out.println(list.get(0)); fail(); } catch (ClassCastException darn) {} }
### Question: AbstractIterableMap implements IterableMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return new EntriesView(); } @Override abstract int size(); @Override boolean isEmpty(); @Override abstract MapIterator<K, V> iterator(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override V get(Object key); @Override V put(K key, V value); @Override void putAll(Map<? extends K, ? extends V> map); @Override V remove(Object key); @Override void clear(); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); }### Answer: @Test public void test_entrySet_removeAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, "d", null, null, 5); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); removeAll( expected.entrySet(), actual.entrySet(), newEntry("a", 1), newEntry("d", (Integer)null), newEntry((String)null, 5), newEntry("c", 4), newEntry("x", 2), newEntry("z", 9)); compare_maps(expected, actual); removeAll(expected.entrySet(), actual.entrySet()); compare_maps(expected, actual); } @Test(expected = NullPointerException.class) public void test_entrySet_removeAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).entrySet().removeAll(null); } @Test public void test_entrySet_retainAll() { Map<String, Integer> expected = newMap("a", 1, "b", 2, "c", 3, "d", null, null, 5); IterableMap<String, Integer> actual = new MockIterableMap<>(expected); retainAll( expected.entrySet(), actual.entrySet(), newEntry("a", 1), newEntry("d", (Integer)null), newEntry((String)null, 5), newEntry("c", 4), newEntry("x", 2), newEntry("z", 9)); compare_maps(expected, actual); } @Test(expected = NullPointerException.class) public void test_entrySet_retainAll_throws() { new MockIterableMap<>(singletonMap("a", 1)).entrySet().retainAll(null); } @Test(expected = UnsupportedOperationException.class) public void test_entrySet_add_throws() { new MockIterableMap<String, Integer>().entrySet().add(newEntry("a", 1)); } @Test(expected = UnsupportedOperationException.class) public void test_entrySet_addAll_throws() { new MockIterableMap<String, Integer>().entrySet().addAll(Arrays.asList(newEntry("a", 1))); }
### 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: SymbolTable { static List<GrainProperty> collectProperties(Type type) throws IntrospectionException { List<GrainProperty> results = new ArrayList<>(); Set<Type> visited = new HashSet<>(); visited.add(null); visited.add(Object.class); Deque<Type> workList = new LinkedList<>(); workList.add(type); while (!workList.isEmpty()) { Type current = workList.removeFirst(); if (visited.contains(current)) { continue; } visited.add(current); results.addAll(collectDeclaredProperties(current)); workList.add(genericSuperclassOf(current)); Collections.addAll(workList, genericInterfacesOf(current)); } return results; } SymbolTable(Class<?> schema, TypeTable typeTable, TypePrinterFactory printerFactory, Member typePolicyMember); }### Answer: @Test public void test_collectProperties_multiple_levels() throws IntrospectionException { List<GrainProperty> result; result = collectProperties(Organism.class); assertEquals(1, result.size()); assertEquals("id", result.get(0).getName()); assertEquals(int.class, result.get(0).getType()); assertTrue(result.get(0).getFlags().isEmpty()); result = collectProperties(Animal.class); assertEquals(3, result.size()); assertEquals("vertebrate", result.get(0).getName()); assertEquals(boolean.class, result.get(0).getType()); assertEquals(GrainProperty.Flag.IS_PROPERTY, result.get(0).getFlags().iterator().next()); assertEquals("id", result.get(1).getName()); assertEquals(int.class, result.get(1).getType()); assertTrue(result.get(1).getFlags().isEmpty()); assertEquals("parent", result.get(2).getName()); assertEquals(UUID.class, result.get(2).getType()); assertTrue(result.get(2).getFlags().isEmpty()); } @Test public void test_collectProperties_multiple_level_raw_generic() throws IntrospectionException { List<GrainProperty> result; result = collectProperties(RawDescendant.class); assertEquals(1, result.size()); assertEquals("parent", result.get(0).getName()); assertEquals(new LateTypeVariable<>("T", Descendant.class), result.get(0).getType()); assertTrue(result.get(0).getFlags().isEmpty()); } @Test public void test_collectProperties_composite_type_with_diamond() throws IntrospectionException { List<GrainProperty> result; result = collectProperties(C.class); assertEquals(3, result.size()); assertEquals("c", result.get(0).getName()); assertEquals("a", result.get(1).getName()); assertEquals("b", result.get(2).getName()); result = collectProperties(E.class); assertEquals(5, result.size()); assertEquals("e", result.get(0).getName()); assertEquals("c", result.get(1).getName()); assertEquals("d", result.get(2).getName()); assertEquals("a", result.get(3).getName()); assertEquals("b", result.get(4).getName()); } @Test public void test_collectProperties_with_duplicate_property_names() throws IntrospectionException { List<GrainProperty> result; result = collectProperties(R.class); assertEquals(3, result.size()); assertEquals(R.class, result.get(0).getType()); assertEquals(P.class, result.get(1).getType()); assertEquals(Q.class, result.get(2).getType()); } @Test public void test_collectProperties_with_narrowest_type_in_upper_level() throws IntrospectionException { List<GrainProperty> result; result = collectProperties(W.class); assertEquals(3, result.size()); assertEquals(Object.class, result.get(0).getType()); assertEquals(Integer.class, result.get(1).getType()); assertEquals(Number.class, result.get(2).getType()); }
### 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: IteratorTools { public static <K, V> MapIterator<K, V> newMapIterator(Map<K, V> map) { if (map.isEmpty()) { return emptyMapIterator(); } return map instanceof IterableMap ? ((IterableMap<K, V>)map).iterator() : new MapIteratorAdapter<>(map.entrySet().iterator()); } private IteratorTools(); @SuppressWarnings("unchecked") static MapIterator<K, V> emptyMapIterator(); static MapIterator<K, V> newMapIterator(Map<K, V> map); static MapIterator<K, V> chainMapIterators(MapIterator<K, V> first, MapIterator<K, V> second); }### Answer: @Test public void test_newMapIterator_adapter() { Map map = mock(Map.class); Set entrySet = mock(Set.class); Iterator entrySetIter = mock(Iterator.class); Map.Entry entry1 = new AbstractMap.SimpleImmutableEntry<>("a", 1); Map.Entry entry2 = new AbstractMap.SimpleImmutableEntry<>("b", 2); when(map.isEmpty()).thenReturn(false); when(map.entrySet()).thenReturn(entrySet); when(entrySet.iterator()).thenReturn(entrySetIter); when(entrySetIter.hasNext()).thenReturn(true, true, false); when(entrySetIter.next()).thenReturn(entry1, entry2); MapIterator iter = newMapIterator((Map<?, ?>)map); try { iter.value(); fail(); } catch (IllegalStateException ignored) {} try { iter.entry(); fail(); } catch (IllegalStateException ignored) {} assertTrue(iter.hasNext()); assertEquals(entry1.getKey(), iter.next()); assertEquals(entry1.getValue(), iter.value()); assertSame(entry1, iter.entry()); iter.remove(); try { iter.value(); fail(); } catch (IllegalStateException ignored) {} try { iter.entry(); fail(); } catch (IllegalStateException ignored) {} assertTrue(iter.hasNext()); assertEquals(entry2.getKey(), iter.next()); assertEquals(entry2.getValue(), iter.value()); assertSame(entry2, iter.entry()); iter.remove(); try { iter.value(); fail(); } catch (IllegalStateException ignored) {} try { iter.entry(); fail(); } catch (IllegalStateException ignored) {} verify(entrySetIter, times(2)).hasNext(); verify(entrySetIter, times(2)).next(); verify(entrySetIter, times(2)).remove(); assertFalse(iter.hasNext()); } @Test public void test_newMapIterator_on_iterableMap() { IterableMap map = mock(IterableMap.class); MapIterator iter = mock(MapIterator.class); when(map.isEmpty()).thenReturn(false); when(map.iterator()).thenReturn(iter); assertSame(iter, newMapIterator((Map<?, ?>)map)); } @Test(expected = NullPointerException.class) public void test_newMapIterator_throws() { newMapIterator(null); }
### 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 ConstSet<String> keySet() { return new ConstKeysView(); } @Override abstract Object get(Object key); @Deprecated @Override final Object put(String key, Object value); @Deprecated @Override final void putAll(Map<? extends String, ?> map); @Deprecated @Override final Object remove(Object key); @Deprecated @Override final void clear(); @Override ConstSet<String> keySet(); @Override ConstCollection<Object> values(); @Override ConstSet<Entry<String, Object>> entrySet(); }### Answer: @Test public void test_iteration_without_calling_hasNext() { Set<String> keys = new LinkedHashSet<>(); Grain grain = new MockGrain(sortedMapOf(null, "a", (Object)1), sortedMapOf(null, "b", (Object)2)); MapIterator<String, Object> iter = grain.iterator(); for (int i = 0; i < grain.size(); i++) { keys.add(iter.next()); } try { iter.next(); fail(); } catch (NoSuchElementException expected) {} assertArrayEquals(grain.keySet().toArray(), keys.toArray()); } @Test public void test_keySet_modify() { Grain grain = new MockGrain(sortedMapOf(null, "a", (Object)1), sortedMapOf(null, "b", (Object)2)); ConstSet<String> keySet = grain.keySet(); assertSame(keySet, keySet.with("a")); assertSame(keySet, keySet.with("b")); compare_sets(newSet("a", "b", "+"), keySet.with("+")); compare_sets(newSet("a", "b", "+", "c"), keySet.withAll(Arrays.asList("+", "c"))); assertSame(keySet, keySet.withAll(Arrays.<String>asList())); assertSame(keySet, keySet.without("+")); compare_sets(newSet("b"), keySet.without("a")); compare_sets(newSet("a"), keySet.without("b")); compare_sets(newSet("a"), keySet.withoutAll(Arrays.asList("b", "c"))); compare_sets(newSet(), keySet.withoutAll(keySet)); assertSame(keySet, keySet.withoutAll(Arrays.asList())); }
### 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())); }

Subsets and Splits

No saved queries yet

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