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 UnsupportedOpe... | 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.getC... | 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); assert... | 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(... | 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(... | 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(... | 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(... | 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(... |
@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}, ins... | 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, in... | 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... | 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... | 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... | 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... |
@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, in... | 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... | 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... | 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... | 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... |
@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, in... | 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... | 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... | 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... | 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... |
@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, in... | 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... | 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... | 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... | 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... |
@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, in... | 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... | 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... | 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... | 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... |
@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, in... | 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... | 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... | 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... | 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... |
@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, in... | 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... | 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... | 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... | 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... |
@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).getClas... | 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)); assert... | 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")))... | 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 = testHa... | 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(inherit... | 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... | 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... | 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... | 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... |
@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(k... | 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.ge... | 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},... | 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 ? res... | 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... | 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... | 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... | 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... |
@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 ? res... | 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... | 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... | 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... | 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... |
@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(Abst... | 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(inherit... | 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... | 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... | 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... | 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... |
@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 Ob... | 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 ? res... | 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... | 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... | 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... | 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... |
@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 {... | 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 ? res... | 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... | 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... | 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... | 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... |
@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... | 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 ? res... | 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... | 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... | 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... | 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... |
@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,... | 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 ? res... | 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... | 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... | 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... | 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... |
@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(); } ca... | 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 ? res... | 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... | 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... | 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... | 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... |
@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); ass... | 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 ? res... | 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... | 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... | 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... | 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... |
@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(... | 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 ? res... | 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... | 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... | 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... | 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... |
@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[... | 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 ? res... | 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... | 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... | 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... | 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... |
@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_ORD... | 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 ? res... | 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... | 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... | 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... | 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... |
@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_INSENSI... | 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 ? res... | 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... | 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... | 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... | 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... |
@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", grainC... | 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(inherit... | 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... | 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... | 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... | 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... |
@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<>(reve... | @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 B... | 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 O... | 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 O... | 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 O... | 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 O... |
@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())); ... | @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)); ... | 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)); ... |
@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)); ... | 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)); ... |
@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(re... | @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 si... | 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 si... |
@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,... | @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); @Ove... | 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); @Ove... |
@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); @Ove... | 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); @Ove... |
@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(); @Overrid... | 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(); @Overrid... |
@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(); @Overr... | 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(); @Overr... |
@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(); @Overrid... | 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(); @Overrid... |
@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(); @Overr... | 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(); @Overr... |
@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... | 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(inherit... | 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... | 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... | 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... | 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... |
@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)... | 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.getProp... | 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 p... | 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 p... | 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 p... | 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 p... |
@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).it... | @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 to... | 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 to... |
@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(BasicList... | @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 to... | 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 to... |
@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 fro... | 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 fro... |
@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 abstr... | 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 abstr... |
@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,... | 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(); @Ove... | 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(); @Ove... |
@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 (i... | 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(); @Ove... | 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(); @Ove... |
@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();... | 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();... |
@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();... | 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();... |
@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.nul... | @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();... | 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();... |
@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(); assert... | @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();... | 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();... |
@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.... | 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(inherit... | 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... | 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... | 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... | 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... |
@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(... | @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 @... | 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 @... |
@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(newSe... | @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 @... | 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 @... |
@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,... | @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 @... | 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 @... |
@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);... | 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);... |
@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... | 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... |
@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,... | @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... | 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... |
@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... | 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... |
@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 lastIn... | 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 lastIn... |
@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 lastIn... | 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 lastIn... |
@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))); compar... | @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 lastIn... | 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 lastIn... |
@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(... | 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(inherit... | 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... | 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... | 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... | 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... |
@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 lastIn... | 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 lastIn... |
@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 lastIn... | 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 lastIn... |
@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); @O... | 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); @O... |
@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); @O... | 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); @O... |
@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 indexO... | 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 indexO... |
@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 ... | 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 ... |
@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 ... | 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 ... |
@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... | @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[] element... | 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[] element... | 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[] element... |
@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[] element... | 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[] element... | 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[] element... |
@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 i... | 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 i... |
@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", enumCla... | 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(inherit... | 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... | 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... | 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... | 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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.