@SuppressWarnings("unchecked") public <ArrayTemplate extends AbstractArrayTemplate<E>, E extends Number> void testNumberArray( Class<ArrayTemplate> templateClass, ArrayDataSchema schema, List<E> castTo, List<? extends Number> castFrom) throws InstantiationException, IllegalAccessException { // test insert non-native, converted to element type on set ArrayTemplate array1 = templateClass.newInstance(); array1.addAll((List<E>) castFrom); for (int i = 0; i < castTo.size(); ++i) { assertEquals(castTo.get(i), array1.get(i)); assertEquals(array1.data().get(i), castTo.get(i)); } // test underlying is non-native, convert on get to element type on get. DataList dataList2 = new DataList(castFrom); ArrayTemplate array2 = DataTemplateUtil.wrap(dataList2, schema, templateClass); for (int i = 0; i < castTo.size(); ++i) { assertSame(dataList2.get(i), castFrom.get(i)); assertEquals(castTo.get(i), array2.get(i)); } }
public <ArrayTemplate extends AbstractArrayTemplate<E>, E> void testArray( Class<ArrayTemplate> templateClass, ArrayDataSchema schema, List<E> input, List<E> adds) throws InstantiationException, IllegalAccessException { // out.println("Testing " + templateClass.getName() + " " + schema.toString()); // constructors and addAll ArrayTemplate array1 = templateClass.newInstance(); array1.addAll(input); assertEquals(input, array1); /* Constructor[] constructors = templateClass.getConstructors(); for (Constructor c : constructors) { out.println(c); } */ try { int size = input.size(); // constructor(int capacity) Constructor<ArrayTemplate> capacityConstructor = templateClass.getConstructor(int.class); ArrayTemplate array = capacityConstructor.newInstance(input.size()); assertEquals(array, Collections.emptyList()); array.addAll(input); assertEquals(input, array); array.clear(); assertEquals(size, input.size()); // constructor(Collection<E>) Constructor<ArrayTemplate> collectionConstructor = templateClass.getConstructor(Collection.class); array = collectionConstructor.newInstance(input); assertEquals(input, array); array.clear(); assertEquals(size, input.size()); // constructor(DataList) Constructor<ArrayTemplate> dataListConstructor = templateClass.getConstructor(DataList.class); array = dataListConstructor.newInstance(array1.data()); assertEquals(array1, array); assertEquals(input, array); array.clear(); assertEquals(array1, array); } catch (Exception e) { assertSame(e, null); } // test wrapping array1.clear(); array1.addAll(input); DataList dataList2 = new DataList(); ArrayTemplate array2 = DataTemplateUtil.wrap(dataList2, schema, templateClass); // with schema arg for (E e : input) { if (e instanceof DataTemplate) { dataList2.add(((DataTemplate<?>) e).data()); } else if (e instanceof Enum) { dataList2.add(e.toString()); } else { dataList2.add(e); } } assertEquals(array1, array2); ArrayTemplate array2a = DataTemplateUtil.wrap(dataList2, templateClass); // without schema arg assertEquals(array1, array2a); assertSame(array2.data(), array2a.data()); // schema() ArrayDataSchema schema1 = array1.schema(); assertTrue(schema1 != null); assertEquals(schema1.getType(), DataSchema.Type.ARRAY); assertEquals(schema1, schema); // add(E element), get(int index) ArrayTemplate array3 = templateClass.newInstance(); for (int i = 0; i < adds.size(); ++i) { E value = adds.get(i); assertTrue(array3.add(value)); assertEquals(array3.get(i), value); assertSame(array3.get(i), value); assertTrue(array3.toString().contains(value.toString())); } assertEquals(array3, adds); // add(int index, E element), get(int index) ArrayTemplate array4 = templateClass.newInstance(); for (int i = 0; i < adds.size(); ++i) { E value = adds.get(adds.size() - i - 1); array4.add(0, value); assertEquals(array4.get(0), value); assertSame(array4.get(0), value); } assertEquals(array4, adds); // clear(), isEmpty(), size() assertEquals(array4.size(), adds.size()); assertFalse(array4.isEmpty()); array4.clear(); assertTrue(array4.isEmpty()); assertEquals(array4.size(), 0); // equals() array4.clear(); array4.addAll(input); assertTrue(array4.equals(array4)); assertTrue(array4.equals(input)); assertFalse(array4.equals(null)); assertFalse(array4.equals(adds)); for (int i = 0; i <= input.size(); ++i) { List<E> subList = input.subList(0, i); ArrayTemplate a = templateClass.newInstance(); a.addAll(subList); if (i == input.size()) { assertTrue(array4.equals(subList)); assertTrue(array4.equals(a)); } else { assertFalse(array4.equals(subList)); assertFalse(array4.equals(a)); } } // hashcode() ArrayTemplate array5 = templateClass.newInstance(); array5.addAll(input); assertEquals(array5.hashCode(), array5.data().hashCode()); array5.addAll(adds); assertEquals(array5.hashCode(), array5.data().hashCode()); array5.clear(); int lastHash = 0; for (int i = 0; i < input.size(); ++i) { array5.add(input.get(i)); int newHash = array5.hashCode(); if (i > 0) { assertFalse(newHash == lastHash); } lastHash = newHash; } // indexOf(Object o), lastIndexOf(Object o) ArrayTemplate array6 = templateClass.newInstance(); array6.addAll(adds); for (E e : adds) { assertEquals(array6.indexOf(e), adds.indexOf(e)); assertEquals(array6.lastIndexOf(e), adds.lastIndexOf(e)); } // remove(int index), subList(int fromIndex, int toIndex) ArrayTemplate array7 = templateClass.newInstance(); array7.addAll(input); ArrayTemplate array8 = templateClass.newInstance(); array8.addAll(input); for (int i = 0; i < input.size(); ++i) { array7.remove(0); assertEquals(array7, input.subList(i + 1, input.size())); assertEquals(array7, array8.subList(i + 1, input.size())); } // removeRange(int fromIndex, int toIndex), subList(int fromIndex, int toIndex) for (int from = 0; from < input.size(); ++from) { for (int to = from + 1; to <= input.size(); ++to) { ArrayTemplate arrayRemove = templateClass.newInstance(); arrayRemove.addAll(input); InternalList<E> reference = new InternalList<E>(input); arrayRemove.removeRange(from, to); reference.removeRange(from, to); assertEquals(reference, arrayRemove); } } // set(int index, E element) ArrayTemplate array9 = templateClass.newInstance(); array9.addAll(input); InternalList<E> reference9 = new InternalList<E>(input); for (int i = 0; i < input.size() / 2; ++i) { int k = input.size() - i - 1; E lo = array9.get(i); E hi = array9.get(k); E hiPrev = array9.set(k, lo); E loPrev = array9.set(i, hi); E refHiPrev = reference9.set(k, lo); E refLoPrev = reference9.set(i, hi); assertEquals(hiPrev, refHiPrev); assertEquals(loPrev, refLoPrev); assertEquals(array9.get(i), reference9.get(i)); assertEquals(array9.get(k), reference9.get(k)); } // clone Exception exc = null; ArrayTemplate array10 = templateClass.newInstance(); array10.addAll(input); try { exc = null; @SuppressWarnings("unchecked") ArrayTemplate array10Clone = (ArrayTemplate) array10.clone(); assertEquals(array10Clone, array10); assertTrue(array10Clone != array10); array10Clone.remove(0); assertEquals(array10Clone.size(), array10.size() - 1); assertFalse(array10Clone.equals(array10)); assertTrue(array10.containsAll(array10Clone)); array10.remove(0); assertEquals(array10Clone, array10); } catch (CloneNotSupportedException e) { exc = e; } assert (exc == null); // contains for (int i = 0; i < input.size(); ++i) { ArrayTemplate array = templateClass.newInstance(); E v = input.get(i); array.add(v); for (int k = 0; k < input.size(); ++k) { if (k == i) assertTrue(array.contains(v)); else assertFalse(array.contains(input.get(k))); } } // containsAll ArrayTemplate arrayContainsAll = templateClass.newInstance(); arrayContainsAll.addAll(input); arrayContainsAll.addAll(adds); InternalList<E> referenceContainsAll = new InternalList<E>(input); referenceContainsAll.addAll(adds); for (int from = 0; from < arrayContainsAll.size(); ++from) { for (int to = from + 1; to <= arrayContainsAll.size(); ++to) { boolean testResult = arrayContainsAll.containsAll(referenceContainsAll.subList(from, to)); boolean referenceResult = referenceContainsAll.containsAll(referenceContainsAll.subList(from, to)); assertEquals(testResult, referenceResult); assertTrue(testResult); assertTrue(referenceResult); } boolean testResult2 = arrayContainsAll.subList(from, arrayContainsAll.size()).containsAll(referenceContainsAll); boolean referenceResult2 = referenceContainsAll .subList(from, arrayContainsAll.size()) .containsAll(referenceContainsAll); // out.println("from " + from + " test " + testResult2 + " ref " + referenceResult2); assertEquals(testResult2, referenceResult2); } // removeAll InternalList<E> referenceListRemoveAll = new InternalList<E>(input); referenceListRemoveAll.addAll(adds); for (int from = 0; from < referenceListRemoveAll.size(); ++from) { for (int to = from + 1; to <= referenceListRemoveAll.size(); ++to) { ArrayTemplate arrayRemoveAll = templateClass.newInstance(); arrayRemoveAll.addAll(referenceListRemoveAll); InternalList<E> referenceRemoveAll = new InternalList<E>(referenceListRemoveAll); boolean testResult = arrayRemoveAll.removeAll(referenceListRemoveAll.subList(from, to)); boolean referenceResult = referenceRemoveAll.removeAll(referenceListRemoveAll.subList(from, to)); // out.println("from " + from + " to " + to + " test " + testResult + " " + arrayRemoveAll + // " ref " + referenceResult + " " + referenceRemoveAll); assertEquals(arrayRemoveAll, referenceRemoveAll); assertEquals(testResult, referenceResult); assertTrue(testResult); assertTrue(referenceResult); } } // retainAll InternalList<E> referenceListRetainAll = new InternalList<E>(input); referenceListRetainAll.addAll(adds); for (int from = 0; from < referenceListRetainAll.size(); ++from) { for (int to = from + 1; to <= referenceListRetainAll.size(); ++to) { ArrayTemplate arrayRetainAll = templateClass.newInstance(); arrayRetainAll.addAll(referenceListRetainAll); InternalList<E> referenceRetainAll = new InternalList<E>(referenceListRetainAll); boolean testResult = arrayRetainAll.removeAll(referenceListRetainAll.subList(from, to)); boolean referenceResult = referenceRetainAll.removeAll(referenceListRetainAll.subList(from, to)); // out.println("from " + from + " to " + to + " test " + testResult + " " + arrayRetainAll + // " ref " + referenceResult + " " + referenceRetainAll); assertEquals(arrayRetainAll, referenceRetainAll); assertEquals(testResult, referenceResult); assertTrue(testResult); assertTrue(referenceResult); } } // Iterator ArrayTemplate arrayIt = templateClass.newInstance(); arrayIt.addAll(input); arrayIt.addAll(adds); for (Iterator<E> it = arrayIt.iterator(); it.hasNext(); ) { it.next(); it.remove(); } assertTrue(arrayIt.isEmpty()); // ListIterator hasNext, hasPrevious, next, previous ArrayTemplate arrayListIt = templateClass.newInstance(); arrayListIt.addAll(input); arrayListIt.addAll(adds); for (int i = 0; i <= arrayListIt.size(); ++i) { ListIterator<E> it = arrayListIt.listIterator(i); if (i > 0) { int save = it.nextIndex(); assertTrue(it.hasPrevious()); assertEquals(it.previous(), arrayListIt.get(i - 1)); it.next(); assertEquals(it.nextIndex(), save); } else { assertFalse(it.hasPrevious()); } if (i < arrayListIt.size()) { int save = it.previousIndex(); assertTrue(it.hasNext()); assertEquals(it.next(), arrayListIt.get(i)); it.previous(); assertEquals(it.previousIndex(), save); } else { assertFalse(it.hasNext()); } assertEquals(it.nextIndex(), i); assertEquals(it.previousIndex(), i - 1); } // ListIterator remove for (ListIterator<E> it = arrayListIt.listIterator(); it.hasNext(); ) { it.next(); it.remove(); } assertTrue(arrayListIt.isEmpty()); // ListIterator add arrayListIt.clear(); { ListIterator<E> it = arrayListIt.listIterator(); for (E e : adds) { it.add(e); } } assertEquals(arrayListIt, adds); // ListIterator set for (int i = 0; i < adds.size(); ++i) { ListIterator<E> it = arrayListIt.listIterator(i); it.next(); E value = adds.get(adds.size() - i - 1); it.set(value); } for (int i = 0; i < adds.size(); ++i) { E value = adds.get(adds.size() - i - 1); assertEquals(arrayListIt.get(i), value); } }
@SuppressWarnings("unchecked") public <ArrayTemplate extends AbstractArrayTemplate<E>, E> void testArrayBadInput( Class<ArrayTemplate> templateClass, ArrayDataSchema schema, List<E> good, List<Object> badInput, List<Object> badOutput) throws InstantiationException, IllegalAccessException { Exception exc = null; ArrayTemplate arrayTemplateBad = templateClass.newInstance(); DataList badDataList = new DataList(); ArrayTemplate badWrappedArrayTemplate = DataTemplateUtil.wrap(badDataList, schema, templateClass); List<E> badIn = (List<E>) badInput; // add(E element) for (E o : badIn) { try { exc = null; arrayTemplateBad.add(o); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(o == null || exc instanceof ClassCastException); assertTrue(o != null || exc instanceof NullPointerException); } // add(int index, E element) for (Object o : badIn) { try { exc = null; arrayTemplateBad.add(0, (E) o); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(o == null || exc instanceof ClassCastException); assertTrue(o != null || exc instanceof NullPointerException); } // addAll(Collection<E> c) try { exc = null; arrayTemplateBad.addAll(badIn); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(exc instanceof ClassCastException); // set(int index, E element) arrayTemplateBad.addAll(good); assertTrue(arrayTemplateBad.size() > 1); for (Object o : badIn) { try { exc = null; arrayTemplateBad.set(0, (E) o); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(o == null || exc instanceof ClassCastException); assertTrue(o != null || exc instanceof NullPointerException); } // listIterator add for (Object o : badIn) { try { exc = null; ListIterator<E> it = arrayTemplateBad.listIterator(0); it.add((E) o); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(o == null || exc instanceof ClassCastException); assertTrue(o != null || exc instanceof NullPointerException); } // listIterator set for (Object o : badIn) { try { exc = null; ListIterator<E> it = arrayTemplateBad.listIterator(0); it.next(); it.set((E) o); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(o == null || exc instanceof ClassCastException); assertTrue(o != null || exc instanceof NullPointerException); } badDataList.clear(); badDataList.addAll(badOutput); badWrappedArrayTemplate = DataTemplateUtil.wrap(badDataList, schema, templateClass); // Get returns bad for (int i = 0; i < badWrappedArrayTemplate.size(); ++i) { try { exc = null; badWrappedArrayTemplate.get(i); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(exc instanceof TemplateOutputCastException); } // Set returns bad badDataList.clear(); badDataList.addAll(badOutput); assertEquals(badWrappedArrayTemplate.size(), badOutput.size()); for (int i = 0; i < badWrappedArrayTemplate.size(); ++i) { try { exc = null; badWrappedArrayTemplate.set(i, good.get(0)); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(exc instanceof TemplateOutputCastException); } // Remove returns bad badDataList.clear(); badDataList.addAll(badOutput); assertEquals(badWrappedArrayTemplate.size(), badOutput.size()); for (int i = 0; i < badWrappedArrayTemplate.size(); ++i) { try { exc = null; badWrappedArrayTemplate.remove(0); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(exc instanceof TemplateOutputCastException); } // Iterator returns bad for (Object o : badOutput) { badDataList.clear(); badDataList.add(o); try { exc = null; badWrappedArrayTemplate.iterator().next(); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(exc instanceof TemplateOutputCastException); } // ListIterator returns bad for (Object o : badOutput) { badDataList.clear(); badDataList.add(o); try { exc = null; badWrappedArrayTemplate.listIterator().next(); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(exc instanceof TemplateOutputCastException); } for (Object o : badOutput) { badDataList.clear(); badDataList.add(o); try { exc = null; badWrappedArrayTemplate.listIterator(badWrappedArrayTemplate.size()).previous(); } catch (Exception e) { exc = e; } assertTrue(exc != null); assertTrue(exc instanceof TemplateOutputCastException); } }