target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void test_copy_collection() { List<Integer> src = Arrays.asList(1, 2, 3); assertArrayEquals(new Object[] {1, 2, 3}, copy(src)); assertEquals(Object[].class, copy(src).getClass()); } | static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_copy_collection_null() { copy((Collection<?>)null); } | static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } |
@Test public void test_copy_iterator() { final int[] items = new int[] {1, 2, 3}; Iterator<Integer> iter = new Iterator<Integer>() { int i = 0; @Override public boolean hasNext() { return i < items.length; } @Override public Integer next() { return items[i++]; } @Override public void remove() { throw new UnsupportedOperationException(); } }; Object[] result = copy(iter); assertArrayEquals(new Object[] {1, 2, 3}, result); assertEquals(Object[].class, result.getClass()); } | static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_copy_iterator_null() { copy((Iterator<?>)null); } | static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } |
@Test public void test_copy_map() { Map<?, ?> map = newMap("a", 1, "b", 2, "c", 3); MapColumns mc; mc = copy(map); assertArrayEquals(new Object[] {"a", "b", "c"}, mc.keys); assertArrayEquals(new Object[] {1, 2, 3}, mc.values); assertEquals(Object[].class, mc.keys.getClass()); assertEquals(Object[].class, mc.values.getClass()); mc = copy(Collections.emptyMap()); assertArrayEquals(EMPTY_OBJECT_ARRAY, mc.keys); assertArrayEquals(EMPTY_OBJECT_ARRAY, mc.values); } | static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } |
@Test public void test_copy_map_lying_about_its_size() { Map<String, Integer> map = new LyingMap<>(); MapColumns mc; map.put("a", 1); assertEquals(2, map.size()); assertEquals("{a=1}", map.toString()); mc = copy(map); assertArrayEquals(new Object[] {"a"}, mc.keys); assertArrayEquals(new Object[] {1}, mc.values); assertEquals(Object[].class, mc.keys.getClass()); assertEquals(Object[].class, mc.values.getClass()); map.put("b", 2); map.put("c", 3); assertEquals(2, map.size()); assertEquals("{a=1, b=2, c=3}", map.toString()); mc = copy(map); assertArrayEquals(new Object[] {"a", "b", "c"}, mc.keys); assertArrayEquals(new Object[] {1, 2, 3}, mc.values); assertEquals(Object[].class, mc.keys.getClass()); assertEquals(Object[].class, mc.values.getClass()); } | static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_copy_map_null() { copy((Map)null); } | static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } | BasicTools { static Object[] copy(Object[] original) { return Arrays.copyOf(original, original.length, Object[].class); } private BasicTools(); } |
@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)); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test public void test_insert_result_type_is_object_array() { assertSame(Object[].class, insert(new Integer[] {1, 2, 3}, 3, 4).getClass()); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_insert_null() { insert(null, 0, null); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@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"}); } | 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 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 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); } | 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); } | 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); } |
@Test(expected = ArrayIndexOutOfBoundsException.class) public void test_insert_out_of_bounds_low() { insert(EMPTY_OBJECT_ARRAY, -1, "a"); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = ArrayIndexOutOfBoundsException.class) public void test_insert_out_of_bounds_high() { insert(EMPTY_OBJECT_ARRAY, 1, "a"); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@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))); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@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()); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test public void test_insertAll_allocates_new() { Object[] src = new Object[] {1, 2, 3}; assertNotSame(src, insertAll(src, 0, Collections.emptyList())); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_insertAll_out_of_bounds_low() { insertAll(EMPTY_OBJECT_ARRAY, -1, Arrays.asList("a")); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_insertAll_out_of_bounds_high() { insertAll(EMPTY_OBJECT_ARRAY, 1, Arrays.asList("a")); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_insertAll_null() { insertAll(null, 0, Collections.emptyList()); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_insertAll_null_collection() { insertAll(EMPTY_OBJECT_ARRAY, 0, null); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@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()); } | static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } |
@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()); } | @Override protected TypePrinter apply(Class<?> clazz, Type enclosing) { return printer.print(clazz); } | SimpleNameWriter extends TypeWriter { @Override protected TypePrinter apply(Class<?> clazz, Type enclosing) { return printer.print(clazz); } } | SimpleNameWriter extends TypeWriter { @Override protected TypePrinter apply(Class<?> clazz, Type enclosing) { return printer.print(clazz); } SimpleNameWriter(); } | SimpleNameWriter extends TypeWriter { @Override protected TypePrinter apply(Class<?> clazz, Type enclosing) { return printer.print(clazz); } SimpleNameWriter(); } | SimpleNameWriter extends TypeWriter { @Override protected TypePrinter apply(Class<?> clazz, Type enclosing) { return printer.print(clazz); } SimpleNameWriter(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_replace_out_of_bounds_low() { replace(EMPTY_OBJECT_ARRAY, -1, null); } | static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_replace_out_of_bounds_high() { replace(EMPTY_OBJECT_ARRAY, 0, null); } | static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_replace_null() { replace(null, 0, null); } | static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } | BasicTools { static Object[] replace(Object[] original, int index, Object e) { Object[] result = copy(original); result[index] = e; return result; } private BasicTools(); } |
@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)); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test public void test_delete_result_type_is_object_array() { assertSame(Object[].class, delete(new Integer[] {1, 2, 3}, 1).getClass()); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = ArrayIndexOutOfBoundsException.class) public void test_delete_out_of_bounds_low() { delete(new Object[] {"a"}, -1); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = ArrayIndexOutOfBoundsException.class) public void test_delete_out_of_bounds_high() { delete(new Object[] {"a"}, 1); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = NegativeArraySizeException.class) public void test_delete_out_of_bounds() { delete(EMPTY_OBJECT_ARRAY, 0); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_delete_null() { delete(null, 0); } | 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; } | 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; } } | 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(); } | 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(); } | 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(); } |
@Test public void test_deleteAll() { String[] src = new String[] {"a", "b", "c"}; assertArrayEquals(new Object[] {"b", "c"}, deleteAll(src, Arrays.asList("a"))); assertArrayEquals(new Object[] {"a", "c"}, deleteAll(src, Arrays.asList("b"))); assertArrayEquals(new Object[] {"a", "b"}, deleteAll(src, Arrays.asList("c"))); assertArrayEquals(new Object[] {"a", "b", "c"}, deleteAll(src, Arrays.asList("d"))); assertArrayEquals(new Object[] {"a", "b", "c"}, deleteAll(src, Collections.emptyList())); TreeSet<String> filter = new TreeSet<>(String.CASE_INSENSITIVE_ORDER); filter.add("A"); filter.add("B"); assertArrayEquals(new Object[] {"c"}, deleteAll(src, filter)); filter.add("C"); filter.add("D"); assertArrayEquals(new Object[] {}, deleteAll(src, filter)); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_simple_class_creation() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); ClassHandle testHandle = table.createClass("com.test.Test", Object.class); assertFalse(testHandle.isLoaded()); assertTrue(testHandle.isDynamicallyCreated()); Class<?> testClass = testHandle.toClass(); assertEquals("com.test.Test", testClass.getName()); assertSame(Object.class, testClass.getSuperclass()); assertTrue(Modifier.isPublic(testClass.getModifiers())); assertTrue(testHandle.isLoaded()); assertTrue(testHandle.isDynamicallyCreated()); } | ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } |
@Test public void test_deleteAll_result_type_is_object_array() { assertSame(Object[].class, deleteAll(new Integer[] {1, 2, 3}, Collections.emptySet()).getClass()); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_deleteAll_null_array() { deleteAll(null, Collections.emptySet()); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_deleteAll_null_collection() { deleteAll(EMPTY_OBJECT_ARRAY, null); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_deleteAll_columns() { String[] keys = new String[] {"a", "b", "c"}; Integer[] values = new Integer[] {1, 2, 3}; MapColumns mc; mc = deleteAll(keys, values, Arrays.asList("a")); assertArrayEquals(new Object[] {"b", "c"}, mc.keys); assertArrayEquals(new Object[] {2, 3}, mc.values); mc = deleteAll(keys, values, Arrays.asList("b")); assertArrayEquals(new Object[] {"a", "c"}, mc.keys); assertArrayEquals(new Object[] {1, 3}, mc.values); mc = deleteAll(keys, values, Arrays.asList("c")); assertArrayEquals(new Object[] {"a", "b"}, mc.keys); assertArrayEquals(new Object[] {1, 2}, mc.values); mc = deleteAll(keys, values, Arrays.asList("d")); assertArrayEquals(new Object[] {"a", "b", "c"}, mc.keys); assertArrayEquals(new Object[] {1, 2, 3}, mc.values); mc = deleteAll(keys, values, Collections.emptyList()); assertArrayEquals(new Object[] {"a", "b", "c"}, mc.keys); assertArrayEquals(new Object[] {1, 2, 3}, mc.values); TreeSet<String> filter = new TreeSet<>(String.CASE_INSENSITIVE_ORDER); filter.add("A"); filter.add("B"); mc = deleteAll(keys, values, filter); assertArrayEquals(new Object[] {"c"}, mc.keys); assertArrayEquals(new Object[] {3}, mc.values); filter.add("C"); filter.add("D"); mc = deleteAll(keys, values, filter); assertArrayEquals(new Object[] {}, mc.keys); assertArrayEquals(new Object[] {}, mc.values); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_deleteAll_columns_result_type_is_object_array() { String[] keys = new String[] {"a", "b", "c"}; Integer[] values = new Integer[] {1, 2, 3}; MapColumns mc; mc = deleteAll(keys, values, Collections.emptyList()); assertSame(Object[].class, mc.keys.getClass()); assertSame(Object[].class, mc.values.getClass()); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_deleteAll_columns_null_array() { deleteAll(null, EMPTY_OBJECT_ARRAY, Collections.emptySet()); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_deleteAll_columns_null_value_array() { deleteAll(EMPTY_OBJECT_ARRAY, null, Collections.emptySet()); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test(expected = NullPointerException.class) public void test_deleteAll_columns_null_collection() { deleteAll(EMPTY_OBJECT_ARRAY, EMPTY_OBJECT_ARRAY, null); } | static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] deleteAll(Object[] original, Collection<?> c) { Object[] result = new Object[original.length]; requireNonNull(c); int cursor = 0; for (Object o : original) { if (!c.contains(o)) { result[cursor++] = o; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into() { assertArrayEquals(new Object[] {1, 2, 3, 0}, unionInto(new Object[] {1, 2, 3}, new Object[] {0})); assertArrayEquals(new Object[] {1, 3, 2, 0}, unionInto(new Object[] {1, 3, 2}, new Object[] {0, 1})); assertArrayEquals(new Object[] {1, 2, 3, null}, unionInto(new Object[] {1, 2, 3}, new Object[] {null})); assertArrayEquals(new Object[] {1, 2, 3, "a"}, unionInto(new Object[] {1, 2, 3}, new Object[] {"a"})); assertArrayEquals(new Object[] {1, 1, 0}, unionInto(new Object[] {1, 1}, new Object[] {1, 0, 0})); assertArrayEquals(new Object[] {1, 0, 2}, unionInto(new Object[] {}, new Object[] {1, 0, 1, 2, 0, 2})); assertArrayEquals(new Object[] {1, 1}, unionInto(new Object[] {1, 1}, new Object[] {})); assertEquals(Object[].class, unionInto(new Integer[] {1}, new Integer[] {2}).getClass()); } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into_null_arrays() { try { unionInto(null, new Object[0]); fail(); } catch (NullPointerException ignored) {} try { unionInto(new Object[0], null); fail(); } catch (NullPointerException ignored) {} } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_generic_class_creation() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); ClassHandle mapHandle = table.createClass("com.test.Map", AbstractMap.class); Class<?> mapClass = mapHandle.toClass(); assertEquals("com.test.Map", mapClass.getName()); assertSame(AbstractMap.class, mapClass.getSuperclass()); assertEquals("[K, V]", Arrays.toString(mapClass.getTypeParameters())); assertEquals("java.util.AbstractMap<K, V>", mapClass.getGenericSuperclass().toString()); } | ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } |
@Test public void test_union_into_comparator() { assertArrayEquals(new Object[] {0, 1, 2, 3}, unionInto(new Object[] {1, 2, 3}, new Object[] {0}, null)); assertArrayEquals(new Object[] {0, 1, 2, 3}, unionInto(new Object[] {1, 2, 3}, new Object[] {0, 1}, null)); assertArrayEquals(new Object[] {0, 1, 1}, unionInto(new Object[] {1, 1}, new Object[] {1, 0, 0}, null)); assertArrayEquals(new Object[] {0, 1, 2}, unionInto(new Object[] {}, new Object[] {1, 0, 1, 2, 0, 2}, null)); assertArrayEquals(new Object[] {1, 1}, unionInto(new Object[] {1, 1}, new Object[] {}, null)); assertEquals(Object[].class, unionInto(new Integer[] {1}, new Integer[] {2}, null).getClass()); Comparator<Object> c = Collections.reverseOrder(); assertArrayEquals(new Object[] {3, 2, 1, 0}, unionInto(new Object[] {3, 2, 1}, new Object[] {0}, c)); assertArrayEquals(new Object[] {3, 2, 1, 0}, unionInto(new Object[] {3, 2, 1}, new Object[] {0, 1}, c)); assertArrayEquals(new Object[] {1, 1, 0}, unionInto(new Object[] {1, 1}, new Object[] {1, 0, 0}, c)); assertArrayEquals(new Object[] {2, 1, 0}, unionInto(new Object[] {}, new Object[] {1, 0, 1, 2, 0, 2}, c)); assertArrayEquals(new Object[] {1, 1}, unionInto(new Object[] {1, 1}, new Object[] {}, c)); assertEquals(Object[].class, unionInto(new Integer[] {1}, new Integer[] {2}, c).getClass()); } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into_comparator_bad_types() { try { unionInto(new Object[] {1}, new Object[] {"a"}, null); } catch (ClassCastException ignored) {} try { unionInto(new Object[] {1}, new Object[] {null}, null); } catch (NullPointerException ignored) {} Comparator<Object> c = Collections.reverseOrder(); try { unionInto(new Object[] {1}, new Object[] {"a"}, c); } catch (ClassCastException ignored) {} try { unionInto(new Object[] {1}, new Object[] {null}, c); } catch (NullPointerException ignored) {} } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into_comparator_null_arrays() { try { unionInto(null, new Object[0], null); fail(); } catch (NullPointerException ignored) {} try { unionInto(new Object[0], null, null); fail(); } catch (NullPointerException ignored) {} Comparator<Object> c = Collections.reverseOrder(); try { unionInto(null, new Object[0], c); fail(); } catch (NullPointerException ignored) {} try { unionInto(new Object[0], null, c); fail(); } catch (NullPointerException ignored) {} } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into_columns() { String[] keys = new String[] {"a", "b", "a"}; Integer[] values = new Integer[] {1, 2, 3}; MapColumns mc; mc = unionInto(keys, values, new String[] {"+"}, new Integer[] {1}); assertArrayEquals(new Object[] {"a", "b", "a", "+"}, mc.keys); assertArrayEquals(new Object[] {1, 2, 3, 1 }, mc.values); mc = unionInto(keys, values, new String[] {"+", "a"}, new Integer[] {1, 2}); assertArrayEquals(new Object[] {"a", "b", "a", "+"}, mc.keys); assertArrayEquals(new Object[] {2, 2, 3, 1 }, mc.values); mc = unionInto(keys, values, new Object[] {"+", "a", "+", "a", 4}, new Object[] {1, 2, 0, 4, "d"}); assertArrayEquals(new Object[] {"a", "b", "a", "+", 4}, mc.keys); assertArrayEquals(new Object[] {4, 2, 3, 0 , "d"}, mc.values); assertEquals(Object[].class, mc.keys.getClass()); assertEquals(Object[].class, mc.values.getClass()); } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into_columns_null_arrays() { try { unionInto(new Object[0], null, null, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, new Object[0], null, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, null, new Object[0], null); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, null, null, new Object[0]); fail(); } catch (NullPointerException ignored) {} } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into_columns_comparator_natural_ordering() { String[] keys = new String[] {"a", "a", "d"}; Integer[] values = new Integer[] {1, 1, 4}; MapColumns mc; mc = unionInto(keys, values, new String[] {"+"}, new Integer[] {1}, null); assertArrayEquals(new Object[] {"+", "a", "a", "d"}, mc.keys); assertArrayEquals(new Object[] {1, 1, 1, 4}, mc.values); mc = unionInto(keys, values, new String[] {"a", "+", "e", "c"}, new Integer[] {1, 0, 5, 3}, null); assertArrayEquals(new Object[] {"+", "a", "a", "c", "d", "e"}, mc.keys); assertArrayEquals(new Object[] {0, 1, 1, 3, 4, 5}, mc.values); assertEquals(Object[].class, mc.keys.getClass()); assertEquals(Object[].class, mc.values.getClass()); } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into_columns_comparator_reverse_ordering() { String[] keys = new String[] {"d", "a", "a"}; Integer[] values = new Integer[] {4, 1, 1}; Comparator<Object> c = Collections.reverseOrder(); MapColumns mc; mc = unionInto(keys, values, new String[] {"+"}, new Integer[] {1}, c); assertArrayEquals(new Object[] {"d", "a", "a", "+"}, mc.keys); assertArrayEquals(new Object[] {4, 1, 1, 1}, mc.values); mc = unionInto(keys, values, new String[] {"a", "+", "e", "c"}, new Integer[] {1, 0, 5, 3}, c); assertArrayEquals(new Object[] {"e", "d", "c", "a", "a", "+"}, mc.keys); assertArrayEquals(new Object[] {5, 4, 3, 1, 1, 0}, mc.values); assertEquals(Object[].class, mc.keys.getClass()); assertEquals(Object[].class, mc.values.getClass()); } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_union_into_columns_comparator_null_arrays() { try { unionInto(new Object[0], null, null, null, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, new Object[0], null, null, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, null, new Object[0], null, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, null, null, new Object[0], null); fail(); } catch (NullPointerException ignored) {} Comparator<Object> c = Collections.reverseOrder(); try { unionInto(new Object[0], null, null, null, c); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, new Object[0], null, null, c); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, null, new Object[0], null, c); fail(); } catch (NullPointerException ignored) {} try { unionInto(null, null, null, new Object[0], c); fail(); } catch (NullPointerException ignored) {} } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_unionInto_bad_types() { final Object[] EMPTY = new Object[0]; final Object[] items = new Object[] {"a"}; final Object[] oneObj = new Object[] {new Object()}; final Object[] oneNull = new Object[] {null}; @SuppressWarnings("unchecked") Comparator<Object> c = (Comparator)String.CASE_INSENSITIVE_ORDER; try { unionInto(EMPTY, oneObj, null); fail(); } catch (ClassCastException ignored) {} try { unionInto(EMPTY, oneObj, c); fail(); } catch (ClassCastException ignored) {} try { unionInto(EMPTY, oneNull, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(EMPTY, oneNull, c); fail(); } catch (NullPointerException ignored) {} try { unionInto(items, oneObj, null); fail(); } catch (ClassCastException ignored) {} try { unionInto(items, oneObj, c); fail(); } catch (ClassCastException ignored) {} try { unionInto(items, oneNull, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(items, oneNull, c); fail(); } catch (NullPointerException ignored) {} } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_unionInto_columns_bad_types() { final Object[] EMPTY = new Object[0]; final Object[] items = new Object[] {"a"}; final Object[] oneObj = new Object[] {new Object()}; final Object[] oneNull = new Object[] {null}; @SuppressWarnings("unchecked") Comparator<Object> c = (Comparator)String.CASE_INSENSITIVE_ORDER; try { unionInto(EMPTY, EMPTY, oneObj, oneNull, null); fail(); } catch (ClassCastException ignored) {} try { unionInto(EMPTY, EMPTY, oneObj, oneNull, c); fail(); } catch (ClassCastException ignored) {} try { unionInto(EMPTY, EMPTY, oneNull, oneNull, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(EMPTY, EMPTY, oneNull, oneNull, c); fail(); } catch (NullPointerException ignored) {} try { unionInto(items, EMPTY, oneObj, oneNull, null); fail(); } catch (ClassCastException ignored) {} try { unionInto(items, EMPTY, oneObj, oneNull, c); fail(); } catch (ClassCastException ignored) {} try { unionInto(items, EMPTY, oneNull, oneNull, null); fail(); } catch (NullPointerException ignored) {} try { unionInto(items, EMPTY, oneNull, oneNull, c); fail(); } catch (NullPointerException ignored) {} } | static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } | BasicTools { static Object[] unionInto(Object[] original, Object[] additional) { Object[] result = copy(original, original.length + additional.length); int cursor = original.length; for (Object element : additional) { if (indexOf(element, result, 0, cursor) < 0) { result[cursor++] = element; } } return cursor == result.length ? result : copy(result, cursor); } private BasicTools(); } |
@Test public void test_creation_of_instantiated_generic() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); ClassHandle grainHandle = table.createClass("com.test.TestGrain", AbstractGrain.class); Class<?> grainClass = grainHandle.toClass(); assertEquals("com.test.TestGrain", grainClass.getName()); assertSame(AbstractGrain.class, grainClass.getSuperclass()); assertEquals(0, grainClass.getTypeParameters().length); assertSame(AbstractGrain.class, grainClass.getGenericSuperclass()); } | ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } |
@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)); } | @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}); } | 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}); } } | 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); } | 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(); } | 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(); } |
@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())); } | @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)); } | 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)); } } | 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); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicSortedMap1<>(null, "a", 1).withAll(null); } | @Override public ConstSortedMap<K, V> withAll(Map<? extends K, ? extends V> map) { if (map.isEmpty()) { return this; } MapColumns mc = copy(map); return condenseToSortedMap( comparator, unionInto(new Object[] {k0}, new Object[] {v0}, mc.keys, mc.values, comparator)); } | 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)); } } | 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); } | 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(); } | 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(); } |
@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")); } | @Override public ConstSortedMap<K, V> without(Object key) { return !containsKey(key) ? this : BasicCollections.<K, V>emptySortedMap(comparator); } | BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> without(Object key) { return !containsKey(key) ? this : BasicCollections.<K, V>emptySortedMap(comparator); } } | 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); } | 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(); } | 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(); } |
@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())); } | @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keys) { return !keys.contains(k0) ? this : BasicCollections.<K, V>emptySortedMap(comparator); } | BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keys) { return !keys.contains(k0) ? this : BasicCollections.<K, V>emptySortedMap(comparator); } } | 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); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicSortedMap1<>(null, "a", 1).withoutAll(null); } | @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keys) { return !keys.contains(k0) ? this : BasicCollections.<K, V>emptySortedMap(comparator); } | BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override public ConstSortedMap<K, V> withoutAll(Collection<?> keys) { return !keys.contains(k0) ? this : BasicCollections.<K, V>emptySortedMap(comparator); } } | 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); } | 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(); } | 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(); } |
@Test public void test_get_key() { assertEquals("a", new BasicSortedMap1<>(null, "a", 1).getKey(0)); } | @Override K getKey(int index) { if (index == 0) { return k0; } throw new IndexOutOfBoundsException(); } | BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override K getKey(int index) { if (index == 0) { return k0; } throw new IndexOutOfBoundsException(); } } | 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); } | 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(); } | 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(); } |
@Test public void test_get_value() { assertEquals(1, new BasicSortedMap1<>(null, "a", 1).getValue(0)); } | @Override V getValue(int index) { if (index == 0) { return v0; } throw new IndexOutOfBoundsException(); } | BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override V getValue(int index) { if (index == 0) { return v0; } throw new IndexOutOfBoundsException(); } } | 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); } | 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(); } | 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(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_key() { new BasicSortedMap1<>(null, "a", 1).getKey(1); } | @Override K getKey(int index) { if (index == 0) { return k0; } throw new IndexOutOfBoundsException(); } | BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override K getKey(int index) { if (index == 0) { return k0; } throw new IndexOutOfBoundsException(); } } | 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); } | 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(); } | 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(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_out_of_bounds_get_value() { new BasicSortedMap1<>(null, "a", 1).getValue(1); } | @Override V getValue(int index) { if (index == 0) { return v0; } throw new IndexOutOfBoundsException(); } | BasicSortedMap1 extends BasicConstSortedMap<K, V> { @Override V getValue(int index) { if (index == 0) { return v0; } throw new IndexOutOfBoundsException(); } } | 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); } | 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(); } | 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(); } |
@Test public void test_interface_creation() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); ClassHandle testableHandle = table.createClass("com.test.Testable", null); assertFalse(testableHandle.isLoaded()); assertTrue(testableHandle.isDynamicallyCreated()); Class<?> testableClass = testableHandle.toClass(); assertTrue(testableClass.isInterface()); assertEquals("com.test.Testable", testableClass.getName()); assertNull(testableClass.getSuperclass()); assertEquals(0, testableClass.getInterfaces().length); assertTrue(Modifier.isPublic(testableClass.getModifiers())); assertTrue(testableHandle.isLoaded()); assertTrue(testableHandle.isDynamicallyCreated()); } | ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } |
@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()); } | 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 { 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 { 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); } | 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); } | 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); } |
@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())); } | @Override public Iterator<E> iterator() { return new Iter(); } | BasicConstList extends AbstractList<E> implements ConstList<E>, RandomAccess, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } } | BasicConstList extends AbstractList<E> implements ConstList<E>, RandomAccess, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } BasicConstList(); } | 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(); } | 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(); } |
@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()); } | @Override public Iterator<E> iterator() { return new Iter(); } | BasicConstList extends AbstractList<E> implements ConstList<E>, RandomAccess, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } } | BasicConstList extends AbstractList<E> implements ConstList<E>, RandomAccess, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } BasicConstList(); } | 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(); } | 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(); } |
@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); } } | @Deprecated @Override public final boolean add(E e) { throw unsupported(); } | BasicConstList extends AbstractList<E> implements ConstList<E>, RandomAccess, Serializable { @Deprecated @Override public final boolean add(E e) { throw unsupported(); } } | BasicConstList extends AbstractList<E> implements ConstList<E>, RandomAccess, Serializable { @Deprecated @Override public final boolean add(E e) { throw unsupported(); } BasicConstList(); } | 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(); } | 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(); } |
@Test public void test_emptySortedMap() { assertSame(BasicSortedMap0.instance(null), emptySortedMap(null)); Comparator<Object> reverse = reverseOrder(); assertSame(BasicSortedSet0.instance(reverse).comparator(), emptySortedMap(reverse).comparator()); } | @Override public Comparator<? super K> comparator() { return comparator; } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { @Override public Comparator<? super K> comparator() { return comparator; } } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { @Override public Comparator<? super K> comparator() { return comparator; } BasicConstSortedMap(Comparator<? super K> comparator); } | 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(); } | 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(); } |
@Test public void test_construction_permutations() { for (int a = 0; a < 6; a++) { compare(newSortedMap(null, a, a+1), sortedMapOf(null, a, a+1)); for (int b = 0; b < 6; b++) { compare(newSortedMap(null, a, a, b, b), sortedMapOf(null, a, a, b, b)); for (int c = 0; c < 6; c++) { compare(newSortedMap(null, a, a, b, b, c, c), sortedMapOf(null, a, a, b, b, c, c)); for (int d = 0; d < 6; d++) { compare( newSortedMap(null, a, a, b, b, c, c, d, d), sortedMapOf(null, a, a, b, b, c, c, d, d)); for (int e = 0; e < 6; e++) { compare( newSortedMap(null, a, a, b, b, c, c, d, d, e, e), sortedMapOf(null, a, a, b, b, c, c, d, d, e, e)); for (int f = 0; f < 6; f++) { Integer[] ary = new Integer[] {a, b, c, d, e, f}; SortedMap<Integer, Integer> expected = newSortedMap(null, a, a, b, b, c, c, d, d, e, e, f, f); Map<Integer, Integer> plainMap = newMap(a, a, b, b, c, c, d, d, e, e, f, f); compare(expected, asSortedMap(null, ary, ary)); compare(expected, asSortedMap(expected)); compare(expected, asSortedMap(null, plainMap)); } } } } } } } | int compare(K left, K right) { return ObjectTools.compare(left, right, comparator); } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { int compare(K left, K right) { return ObjectTools.compare(left, right, comparator); } } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { int compare(K left, K right) { return ObjectTools.compare(left, right, comparator); } BasicConstSortedMap(Comparator<? super K> comparator); } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { int compare(K left, K right) { return ObjectTools.compare(left, right, 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(); } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { int compare(K left, K right) { return ObjectTools.compare(left, right, 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(); } |
@Test public void test_construction_permutations_reverse() { Comparator<Object> reverse = reverseOrder(); for (int a = 0; a < 6; a++) { compare(newSortedMap(reverse, a, a+1), sortedMapOf(reverse, a, a+1)); for (int b = 0; b < 6; b++) { compare(newSortedMap(reverse, a, a, b, b), sortedMapOf(reverse, a, a, b, b)); for (int c = 0; c < 6; c++) { compare(newSortedMap(reverse, a, a, b, b, c, c), sortedMapOf(reverse, a, a, b, b, c, c)); for (int d = 0; d < 6; d++) { compare( newSortedMap(reverse, a, a, b, b, c, c, d, d), sortedMapOf(reverse, a, a, b, b, c, c, d, d)); for (int e = 0; e < 6; e++) { compare( newSortedMap(reverse, a, a, b, b, c, c, d, d, e, e), sortedMapOf(reverse, a, a, b, b, c, c, d, d, e, e)); for (int f = 0; f < 6; f++) { Integer[] ary = new Integer[] {a, b, c, d, e, f}; SortedMap<Integer, Integer> expected = newSortedMap(reverse, a, a, b, b, c, c, d, d, e, e, f, f); Map<Integer, Integer> plainMap = newMap(a, a, b, b, c, c, d, d, e, e, f, f); compare(expected, asSortedMap(reverse, ary, ary)); compare(expected, asSortedMap(expected)); compare(expected, asSortedMap(reverse, plainMap)); } } } } } } } | int compare(K left, K right) { return ObjectTools.compare(left, right, comparator); } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { int compare(K left, K right) { return ObjectTools.compare(left, right, comparator); } } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { int compare(K left, K right) { return ObjectTools.compare(left, right, comparator); } BasicConstSortedMap(Comparator<? super K> comparator); } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { int compare(K left, K right) { return ObjectTools.compare(left, right, 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(); } | BasicConstSortedMap extends BasicConstMap<K, V> implements ConstSortedMap<K, V> { int compare(K left, K right) { return ObjectTools.compare(left, right, 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(); } |
@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); } | @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } | BasicSortedSet0 extends BasicConstSortedSet<E> { @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } } | 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); } | 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(); } | 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(); } |
@Test public void test_immutable() { assert_sorted_set_immutable(BasicSortedSet0.instance(null)); } | @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } | BasicSortedSet0 extends BasicConstSortedSet<E> { @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } } | 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); } | 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(); } | 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(); } |
@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()); } | @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } | BasicSortedSet0 extends BasicConstSortedSet<E> { @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } } | 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); } | 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(); } | 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(); } |
@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()); } | @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } | BasicSortedSet0 extends BasicConstSortedSet<E> { @SuppressWarnings("unchecked") static <E> BasicSortedSet0<E> instance(Comparator<? super E> comparator) { return comparator == null ? NATURAL_INSTANCE : new BasicSortedSet0<>(comparator); } } | 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); } | 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(); } | 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(); } |
@Test public void test_sub_interface_creation() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); ClassHandle raHandle = table.createClass("com.test.RandomAccess", RandomAccess.class); Class<?> raClass = raHandle.toClass(); assertTrue(raClass.isInterface()); assertEquals("com.test.RandomAccess", raClass.getName()); assertNull(raClass.getSuperclass()); assertSame(RandomAccess.class, raClass.getInterfaces()[0]); } | ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } |
@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())); } } } } } } } | @Override public Iterator<E> iterator() { return new Iter(); } | BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } } | BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } BasicConstSet(); } | 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(); } | 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(); } |
@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())); } | @Override public Iterator<E> iterator() { return new Iter(); } | BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } } | BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } BasicConstSet(); } | 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(); } | 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(); } |
@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()); } | @Override public Iterator<E> iterator() { return new Iter(); } | BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } } | BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Override public Iterator<E> iterator() { return new Iter(); } BasicConstSet(); } | 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(); } | 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(); } |
@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); } } | @Deprecated @Override public final boolean add(E e) { throw unsupported(); } | BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Deprecated @Override public final boolean add(E e) { throw unsupported(); } } | BasicConstSet extends AbstractSet<E> implements ConstSet<E>, Serializable { @Deprecated @Override public final boolean add(E e) { throw unsupported(); } BasicConstSet(); } | 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(); } | 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(); } |
@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)); } | @Override public ConstList<E> with(E e) { return with(elements.length, e); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> with(E e) { return with(elements.length, e); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> with(E e) { return with(elements.length, e); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@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)); } | @Override public ConstList<E> with(E e) { return with(elements.length, e); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> with(E e) { return with(elements.length, e); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> with(E e) { return with(elements.length, e); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@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); } | @Override public ConstList<E> with(E e) { return with(elements.length, e); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> with(E e) { return with(elements.length, e); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> with(E e) { return with(elements.length, e); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@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())); } | @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_withAll_throws() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).withAll(null); } | @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@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())); } | @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@Test public void test_generic_interface_creation() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); ClassHandle iMapHandle = table.createClass("com.test.IMap", Map.class); Class<?> iMapClass = iMapHandle.toClass(); assertEquals("com.test.IMap", iMapClass.getName()); assertEquals("[K, V]", Arrays.toString(iMapClass.getTypeParameters())); assertSame(Map.class, iMapClass.getInterfaces()[0]); assertEquals("java.util.Map<K, V>", iMapClass.getGenericInterfaces()[0].toString()); assertNull(iMapClass.getSuperclass()); assertNull(iMapClass.getGenericSuperclass()); } | ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } |
@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()); } | @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_withAll_index_throws() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).withAll(0, null); } | @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> withAll(Collection<? extends E> c) { return withAll(elements.length, c); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@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)); } | @Override public ConstList<E> replace(int index, E e) { return new BasicListN<>(BasicTools.replace(elements, index, e)); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> replace(int index, E e) { return new BasicListN<>(BasicTools.replace(elements, index, e)); } } | 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); } | 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(); } | 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(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_replace_out_of_bounds() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).replace(6, 9); } | @Override public ConstList<E> replace(int index, E e) { return new BasicListN<>(BasicTools.replace(elements, index, e)); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> replace(int index, E e) { return new BasicListN<>(BasicTools.replace(elements, index, e)); } } | 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); } | 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(); } | 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(); } |
@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)); } | @Override public ConstList<E> without(Object o) { int index = ArrayTools.indexOf(o, elements); return index < 0 ? this : delete(index); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> without(Object o) { int index = ArrayTools.indexOf(o, elements); return index < 0 ? this : delete(index); } } | 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); } | 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(); } | 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(); } |
@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)); } | @Override public ConstList<E> delete(int index) { return condenseToList(BasicTools.delete(elements, index)); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> delete(int index) { return condenseToList(BasicTools.delete(elements, index)); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> delete(int index) { return condenseToList(BasicTools.delete(elements, index)); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@Test(expected = IndexOutOfBoundsException.class) public void test_delete_out_of_bounds() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).delete(6); } | @Override public ConstList<E> delete(int index) { return condenseToList(BasicTools.delete(elements, index)); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> delete(int index) { return condenseToList(BasicTools.delete(elements, index)); } } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> delete(int index) { return condenseToList(BasicTools.delete(elements, index)); } @SuppressWarnings("unchecked") BasicListN(Object[] elements); } | 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(); } | 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(); } |
@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)); } | @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); } | 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); } } | 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); } | 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(); } | 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(); } |
@Test(expected = NullPointerException.class) public void test_withoutAll_throws() { new BasicListN<>(new Object[] {1, 2, 3, 4, 5, 6}).withoutAll(null); } | @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); } | 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); } } | 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); } | 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(); } | 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(); } |
@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)); } | @Override public ConstList<E> subList(int fromIndex, int toIndex) { return condenseToList(Arrays.copyOfRange(elements, fromIndex, toIndex)); } | BasicListN extends BasicConstList<E> { @Override public ConstList<E> subList(int fromIndex, int toIndex) { return condenseToList(Arrays.copyOfRange(elements, fromIndex, toIndex)); } } | 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); } | 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(); } | 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(); } |
@Test public void test_enum_creation() { TypeTable table = new TypeTable(new NamingPolicy(), ConfigurableTypePolicy.STANDARD); ClassHandle enumHandle = table.createClass("com.test.TestEnum", Enum.class); Class<?> enumClass = enumHandle.toClass(); assertTrue(enumClass.isEnum()); assertEquals("com.test.TestEnum", enumClass.getName()); assertSame(Enum.class, enumClass.getSuperclass()); assertEquals("java.lang.Enum<E>", enumClass.getGenericSuperclass().toString()); assertTrue(Modifier.isPublic(enumClass.getModifiers())); } | ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } | TypeTable { ClassHandle createClass(String name, Class<?> inherits) { try { CtClass newClass = inherits == null || inherits.isInterface() ? classPool.makeInterface(name) : classPool.makeClass(name); newClass.setModifiers(Modifier.setPublic(newClass.getModifiers())); if (inherits != null) { CtClass baseClass = classPool.get(inherits.getName()); ClassSignature baseSignature = baseClass.getGenericSignature() != null ? toClassSignature(baseClass.getGenericSignature()) : null; TypeParameter[] params = baseSignature != null ? baseSignature.getParameters() : new TypeParameter[0]; if (params.length > 0) { assignGenericSignature(newClass, baseClass, baseSignature); } if (inherits.isInterface()) { newClass.setInterfaces(new CtClass[] {baseClass}); } else { newClass.setSuperclass(baseClass); if (inherits == Enum.class) { newClass.setModifiers(newClass.getModifiers() | Modifier.ENUM); } } } return new ClassHandle(name, null, newClass); } catch (NotFoundException | CannotCompileException | BadBytecode e) { throw new RuntimeException(e); } } TypeTable(NamingPolicy namingPolicy, TypePolicy typePolicy); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.