Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
1
method2testcases
stringlengths
118
6.63k
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public boolean remove(int value) { return myList.remove(value); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify1() { PETRIFIED_LIST.remove(TEST_INT); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify2() { PETRIFIED_LIST.remove(0, 1); }
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public boolean removeAll(Collection<?> collection) { return myList.removeAll(collection); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify1() { PETRIFIED_LIST.removeAll(TEST_INT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify2() { PETRIFIED_LIST.removeAll(TEST_INT_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify3() { PETRIFIED_LIST.removeAll(TEST_INT_ARRAY_LIST); }
### Question: SpeedKey extends AbstractSpecialKey implements SpecialColumnDetector { @Override public boolean markSpecialColumn(MetaDataInfo metaData, String columnName) { boolean wasDetected = false; if (!metaData.hasTypeForSpecialKey(SpeedKey.DEFAULT)) { SpecialKey specialKey = detectColumn(columnName); if (specialKey != null) { metaData.setSpecialKey(columnName, specialKey, metaData); wasDetected = true; } } return wasDetected; } SpeedKey(); SpeedKey(SpeedUnit unit); @Override SpeedUnit getKeyUnit(); @Override boolean markSpecialColumn(MetaDataInfo metaData, String columnName); @Override SpecialKey detectColumn(String columnName); static boolean isSpeed(String columnName); static final SpeedKey DEFAULT; }### Answer: @Test public void testMarkSpecialColumn() { DefaultMetaDataInfo metaData = new DefaultMetaDataInfo(); String column = "Speed (m/s)"; metaData.addKey(column, Double.class, this); SpeedKey.DEFAULT.markSpecialColumn(metaData, column); SpeedKey actual = (SpeedKey)metaData.getSpecialTypeForKey(column); SpeedKey expected = new SpeedKey(SpeedUnit.METERS_PER_SECOND); Assert.assertEquals(expected, actual); Assert.assertEquals(expected.getKeyUnit(), actual.getKeyUnit()); metaData = new DefaultMetaDataInfo(); column = "Speed (km/hr)"; metaData.addKey(column, Double.class, this); SpeedKey.DEFAULT.markSpecialColumn(metaData, column); actual = (SpeedKey)metaData.getSpecialTypeForKey(column); expected = new SpeedKey(SpeedUnit.KILOMETERS_PER_HOUR); Assert.assertEquals(expected, actual); Assert.assertEquals(expected.getKeyUnit(), actual.getKeyUnit()); }
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public int removeAt(int offset) { return myList.removeAt(offset); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAtAfterPetrify() { PETRIFIED_LIST.removeAt(1); }
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public int replace(int offset, int val) { return myList.replace(offset, val); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReplaceAfterPetrify() { PETRIFIED_LIST.replace(0, TEST_INT); }
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public boolean retainAll(Collection<?> collection) { return myList.retainAll(collection); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify1() { PETRIFIED_LIST.retainAll(TEST_INT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify2() { PETRIFIED_LIST.retainAll(TEST_INT_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify3() { PETRIFIED_LIST.retainAll(TEST_INT_ARRAY_LIST); }
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public void reverse() { myList.reverse(); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify1() { PETRIFIED_LIST.reverse(); } @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify2() { PETRIFIED_LIST.reverse(0, 5); }
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public int set(int offset, int val) { return myList.set(offset, val); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify1() { PETRIFIED_LIST.set(0, TEST_INT); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify2() { PETRIFIED_LIST.set(0, TEST_INT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify3() { PETRIFIED_LIST.set(0, TEST_INT_ARRAY, 0, 1); }
### Question: EllipseSemiMinorAxisKey extends AbstractSpecialKey implements SpecialColumnDetector { @Override public boolean markSpecialColumn(MetaDataInfo metaData, String columnName) { boolean wasDetected = false; if (!metaData.hasTypeForSpecialKey(EllipseSemiMinorAxisKey.DEFAULT)) { SpecialKey specialKey = detectColumn(columnName); if (specialKey != null) { metaData.setSpecialKey(columnName, specialKey, metaData); wasDetected = true; } } return wasDetected; } EllipseSemiMinorAxisKey(); EllipseSemiMinorAxisKey(Class<? extends Length> semiMinorUnit); @Override boolean markSpecialColumn(MetaDataInfo metaData, String columnName); @Override SpecialKey detectColumn(String columnName); @SuppressWarnings("unchecked") Class<? extends Length> getAltitudeUnit(); static Class<? extends Length> detectUnit(String columnName); static final EllipseSemiMinorAxisKey DEFAULT; }### Answer: @Test public void testMarkSpecialColumn() { DefaultMetaDataInfo metaData = new DefaultMetaDataInfo(); String column = "Semi-Minor 95 (km)"; metaData.addKey(column, Double.class, this); EllipseSemiMinorAxisKey.DEFAULT.markSpecialColumn(metaData, column); EllipseSemiMinorAxisKey actual = (EllipseSemiMinorAxisKey)metaData.getSpecialTypeForKey(column); EllipseSemiMinorAxisKey expected = new EllipseSemiMinorAxisKey(Kilometers.class); Assert.assertEquals(expected, actual); Assert.assertEquals(expected.getKeyUnit(), actual.getKeyUnit()); }
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public void sort() { myList.sort(); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify1() { PETRIFIED_LIST.sort(); } @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify2() { PETRIFIED_LIST.sort(0, 5); }
### Question: PetrifyableTIntArrayList extends AbstractPetrifyable implements PetrifyableTIntList { @Override public void transformValues(TIntFunction function) { myList.transformValues(function); } PetrifyableTIntArrayList(); PetrifyableTIntArrayList(int capacity); PetrifyableTIntArrayList(int[] values); PetrifyableTIntArrayList(TIntCollection values); @Override boolean add(int val); @Override void add(int[] vals); @Override void add(int[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Integer> collection); @Override boolean addAll(int[] array); @Override boolean addAll(TIntCollection collection); @Override int binarySearch(int value); @Override int binarySearch(int value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(int value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(int[] array); @Override boolean containsAll(TIntCollection collection); @Override void fill(int val); @Override void fill(int fromIndex, int toIndex, int val); @Override boolean forEach(TIntProcedure procedure); @Override boolean forEachDescending(TIntProcedure procedure); @Override int get(int offset); @Override int getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTIntArrayList grep(TIntProcedure condition); @Override int indexOf(int value); @Override int indexOf(int offset, int value); @Override void insert(int offset, int value); @Override void insert(int offset, int[] values); @Override void insert(int offset, int[] values, int valOffset, int len); @Override PetrifyableTIntArrayList inverseGrep(TIntProcedure condition); @Override boolean isEmpty(); @Override TIntIterator iterator(); @Override int lastIndexOf(int value); @Override int lastIndexOf(int offset, int value); @Override int max(); @Override int min(); @Override synchronized void petrify(); @Override boolean remove(int value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(int[] array); @Override boolean removeAll(TIntCollection collection); @Override int removeAt(int offset); @Override int replace(int offset, int val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(int[] array); @Override boolean retainAll(TIntCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override int set(int offset, int val); @Override void set(int offset, int[] values); @Override void set(int offset, int[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTIntArrayList subList(int begin, int end); @Override int sum(); @Override int[] toArray(); @Override int[] toArray(int offset, int len); @Override int[] toArray(int[] dest); @Override int[] toArray(int[] dest, int offset, int len); @Override int[] toArray(int[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TIntFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testTransformValuesAfterPetrify2() { PETRIFIED_LIST.transformValues(new TIntFunction() { @Override public int execute(int value) { return 0; } }); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public boolean add(char val) { return myList.add(val); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify1() { PETRIFIED_LIST.add(TEST_CHAR); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify2() { PETRIFIED_LIST.add(TEST_CHAR_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify3() { PETRIFIED_LIST.add(TEST_CHAR_ARRAY, 0, 1); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public boolean addAll(char[] array) { return myList.addAll(array); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify1() { PETRIFIED_LIST.addAll(TEST_CHAR_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify2() { PETRIFIED_LIST.addAll(TEST_CHAR_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify3() { PETRIFIED_LIST.addAll(TEST_CHAR_ARRAY_LIST); }
### Question: EllipseSemiMinorAxisKey extends AbstractSpecialKey implements SpecialColumnDetector { static boolean isSemiMinor(String columnName) { return COLUMN_PATTERN.matcher(columnName).matches(); } EllipseSemiMinorAxisKey(); EllipseSemiMinorAxisKey(Class<? extends Length> semiMinorUnit); @Override boolean markSpecialColumn(MetaDataInfo metaData, String columnName); @Override SpecialKey detectColumn(String columnName); @SuppressWarnings("unchecked") Class<? extends Length> getAltitudeUnit(); static Class<? extends Length> detectUnit(String columnName); static final EllipseSemiMinorAxisKey DEFAULT; }### Answer: @Test public void testIsSemiMinor() { Assert.assertFalse(EllipseSemiMinorAxisKey.isSemiMinor("")); Assert.assertFalse(EllipseSemiMinorAxisKey.isSemiMinor("SEMI_MAJOR")); Assert.assertTrue(EllipseSemiMinorAxisKey.isSemiMinor("Semi-Minor 95 (km)")); Assert.assertTrue(EllipseSemiMinorAxisKey.isSemiMinor("SEMI_MINOR")); Assert.assertTrue(EllipseSemiMinorAxisKey.isSemiMinor("SMI")); Assert.assertTrue(EllipseSemiMinorAxisKey.isSemiMinor("SMI_NM")); Assert.assertTrue(EllipseSemiMinorAxisKey.isSemiMinor("SMIN")); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public void clear() { myList.clear(); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testClearAfterPetrify() { PETRIFIED_LIST.clear(); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public void fill(char val) { myList.fill(val); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify1() { PETRIFIED_LIST.fill(TEST_CHAR); } @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify2() { PETRIFIED_LIST.fill(0, 1, TEST_CHAR); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public void insert(int offset, char value) { myList.insert(offset, value); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify1() { PETRIFIED_LIST.insert(0, TEST_CHAR); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify2() { PETRIFIED_LIST.insert(0, TEST_CHAR_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify3() { PETRIFIED_LIST.insert(0, TEST_CHAR_ARRAY, 0, 1); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public boolean remove(char value) { return myList.remove(value); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify1() { PETRIFIED_LIST.remove(TEST_CHAR); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify2() { PETRIFIED_LIST.remove(0, 1); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public boolean removeAll(char[] array) { return myList.removeAll(array); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify1() { PETRIFIED_LIST.removeAll(TEST_CHAR_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify2() { PETRIFIED_LIST.removeAll(TEST_CHAR_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify3() { PETRIFIED_LIST.removeAll(TEST_CHAR_ARRAY_LIST); }
### Question: EllipseSemiMajorAxisKey extends AbstractSpecialKey implements SpecialColumnDetector { public static Class<? extends Length> detectUnit(String columnName) { Class<? extends Length> lengthClass = null; if (StringUtils.containsIgnoreCase(columnName, "km)") || StringUtils.containsIgnoreCase(columnName, "kilometers)")) { lengthClass = Kilometers.class; } else if (StringUtils.containsIgnoreCase(columnName, "nm)") || StringUtils.containsIgnoreCase(columnName, "nmi)") || StringUtils.containsIgnoreCase(columnName, "nautical miles)")) { lengthClass = NauticalMiles.class; } else if (StringUtils.containsIgnoreCase(columnName, "mi)") || StringUtils.containsIgnoreCase(columnName, "miles)")) { lengthClass = StatuteMiles.class; } else if (StringUtils.containsIgnoreCase(columnName, "m)") || StringUtils.containsIgnoreCase(columnName, "meters)")) { lengthClass = Meters.class; } return lengthClass; } EllipseSemiMajorAxisKey(); EllipseSemiMajorAxisKey(Class<? extends Length> semiMajorUnit); @Override boolean markSpecialColumn(MetaDataInfo metaData, String columnName); @Override SpecialKey detectColumn(String columnName); @SuppressWarnings("unchecked") Class<? extends Length> getSemiMajorUnit(); static Class<? extends Length> detectUnit(String columnName); static final EllipseSemiMajorAxisKey DEFAULT; }### Answer: @Test public void testDetectUnit() { Assert.assertEquals(Kilometers.class, EllipseSemiMajorAxisKey.detectUnit("blah (km)")); Assert.assertEquals(Kilometers.class, EllipseSemiMajorAxisKey.detectUnit("blah (kilometers)")); Assert.assertEquals(Meters.class, EllipseSemiMajorAxisKey.detectUnit("blah (m)")); Assert.assertEquals(Meters.class, EllipseSemiMajorAxisKey.detectUnit("blah (meters)")); Assert.assertEquals(StatuteMiles.class, EllipseSemiMajorAxisKey.detectUnit("blah (mi)")); Assert.assertEquals(StatuteMiles.class, EllipseSemiMajorAxisKey.detectUnit("blah (miles)")); Assert.assertEquals(NauticalMiles.class, EllipseSemiMajorAxisKey.detectUnit("blah (nm)")); Assert.assertEquals(NauticalMiles.class, EllipseSemiMajorAxisKey.detectUnit("blah (nmi)")); Assert.assertEquals(NauticalMiles.class, EllipseSemiMajorAxisKey.detectUnit("blah (nautical miles)")); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public char removeAt(int offset) { return myList.removeAt(offset); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAtAfterPetrify() { PETRIFIED_LIST.removeAt(1); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public char replace(int offset, char val) { return myList.replace(offset, val); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReplaceAfterPetrify() { PETRIFIED_LIST.replace(0, TEST_CHAR); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public boolean retainAll(char[] array) { return myList.retainAll(array); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify1() { PETRIFIED_LIST.retainAll(TEST_CHAR_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify2() { PETRIFIED_LIST.retainAll(TEST_CHAR_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify3() { PETRIFIED_LIST.retainAll(TEST_CHAR_ARRAY_LIST); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public void reverse() { myList.reverse(); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify1() { PETRIFIED_LIST.reverse(); } @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify2() { PETRIFIED_LIST.reverse(0, 5); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public char set(int offset, char val) { return myList.set(offset, val); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify1() { PETRIFIED_LIST.set(0, TEST_CHAR); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify2() { PETRIFIED_LIST.set(0, TEST_CHAR_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify3() { PETRIFIED_LIST.set(0, TEST_CHAR_ARRAY, 0, 1); }
### Question: EllipseSemiMajorAxisKey extends AbstractSpecialKey implements SpecialColumnDetector { @Override public boolean markSpecialColumn(MetaDataInfo metaData, String columnName) { boolean wasDetected = false; if (!metaData.hasTypeForSpecialKey(EllipseSemiMajorAxisKey.DEFAULT)) { SpecialKey specialKey = detectColumn(columnName); if (specialKey != null) { metaData.setSpecialKey(columnName, specialKey, metaData); wasDetected = true; } } return wasDetected; } EllipseSemiMajorAxisKey(); EllipseSemiMajorAxisKey(Class<? extends Length> semiMajorUnit); @Override boolean markSpecialColumn(MetaDataInfo metaData, String columnName); @Override SpecialKey detectColumn(String columnName); @SuppressWarnings("unchecked") Class<? extends Length> getSemiMajorUnit(); static Class<? extends Length> detectUnit(String columnName); static final EllipseSemiMajorAxisKey DEFAULT; }### Answer: @Test public void testMarkSpecialColumn() { DefaultMetaDataInfo metaData = new DefaultMetaDataInfo(); String column = "Semi-Major 95 (km)"; metaData.addKey(column, Double.class, this); EllipseSemiMajorAxisKey.DEFAULT.markSpecialColumn(metaData, column); EllipseSemiMajorAxisKey actual = (EllipseSemiMajorAxisKey)metaData.getSpecialTypeForKey(column); EllipseSemiMajorAxisKey expected = new EllipseSemiMajorAxisKey(Kilometers.class); Assert.assertEquals(expected, actual); Assert.assertEquals(expected.getKeyUnit(), actual.getKeyUnit()); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public void sort() { myList.sort(); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify1() { PETRIFIED_LIST.sort(); } @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify2() { PETRIFIED_LIST.sort(0, 5); }
### Question: PetrifyableTCharArrayList extends AbstractPetrifyable implements PetrifyableTCharList { @Override public void transformValues(TCharFunction function) { myList.transformValues(function); } PetrifyableTCharArrayList(); PetrifyableTCharArrayList(char[] values); PetrifyableTCharArrayList(int capacity); PetrifyableTCharArrayList(TCharCollection values); @Override boolean add(char val); @Override void add(char[] vals); @Override void add(char[] vals, int offset, int length); @Override boolean addAll(char[] array); @Override boolean addAll(Collection<? extends Character> collection); @Override boolean addAll(TCharCollection collection); @Override int binarySearch(char value); @Override int binarySearch(char value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(char value); @Override boolean containsAll(char[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TCharCollection collection); @Override void fill(char val); @Override void fill(int fromIndex, int toIndex, char val); @Override boolean forEach(TCharProcedure procedure); @Override boolean forEachDescending(TCharProcedure procedure); @Override char get(int offset); @Override char getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTCharArrayList grep(TCharProcedure condition); @Override int indexOf(char value); @Override int indexOf(int offset, char value); @Override void insert(int offset, char value); @Override void insert(int offset, char[] values); @Override void insert(int offset, char[] values, int valOffset, int len); @Override PetrifyableTCharArrayList inverseGrep(TCharProcedure condition); @Override boolean isEmpty(); @Override TCharIterator iterator(); @Override int lastIndexOf(char value); @Override int lastIndexOf(int offset, char value); @Override char max(); @Override char min(); @Override synchronized void petrify(); @Override boolean remove(char value); @Override void remove(int offset, int length); @Override boolean removeAll(char[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TCharCollection collection); @Override char removeAt(int offset); @Override char replace(int offset, char val); @Override boolean retainAll(char[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TCharCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override char set(int offset, char val); @Override void set(int offset, char[] values); @Override void set(int offset, char[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTCharArrayList subList(int begin, int end); @Override char sum(); @Override char[] toArray(); @Override char[] toArray(char[] dest); @Override char[] toArray(char[] dest, int offset, int len); @Override char[] toArray(char[] dest, int sourcePos, int destPos, int len); @Override char[] toArray(int offset, int len); @Override void transformValues(TCharFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testTransformValuesAfterPetrify2() { PETRIFIED_LIST.transformValues(new TCharFunction() { @Override public char execute(char value) { return 0; } }); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public boolean add(byte val) { return myList.add(val); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify1() { PETRIFIED_LIST.add(TEST_BYTE); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify2() { PETRIFIED_LIST.add(TEST_BYTE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify3() { PETRIFIED_LIST.add(TEST_BYTE_ARRAY, 0, 1); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public boolean addAll(byte[] array) { return myList.addAll(array); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify1() { PETRIFIED_LIST.addAll(TEST_BYTE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify2() { PETRIFIED_LIST.addAll(TEST_BYTE_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify3() { PETRIFIED_LIST.addAll(TEST_BYTE_ARRAY_LIST); }
### Question: EllipseSemiMajorAxisKey extends AbstractSpecialKey implements SpecialColumnDetector { static boolean isSemiMajor(String columnName) { return COLUMN_PATTERN.matcher(columnName).matches(); } EllipseSemiMajorAxisKey(); EllipseSemiMajorAxisKey(Class<? extends Length> semiMajorUnit); @Override boolean markSpecialColumn(MetaDataInfo metaData, String columnName); @Override SpecialKey detectColumn(String columnName); @SuppressWarnings("unchecked") Class<? extends Length> getSemiMajorUnit(); static Class<? extends Length> detectUnit(String columnName); static final EllipseSemiMajorAxisKey DEFAULT; }### Answer: @Test public void testIsSemiMajor() { Assert.assertFalse(EllipseSemiMajorAxisKey.isSemiMajor("")); Assert.assertFalse(EllipseSemiMajorAxisKey.isSemiMajor("SEMI_MINOR")); Assert.assertTrue(EllipseSemiMajorAxisKey.isSemiMajor("Semi-Major 95 (km)")); Assert.assertTrue(EllipseSemiMajorAxisKey.isSemiMajor("SEMI_MAJOR")); Assert.assertTrue(EllipseSemiMajorAxisKey.isSemiMajor("SMA")); Assert.assertTrue(EllipseSemiMajorAxisKey.isSemiMajor("SMJ_NM")); Assert.assertTrue(EllipseSemiMajorAxisKey.isSemiMajor("SMAJ")); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public void clear() { myList.clear(); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testClearAfterPetrify() { PETRIFIED_LIST.clear(); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public void fill(byte val) { myList.fill(val); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify1() { PETRIFIED_LIST.fill(TEST_BYTE); } @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify2() { PETRIFIED_LIST.fill(0, 1, TEST_BYTE); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public void insert(int offset, byte value) { myList.insert(offset, value); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify1() { PETRIFIED_LIST.insert(0, TEST_BYTE); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify2() { PETRIFIED_LIST.insert(0, TEST_BYTE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify3() { PETRIFIED_LIST.insert(0, TEST_BYTE_ARRAY, 0, 1); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public boolean remove(byte value) { return myList.remove(value); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify1() { PETRIFIED_LIST.remove(TEST_BYTE); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify2() { PETRIFIED_LIST.remove(0, 1); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public boolean removeAll(byte[] array) { return myList.removeAll(array); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify1() { PETRIFIED_LIST.removeAll(TEST_BYTE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify2() { PETRIFIED_LIST.removeAll(TEST_BYTE_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify3() { PETRIFIED_LIST.removeAll(TEST_BYTE_ARRAY_LIST); }
### Question: SpeedErrorKey extends AbstractSpecialKey implements SpecialColumnDetector { @Override public boolean markSpecialColumn(MetaDataInfo metaData, String columnName) { boolean wasDetected = false; if (!metaData.hasTypeForSpecialKey(SpeedErrorKey.DEFAULT)) { SpecialKey specialKey = detectColumn(columnName); if (specialKey != null) { metaData.setSpecialKey(columnName, specialKey, metaData); wasDetected = true; } } return wasDetected; } SpeedErrorKey(); SpeedErrorKey(SpeedUnit unit); @Override SpeedUnit getKeyUnit(); @Override boolean markSpecialColumn(MetaDataInfo metaData, String columnName); @Override SpecialKey detectColumn(String columnName); static final SpeedErrorKey DEFAULT; }### Answer: @Test public void testMarkSpecialColumn() { DefaultMetaDataInfo metaData = new DefaultMetaDataInfo(); String column = "Speed Error (+/-mi/hr)"; metaData.addKey(column, Double.class, this); SpeedErrorKey.DEFAULT.markSpecialColumn(metaData, column); SpeedErrorKey actual = (SpeedErrorKey)metaData.getSpecialTypeForKey(column); SpeedErrorKey expected = new SpeedErrorKey(SpeedUnit.MILES_PER_HOUR); Assert.assertEquals(expected, actual); Assert.assertEquals(expected.getKeyUnit(), actual.getKeyUnit()); }
### Question: ElementData { public Long getID() { return myID; } ElementData(); ElementData(Long id, TimeSpan ts, VisualizationState vs, MetaDataProvider mdp, MapGeometrySupport mgs); boolean found(); Long getID(); MapGeometrySupport getMapGeometrySupport(); MetaDataProvider getMetaDataProvider(); TimeSpan getTimeSpan(); VisualizationState getVisualizationState(); final void updateValues(Long id, TimeSpan ts, VisualizationState vs, MetaDataProvider mdp, MapGeometrySupport mgs); }### Answer: @Test public void testGetID() { assertEquals(myTestID, myTestObject.getID()); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public byte removeAt(int offset) { return myList.removeAt(offset); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAtAfterPetrify() { PETRIFIED_LIST.removeAt(1); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public byte replace(int offset, byte val) { return myList.replace(offset, val); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReplaceAfterPetrify() { PETRIFIED_LIST.replace(0, TEST_BYTE); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public boolean retainAll(byte[] array) { return myList.retainAll(array); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify1() { PETRIFIED_LIST.retainAll(TEST_BYTE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify2() { PETRIFIED_LIST.retainAll(TEST_BYTE_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify3() { PETRIFIED_LIST.retainAll(TEST_BYTE_ARRAY_LIST); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public void reverse() { myList.reverse(); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify1() { PETRIFIED_LIST.reverse(); } @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify2() { PETRIFIED_LIST.reverse(0, 5); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public byte set(int offset, byte val) { return myList.set(offset, val); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify1() { PETRIFIED_LIST.set(0, TEST_BYTE); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify2() { PETRIFIED_LIST.set(0, TEST_BYTE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify3() { PETRIFIED_LIST.set(0, TEST_BYTE_ARRAY, 0, 1); }
### Question: HeadingKey extends AbstractSpecialKey implements SpecialColumnDetector { @Override public boolean markSpecialColumn(MetaDataInfo metaData, String columnName) { boolean wasDetected = false; if (!metaData.hasTypeForSpecialKey(HeadingKey.DEFAULT)) { SpecialKey specialKey = detectColumn(columnName); if (specialKey != null) { metaData.setSpecialKey(columnName, specialKey, metaData); wasDetected = true; } } return wasDetected; } HeadingKey(); HeadingKey(HeadingUnit unit); @Override HeadingUnit getKeyUnit(); @Override boolean markSpecialColumn(MetaDataInfo metaData, String columnName); @Override SpecialKey detectColumn(String columnName); static boolean isHeading(String columnName); static final HeadingKey DEFAULT; }### Answer: @Test public void testMarkSpecialColumn() { DefaultMetaDataInfo metaData = new DefaultMetaDataInfo(); String column = "Heading (degN)"; metaData.addKey(column, Double.class, this); HeadingKey.DEFAULT.markSpecialColumn(metaData, column); HeadingKey actual = (HeadingKey)metaData.getSpecialTypeForKey(column); HeadingKey expected = new HeadingKey(HeadingUnit.DEGREES_CLOCKWISE_FROM_NORTH); Assert.assertEquals(expected, actual); Assert.assertEquals(expected.getKeyUnit(), actual.getKeyUnit()); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public void sort() { myList.sort(); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify1() { PETRIFIED_LIST.sort(); } @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify2() { PETRIFIED_LIST.sort(0, 5); }
### Question: PetrifyableTByteArrayList extends AbstractPetrifyable implements PetrifyableTByteList { @Override public void transformValues(TByteFunction function) { myList.transformValues(function); } PetrifyableTByteArrayList(); PetrifyableTByteArrayList(byte[] values); PetrifyableTByteArrayList(int capacity); PetrifyableTByteArrayList(TByteCollection values); @Override boolean add(byte val); @Override void add(byte[] vals); @Override void add(byte[] vals, int offset, int length); @Override boolean addAll(byte[] array); @Override boolean addAll(Collection<? extends Byte> collection); @Override boolean addAll(TByteCollection collection); @Override int binarySearch(byte value); @Override int binarySearch(byte value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(byte value); @Override boolean containsAll(byte[] array); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(TByteCollection collection); @Override void fill(byte val); @Override void fill(int fromIndex, int toIndex, byte val); @Override boolean forEach(TByteProcedure procedure); @Override boolean forEachDescending(TByteProcedure procedure); @Override byte get(int offset); @Override byte getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTByteArrayList grep(TByteProcedure condition); @Override int indexOf(byte value); @Override int indexOf(int offset, byte value); @Override void insert(int offset, byte value); @Override void insert(int offset, byte[] values); @Override void insert(int offset, byte[] values, int valOffset, int len); @Override PetrifyableTByteArrayList inverseGrep(TByteProcedure condition); @Override boolean isEmpty(); @Override TByteIterator iterator(); @Override int lastIndexOf(byte value); @Override int lastIndexOf(int offset, byte value); @Override byte max(); @Override byte min(); @Override synchronized void petrify(); @Override boolean remove(byte value); @Override void remove(int offset, int length); @Override boolean removeAll(byte[] array); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(TByteCollection collection); @Override byte removeAt(int offset); @Override byte replace(int offset, byte val); @Override boolean retainAll(byte[] array); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(TByteCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override byte set(int offset, byte val); @Override void set(int offset, byte[] values); @Override void set(int offset, byte[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTByteArrayList subList(int begin, int end); @Override byte sum(); @Override byte[] toArray(); @Override byte[] toArray(byte[] dest); @Override byte[] toArray(byte[] dest, int offset, int len); @Override byte[] toArray(byte[] dest, int sourcePos, int destPos, int len); @Override byte[] toArray(int offset, int len); @Override void transformValues(TByteFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testTransformValuesAfterPetrify2() { PETRIFIED_LIST.transformValues(new TByteFunction() { @Override public byte execute(byte value) { return 0; } }); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public boolean add(float val) { return myList.add(val); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify1() { PETRIFIED_LIST.add(TEST_FLOAT); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify2() { PETRIFIED_LIST.add(TEST_FLOAT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify3() { PETRIFIED_LIST.add(TEST_FLOAT_ARRAY, 0, 1); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public boolean addAll(Collection<? extends Float> collection) { return myList.addAll(collection); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify1() { PETRIFIED_LIST.addAll(TEST_FLOAT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify2() { PETRIFIED_LIST.addAll(TEST_FLOAT_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify3() { PETRIFIED_LIST.addAll(TEST_FLOAT_ARRAY_LIST); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public void clear() { myList.clear(); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testClearAfterPetrify() { PETRIFIED_LIST.clear(); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public void fill(float val) { myList.fill(val); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify1() { PETRIFIED_LIST.fill(TEST_FLOAT); } @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify2() { PETRIFIED_LIST.fill(0, 1, TEST_FLOAT); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public void insert(int offset, float value) { myList.insert(offset, value); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify1() { PETRIFIED_LIST.insert(0, TEST_FLOAT); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify2() { PETRIFIED_LIST.insert(0, TEST_FLOAT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify3() { PETRIFIED_LIST.insert(0, TEST_FLOAT_ARRAY, 0, 1); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public boolean remove(float value) { return myList.remove(value); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify1() { PETRIFIED_LIST.remove(TEST_FLOAT); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify2() { PETRIFIED_LIST.remove(0, 1); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public boolean removeAll(Collection<?> collection) { return myList.removeAll(collection); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify1() { PETRIFIED_LIST.removeAll(TEST_FLOAT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify2() { PETRIFIED_LIST.removeAll(TEST_FLOAT_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify3() { PETRIFIED_LIST.removeAll(TEST_FLOAT_ARRAY_LIST); }
### Question: TimeSpanUtility { public static String formatTimeSpan(SimpleDateFormat dateFormat, TimeSpan ts) { return ts == null ? BLANK : TimeSpanFormatter.buildString(ts, dateFormat, " to ", new StringBuilder(42)).toString(); } private TimeSpanUtility(); static String formatTimeSpan(SimpleDateFormat dateFormat, TimeSpan ts); static String formatTimeSpanSingleTimeOnly(SimpleDateFormat dateFormat, TimeSpan ts); static TimeSpan fromStartEnd(long startTime, long endTime); static long getWorkaroundEnd(TimeSpan ts); static long getWorkaroundStart(TimeSpan ts); static final long TIMELESS_END; static final long TIMELESS_START; }### Answer: @Test public void testFormatTimeSpan() { SimpleDateFormat format = new SimpleDateFormat(DateTimeFormats.DATE_TIME_FORMAT); Assert.assertEquals("", TimeSpanUtility.formatTimeSpan(format, null)); Assert.assertEquals("TIMELESS", TimeSpanUtility.formatTimeSpan(format, TimeSpan.TIMELESS)); Assert.assertEquals("ZERO", TimeSpanUtility.formatTimeSpan(format, TimeSpan.ZERO)); Assert.assertEquals("1970-01-02 00:00:00", TimeSpanUtility.formatTimeSpan(format, TimeSpan.get(Constants.MILLIS_PER_DAY))); Assert.assertEquals("1970-01-02 00:00:00 to 1970-01-03 00:00:00", TimeSpanUtility.formatTimeSpan(format, TimeSpan.get(Constants.MILLIS_PER_DAY, Constants.MILLIS_PER_DAY * 2))); Assert.assertEquals("UNBOUNDED to 1970-01-02 00:00:00", TimeSpanUtility.formatTimeSpan(format, TimeSpan.newUnboundedStartTimeSpan(Constants.MILLIS_PER_DAY))); Assert.assertEquals("1970-01-02 00:00:00 to UNBOUNDED", TimeSpanUtility.formatTimeSpan(format, TimeSpan.newUnboundedEndTimeSpan(Constants.MILLIS_PER_DAY))); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public float removeAt(int offset) { return myList.removeAt(offset); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAtAfterPetrify() { PETRIFIED_LIST.removeAt(1); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public float replace(int offset, float val) { return myList.replace(offset, val); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReplaceAfterPetrify() { PETRIFIED_LIST.replace(0, TEST_FLOAT); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public boolean retainAll(Collection<?> collection) { return myList.retainAll(collection); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify1() { PETRIFIED_LIST.retainAll(TEST_FLOAT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify2() { PETRIFIED_LIST.retainAll(TEST_FLOAT_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify3() { PETRIFIED_LIST.retainAll(TEST_FLOAT_ARRAY_LIST); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public void reverse() { myList.reverse(); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify1() { PETRIFIED_LIST.reverse(); } @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify2() { PETRIFIED_LIST.reverse(0, 5); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public float set(int offset, float val) { return myList.set(offset, val); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify1() { PETRIFIED_LIST.set(0, TEST_FLOAT); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify2() { PETRIFIED_LIST.set(0, TEST_FLOAT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify3() { PETRIFIED_LIST.set(0, TEST_FLOAT_ARRAY, 0, 1); }
### Question: QueryRegionStateController extends AbstractModuleStateController { @Override public boolean canActivateState(Node node) { try { return StateXML.newXPath().evaluate("/" + ModuleStateController.STATE_QNAME + "/:queryAreas", node, XPathConstants.NODE) != null; } catch (XPathExpressionException e) { LOGGER.error(e, e); return false; } } QueryRegionStateController(QueryRegionManager queryRegionManager, Toolbox toolbox); @Override synchronized void activateState(final String id, String description, Collection<? extends String> tags, Node node); @Override void activateState(String id, String description, Collection<? extends String> tags, StateType state); @Override boolean canActivateState(Node node); @Override boolean canActivateState(StateType state); @Override boolean canSaveState(); @Override synchronized void deactivateState(String id, Node node); @Override void deactivateState(String id, StateType state); @Override boolean isSaveStateByDefault(); @Override void saveState(Node node); @Override void saveState(StateType state); }### Answer: @Test public void testCanActivateState() throws XPathExpressionException, ParserConfigurationException { Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); QueryRegionStateController controller = new QueryRegionStateController(null, null); Assert.assertFalse(controller.canActivateState(doc)); doc.appendChild(StateXML.createElement(doc, ModuleStateController.STATE_NAME)) .appendChild(StateXML.createElement(doc, "queryAreas")); Assert.assertTrue(controller.canActivateState(doc)); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public void sort() { myList.sort(); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify1() { PETRIFIED_LIST.sort(); } @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify2() { PETRIFIED_LIST.sort(0, 5); }
### Question: PetrifyableTFloatArrayList extends AbstractPetrifyable implements PetrifyableTFloatList { @Override public void transformValues(TFloatFunction function) { myList.transformValues(function); } PetrifyableTFloatArrayList(); PetrifyableTFloatArrayList(float[] values); PetrifyableTFloatArrayList(int capacity); PetrifyableTFloatArrayList(TFloatCollection values); @Override boolean add(float val); @Override void add(float[] vals); @Override void add(float[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Float> collection); @Override boolean addAll(float[] array); @Override boolean addAll(TFloatCollection collection); @Override int binarySearch(float value); @Override int binarySearch(float value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(float value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(float[] array); @Override boolean containsAll(TFloatCollection collection); @Override void fill(float val); @Override void fill(int fromIndex, int toIndex, float val); @Override boolean forEach(TFloatProcedure procedure); @Override boolean forEachDescending(TFloatProcedure procedure); @Override float get(int offset); @Override float getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTFloatArrayList grep(TFloatProcedure condition); @Override int indexOf(float value); @Override int indexOf(int offset, float value); @Override void insert(int offset, float value); @Override void insert(int offset, float[] values); @Override void insert(int offset, float[] values, int valOffset, int len); @Override PetrifyableTFloatArrayList inverseGrep(TFloatProcedure condition); @Override boolean isEmpty(); @Override TFloatIterator iterator(); @Override int lastIndexOf(float value); @Override int lastIndexOf(int offset, float value); @Override float max(); @Override float min(); @Override synchronized void petrify(); @Override boolean remove(float value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(float[] array); @Override boolean removeAll(TFloatCollection collection); @Override float removeAt(int offset); @Override float replace(int offset, float val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(float[] array); @Override boolean retainAll(TFloatCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override float set(int offset, float val); @Override void set(int offset, float[] values); @Override void set(int offset, float[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTFloatArrayList subList(int begin, int end); @Override float sum(); @Override float[] toArray(); @Override float[] toArray(float[] dest); @Override float[] toArray(float[] dest, int offset, int len); @Override float[] toArray(float[] dest, int sourcePos, int destPos, int len); @Override float[] toArray(int offset, int len); @Override void transformValues(TFloatFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testTransformValuesAfterPetrify2() { PETRIFIED_LIST.transformValues(new TFloatFunction() { @Override public float execute(float value) { return 0; } }); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public boolean add(short val) { return myList.add(val); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify1() { PETRIFIED_LIST.add(TEST_SHORT); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify2() { PETRIFIED_LIST.add(TEST_SHORT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify3() { PETRIFIED_LIST.add(TEST_SHORT_ARRAY, 0, 1); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public boolean addAll(Collection<? extends Short> collection) { return myList.addAll(collection); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify1() { PETRIFIED_LIST.addAll(TEST_SHORT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify2() { PETRIFIED_LIST.addAll(TEST_SHORT_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify3() { PETRIFIED_LIST.addAll(TEST_SHORT_ARRAY_LIST); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public void clear() { myList.clear(); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testClearAfterPetrify() { PETRIFIED_LIST.clear(); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public void fill(int fromIndex, int toIndex, short val) { myList.fill(fromIndex, toIndex, val); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify1() { PETRIFIED_LIST.fill(TEST_SHORT); } @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify2() { PETRIFIED_LIST.fill(0, 1, TEST_SHORT); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public void insert(int offset, short value) { myList.insert(offset, value); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify1() { PETRIFIED_LIST.insert(0, TEST_SHORT); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify2() { PETRIFIED_LIST.insert(0, TEST_SHORT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify3() { PETRIFIED_LIST.insert(0, TEST_SHORT_ARRAY, 0, 1); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public void remove(int offset, int length) { myList.remove(offset, length); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify1() { PETRIFIED_LIST.remove(TEST_SHORT); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify2() { PETRIFIED_LIST.remove(0, 1); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public boolean removeAll(Collection<?> collection) { return myList.removeAll(collection); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify1() { PETRIFIED_LIST.removeAll(TEST_SHORT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify2() { PETRIFIED_LIST.removeAll(TEST_SHORT_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify3() { PETRIFIED_LIST.removeAll(TEST_SHORT_ARRAY_LIST); }
### Question: InfinityUtilities { public static String getTagValue(String tagKey, DataTypeInfo dataType) { String completeKey = tagKey + "="; return dataType.getTags().stream().filter(t -> t.startsWith(completeKey)).map(t -> t.replace(completeKey, "")).findAny() .orElse(null); } private InfinityUtilities(); static boolean isInfinityEnabled(DataTypeInfo dataType); static String getUrl(DataTypeInfo dataType); static String getTagValue(String tagKey, DataTypeInfo dataType); static String getDateFormat(String interval); static String infinify(String text, boolean isInfinity); static final String INFINITY; static final String URL; static final String INDEX; static final String POINT; static final String SHAPE; static final String START; static final String END; static final String TIME; static final long MISSING_VALUE; static final String MISSING_VALUE_SCI_NOTATION; static final double DEFAULT_BIN_WIDTH; static final int DEFAULT_BIN_WIDTH_FRAC_DIGITS; static final double DEFAULT_BIN_OFFSET; static final int DEFAULT_MIN_DOC_COUNT; static final int DEFAULT_SIZE; static final String DEFAULT_USER_NUM_FORMAT; static final int DEFAULT_INITIAL_BYTE_STREAM_SIZE; static final String BIN_MINUTE_INTERVAL; static final String BIN_HOUR_INTERVAL; static final String BIN_DAY_INTERVAL; static final String BIN_WEEK_INTERVAL; static final String BIN_MONTH_INTERVAL; static final String BIN_YEAR_INTERVAL; static final String BIN_UNIQUE_INTERVAL; static final String DEFAULT_DATE_BIN_INTERVAL; static final String DEFAULT_DATE_BIN_FORMAT; static final String DEFAULT_SCRIPT_LANGUAGE; }### Answer: @Test public void testGetTagValue() { DataTypeInfo dataType = new DefaultDataTypeInfo(null, null, "typeKey", null, null, true); dataType.addTag("bubba=gump", null); dataType.addTag(".ben=jerrys", null); Assert.assertEquals("gump", InfinityUtilities.getTagValue("bubba", dataType)); Assert.assertEquals("jerrys", InfinityUtilities.getTagValue(".ben", dataType)); Assert.assertNull(InfinityUtilities.getTagValue("something", dataType)); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public short removeAt(int offset) { return myList.removeAt(offset); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAtAfterPetrify() { PETRIFIED_LIST.removeAt(1); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public short replace(int offset, short val) { return myList.replace(offset, val); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReplaceAfterPetrify() { PETRIFIED_LIST.replace(0, TEST_SHORT); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public boolean retainAll(Collection<?> collection) { return myList.retainAll(collection); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify1() { PETRIFIED_LIST.retainAll(TEST_SHORT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify2() { PETRIFIED_LIST.retainAll(TEST_SHORT_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify3() { PETRIFIED_LIST.retainAll(TEST_SHORT_ARRAY_LIST); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public void reverse() { myList.reverse(); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify1() { PETRIFIED_LIST.reverse(); } @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify2() { PETRIFIED_LIST.reverse(0, 5); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public short set(int offset, short val) { return myList.set(offset, val); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify1() { PETRIFIED_LIST.set(0, TEST_SHORT); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify2() { PETRIFIED_LIST.set(0, TEST_SHORT_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify3() { PETRIFIED_LIST.set(0, TEST_SHORT_ARRAY, 0, 1); }
### Question: InfinityUtilities { public static String getUrl(DataTypeInfo dataType) { String url = getTagValue(URL, dataType); String index = getTagValue(INDEX, dataType); if (index != null) { url += "?" + index; } return url; } private InfinityUtilities(); static boolean isInfinityEnabled(DataTypeInfo dataType); static String getUrl(DataTypeInfo dataType); static String getTagValue(String tagKey, DataTypeInfo dataType); static String getDateFormat(String interval); static String infinify(String text, boolean isInfinity); static final String INFINITY; static final String URL; static final String INDEX; static final String POINT; static final String SHAPE; static final String START; static final String END; static final String TIME; static final long MISSING_VALUE; static final String MISSING_VALUE_SCI_NOTATION; static final double DEFAULT_BIN_WIDTH; static final int DEFAULT_BIN_WIDTH_FRAC_DIGITS; static final double DEFAULT_BIN_OFFSET; static final int DEFAULT_MIN_DOC_COUNT; static final int DEFAULT_SIZE; static final String DEFAULT_USER_NUM_FORMAT; static final int DEFAULT_INITIAL_BYTE_STREAM_SIZE; static final String BIN_MINUTE_INTERVAL; static final String BIN_HOUR_INTERVAL; static final String BIN_DAY_INTERVAL; static final String BIN_WEEK_INTERVAL; static final String BIN_MONTH_INTERVAL; static final String BIN_YEAR_INTERVAL; static final String BIN_UNIQUE_INTERVAL; static final String DEFAULT_DATE_BIN_INTERVAL; static final String DEFAULT_DATE_BIN_FORMAT; static final String DEFAULT_SCRIPT_LANGUAGE; }### Answer: @Test public void testGetUrl() { DataTypeInfo dataType = new DefaultDataTypeInfo(null, null, "typeKey", null, null, true); dataType.addTag(".es-url=http: dataType.addTag(".es-index=layer=layer1&index=index1", null); Assert.assertEquals("http: }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public void sort() { myList.sort(); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify1() { PETRIFIED_LIST.sort(); } @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify2() { PETRIFIED_LIST.sort(0, 5); }
### Question: PetrifyableTShortArrayList extends AbstractPetrifyable implements PetrifyableTShortList { @Override public void transformValues(TShortFunction function) { myList.transformValues(function); } PetrifyableTShortArrayList(); PetrifyableTShortArrayList(int capacity); PetrifyableTShortArrayList(short[] values); PetrifyableTShortArrayList(TShortCollection values); @Override boolean add(short val); @Override void add(short[] vals); @Override void add(short[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Short> collection); @Override boolean addAll(short[] array); @Override boolean addAll(TShortCollection collection); @Override int binarySearch(short value); @Override int binarySearch(short value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(short value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(short[] array); @Override boolean containsAll(TShortCollection collection); @Override void fill(int fromIndex, int toIndex, short val); @Override void fill(short val); @Override boolean forEach(TShortProcedure procedure); @Override boolean forEachDescending(TShortProcedure procedure); @Override short get(int offset); @Override short getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTShortArrayList grep(TShortProcedure condition); @Override int indexOf(int offset, short value); @Override int indexOf(short value); @Override void insert(int offset, short value); @Override void insert(int offset, short[] values); @Override void insert(int offset, short[] values, int valOffset, int len); @Override PetrifyableTShortArrayList inverseGrep(TShortProcedure condition); @Override boolean isEmpty(); @Override TShortIterator iterator(); @Override int lastIndexOf(int offset, short value); @Override int lastIndexOf(short value); @Override short max(); @Override short min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(short value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(short[] array); @Override boolean removeAll(TShortCollection collection); @Override short removeAt(int offset); @Override short replace(int offset, short val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(short[] array); @Override boolean retainAll(TShortCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override short set(int offset, short val); @Override void set(int offset, short[] values); @Override void set(int offset, short[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTShortArrayList subList(int begin, int end); @Override short sum(); @Override short[] toArray(); @Override short[] toArray(int offset, int len); @Override short[] toArray(short[] dest); @Override short[] toArray(short[] dest, int offset, int len); @Override short[] toArray(short[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TShortFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testTransformValuesAfterPetrify2() { PETRIFIED_LIST.transformValues(new TShortFunction() { @Override public short execute(short value) { return 0; } }); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public boolean add(double val) { return myList.add(val); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify1() { PETRIFIED_LIST.add(TEST_DOUBLE); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify2() { PETRIFIED_LIST.add(TEST_DOUBLE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify3() { PETRIFIED_LIST.add(TEST_DOUBLE_ARRAY, 0, 1); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public boolean addAll(Collection<? extends Double> collection) { return myList.addAll(collection); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify1() { PETRIFIED_LIST.addAll(TEST_DOUBLE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify2() { PETRIFIED_LIST.addAll(TEST_DOUBLE_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify3() { PETRIFIED_LIST.addAll(TEST_DOUBLE_ARRAY_LIST); }
### Question: IconRemover { public void deleteIcons() { IconRecord record = myModel.selectedRecordProperty().get(); if(record != null) { myModel.getModel().getIconRecords().remove(record); myModel.getIconRegistry().removeIcon(record, this); } } IconRemover(IconModel model); void deleteIcons(); }### Answer: @Test public void test() { EasyMockSupport support = new EasyMockSupport(); IconRecord icon = support.createMock(IconRecord.class); EasyMock.expect(icon.collectionNameProperty()).andReturn(new SimpleStringProperty("User")).anyTimes(); EasyMock.expect(icon.favoriteProperty()).andReturn(new SimpleBooleanProperty(false)).anyTimes(); EasyMock.expect(icon.getTags()).andReturn(FXCollections.observableArrayList()).anyTimes(); EasyMock.expect(icon.nameProperty()).andReturn(new SimpleStringProperty("testIcon")).anyTimes(); EasyMock.expect(icon.descriptionProperty()).andReturn(new SimpleStringProperty("A description")).anyTimes(); IconRegistry iconRegistry = createIconRegistry(support, icon); EasyMock.expect(Boolean.valueOf(iconRegistry.removeIcon(EasyMock.eq(icon), EasyMock.isA(IconRemover.class)))).andReturn(Boolean.TRUE); Toolbox toolbox = support.createMock(Toolbox.class); support.replayAll(); IconModel model = new IconModel(toolbox); model.setIconRegistry(iconRegistry); model.selectedRecordProperty().set(icon); assertEquals(1, model.getModel().getIconRecords().size()); assertEquals(icon, model.getModel().getIconRecords().get(0)); IconRemover remover = new IconRemover(model); remover.deleteIcons(); assertTrue(model.getModel().getIconRecords().isEmpty()); support.verifyAll(); } @Test public void testRemoveNothingSelected() { EasyMockSupport support = new EasyMockSupport(); IconRegistry iconRegistry = createIconRegistry(support); Toolbox toolbox = support.createMock(Toolbox.class); support.replayAll(); IconModel model = new IconModel(toolbox); model.setIconRegistry(iconRegistry); IconRemover remover = new IconRemover(model); remover.deleteIcons(); support.verifyAll(); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public void clear() { myList.clear(); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testClearAfterPetrify() { PETRIFIED_LIST.clear(); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public void fill(double val) { myList.fill(val); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify1() { PETRIFIED_LIST.fill(TEST_DOUBLE); } @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify2() { PETRIFIED_LIST.fill(0, 1, TEST_DOUBLE); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public void insert(int offset, double value) { myList.insert(offset, value); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify1() { PETRIFIED_LIST.insert(0, TEST_DOUBLE); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify2() { PETRIFIED_LIST.insert(0, TEST_DOUBLE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testInsertAfterPetrify3() { PETRIFIED_LIST.insert(0, TEST_DOUBLE_ARRAY, 0, 1); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public boolean remove(double value) { return myList.remove(value); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify1() { PETRIFIED_LIST.remove(TEST_DOUBLE); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAfterPetrify2() { PETRIFIED_LIST.remove(0, 1); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public boolean removeAll(Collection<?> collection) { return myList.removeAll(collection); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify1() { PETRIFIED_LIST.removeAll(TEST_DOUBLE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify2() { PETRIFIED_LIST.removeAll(TEST_DOUBLE_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRemoveAllAfterPetrify3() { PETRIFIED_LIST.removeAll(TEST_DOUBLE_ARRAY_LIST); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public double removeAt(int offset) { return myList.removeAt(offset); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRemoveAtAfterPetrify() { PETRIFIED_LIST.removeAt(1); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public double replace(int offset, double val) { return myList.replace(offset, val); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReplaceAfterPetrify() { PETRIFIED_LIST.replace(0, TEST_DOUBLE); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public boolean retainAll(Collection<?> collection) { return myList.retainAll(collection); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify1() { PETRIFIED_LIST.retainAll(TEST_DOUBLE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify2() { PETRIFIED_LIST.retainAll(TEST_DOUBLE_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testRetainAllAfterPetrify3() { PETRIFIED_LIST.retainAll(TEST_DOUBLE_ARRAY_LIST); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public void reverse() { myList.reverse(); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify1() { PETRIFIED_LIST.reverse(); } @Test(expected = UnsupportedOperationException.class) public void testReverseAfterPetrify2() { PETRIFIED_LIST.reverse(0, 5); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public double set(int offset, double val) { return myList.set(offset, val); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify1() { PETRIFIED_LIST.set(0, TEST_DOUBLE); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify2() { PETRIFIED_LIST.set(0, TEST_DOUBLE_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testSetAfterPetrify3() { PETRIFIED_LIST.set(0, TEST_DOUBLE_ARRAY, 0, 1); }
### Question: DataTypeChecker { public static boolean isFeatureType(DataTypeInfo dataType) { boolean isFeature = ((dataType == null) ? false : dataType.getBasicVisualizationInfo() != null && dataType.getBasicVisualizationInfo().usesDataElements() || dataType.getMapVisualizationInfo() != null && dataType.getMapVisualizationInfo().usesMapDataElements()); return isFeature; } private DataTypeChecker(); static boolean isFeatureType(DataTypeInfo dataType); }### Answer: @Test public void testIsFeatureDataType() { EasyMockSupport support = new EasyMockSupport(); List<DataTypeInfo> dataTypes = createDataTypes(support); support.replayAll(); int index = 1; for (DataTypeInfo dataType : dataTypes) { if (index % 3 == 0) { assertTrue(DataTypeChecker.isFeatureType(dataType)); } else { assertFalse(DataTypeChecker.isFeatureType(dataType)); } index++; } support.verifyAll(); }
### Question: ElementData { public MapGeometrySupport getMapGeometrySupport() { return myMapGeometrySupport; } ElementData(); ElementData(Long id, TimeSpan ts, VisualizationState vs, MetaDataProvider mdp, MapGeometrySupport mgs); boolean found(); Long getID(); MapGeometrySupport getMapGeometrySupport(); MetaDataProvider getMetaDataProvider(); TimeSpan getTimeSpan(); VisualizationState getVisualizationState(); final void updateValues(Long id, TimeSpan ts, VisualizationState vs, MetaDataProvider mdp, MapGeometrySupport mgs); }### Answer: @Test public void testGetMapGeometrySupport() { assertEquals(myMapGeometrySupport, myTestObject.getMapGeometrySupport()); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public void sort() { myList.sort(); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify1() { PETRIFIED_LIST.sort(); } @Test(expected = UnsupportedOperationException.class) public void testSortAfterPetrify2() { PETRIFIED_LIST.sort(0, 5); }
### Question: PetrifyableTDoubleArrayList extends AbstractPetrifyable implements PetrifyableTDoubleList { @Override public void transformValues(TDoubleFunction function) { myList.transformValues(function); } PetrifyableTDoubleArrayList(); PetrifyableTDoubleArrayList(double[] values); PetrifyableTDoubleArrayList(int capacity); PetrifyableTDoubleArrayList(TDoubleCollection values); @Override boolean add(double val); @Override void add(double[] vals); @Override void add(double[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Double> collection); @Override boolean addAll(double[] array); @Override boolean addAll(TDoubleCollection collection); @Override int binarySearch(double value); @Override int binarySearch(double value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(double value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(double[] array); @Override boolean containsAll(TDoubleCollection collection); @Override void fill(double val); @Override void fill(int fromIndex, int toIndex, double val); @Override boolean forEach(TDoubleProcedure procedure); @Override boolean forEachDescending(TDoubleProcedure procedure); @Override double get(int offset); @Override double getNoEntryValue(); @Override long getSizeBytes(); @Override PetrifyableTDoubleArrayList grep(TDoubleProcedure condition); @Override int indexOf(double value); @Override int indexOf(int offset, double value); @Override void insert(int offset, double value); @Override void insert(int offset, double[] values); @Override void insert(int offset, double[] values, int valOffset, int len); @Override PetrifyableTDoubleArrayList inverseGrep(TDoubleProcedure condition); @Override boolean isEmpty(); @Override TDoubleIterator iterator(); @Override int lastIndexOf(double value); @Override int lastIndexOf(int offset, double value); @Override double max(); @Override double min(); @Override synchronized void petrify(); @Override boolean remove(double value); @Override void remove(int offset, int length); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(double[] array); @Override boolean removeAll(TDoubleCollection collection); @Override double removeAt(int offset); @Override double replace(int offset, double val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(double[] array); @Override boolean retainAll(TDoubleCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override double set(int offset, double val); @Override void set(int offset, double[] values); @Override void set(int offset, double[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTDoubleArrayList subList(int begin, int end); @Override double sum(); @Override double[] toArray(); @Override double[] toArray(double[] dest); @Override double[] toArray(double[] dest, int offset, int len); @Override double[] toArray(double[] dest, int sourcePos, int destPos, int len); @Override double[] toArray(int offset, int len); @Override void transformValues(TDoubleFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testTransformValuesAfterPetrify2() { PETRIFIED_LIST.transformValues(new TDoubleFunction() { @Override public double execute(double value) { return 0; } }); }
### Question: PetrifyableTLongArrayList extends AbstractPetrifyable implements PetrifyableTLongList { @Override public boolean add(long val) { return myList.add(val); } PetrifyableTLongArrayList(); PetrifyableTLongArrayList(int capacity); PetrifyableTLongArrayList(long[] values); PetrifyableTLongArrayList(TLongCollection values); @Override boolean add(long val); @Override void add(long[] vals); @Override void add(long[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Long> collection); @Override boolean addAll(long[] array); @Override boolean addAll(TLongCollection collection); @Override int binarySearch(long value); @Override int binarySearch(long value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(long value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(long[] array); @Override boolean containsAll(TLongCollection collection); @Override void fill(int fromIndex, int toIndex, long val); @Override void fill(long val); @Override boolean forEach(TLongProcedure procedure); @Override boolean forEachDescending(TLongProcedure procedure); @Override long get(int offset); @Override long getNoEntryValue(); @Override long getSizeBytes(); @Override TLongList grep(TLongProcedure condition); @Override int indexOf(int offset, long value); @Override int indexOf(long value); @Override void insert(int offset, long value); @Override void insert(int offset, long[] values); @Override void insert(int offset, long[] values, int valOffset, int len); @Override TLongList inverseGrep(TLongProcedure condition); @Override boolean isEmpty(); @Override TLongIterator iterator(); @Override int lastIndexOf(int offset, long value); @Override int lastIndexOf(long value); @Override long max(); @Override long min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(long value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(long[] array); @Override boolean removeAll(TLongCollection collection); @Override long removeAt(int offset); @Override long replace(int offset, long val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(long[] array); @Override boolean retainAll(TLongCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override long set(int offset, long val); @Override void set(int offset, long[] values); @Override void set(int offset, long[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTLongArrayList subList(int begin, int end); @Override long sum(); @Override long[] toArray(); @Override long[] toArray(int offset, int len); @Override long[] toArray(long[] dest); @Override long[] toArray(long[] dest, int offset, int len); @Override long[] toArray(long[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TLongFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify1() { PETRIFIED_LIST.add(TEST_LONG); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify2() { PETRIFIED_LIST.add(TEST_LONG_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAfterPetrify3() { PETRIFIED_LIST.add(TEST_LONG_ARRAY, 0, 1); }
### Question: PetrifyableTLongArrayList extends AbstractPetrifyable implements PetrifyableTLongList { @Override public boolean addAll(Collection<? extends Long> collection) { return myList.addAll(collection); } PetrifyableTLongArrayList(); PetrifyableTLongArrayList(int capacity); PetrifyableTLongArrayList(long[] values); PetrifyableTLongArrayList(TLongCollection values); @Override boolean add(long val); @Override void add(long[] vals); @Override void add(long[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Long> collection); @Override boolean addAll(long[] array); @Override boolean addAll(TLongCollection collection); @Override int binarySearch(long value); @Override int binarySearch(long value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(long value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(long[] array); @Override boolean containsAll(TLongCollection collection); @Override void fill(int fromIndex, int toIndex, long val); @Override void fill(long val); @Override boolean forEach(TLongProcedure procedure); @Override boolean forEachDescending(TLongProcedure procedure); @Override long get(int offset); @Override long getNoEntryValue(); @Override long getSizeBytes(); @Override TLongList grep(TLongProcedure condition); @Override int indexOf(int offset, long value); @Override int indexOf(long value); @Override void insert(int offset, long value); @Override void insert(int offset, long[] values); @Override void insert(int offset, long[] values, int valOffset, int len); @Override TLongList inverseGrep(TLongProcedure condition); @Override boolean isEmpty(); @Override TLongIterator iterator(); @Override int lastIndexOf(int offset, long value); @Override int lastIndexOf(long value); @Override long max(); @Override long min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(long value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(long[] array); @Override boolean removeAll(TLongCollection collection); @Override long removeAt(int offset); @Override long replace(int offset, long val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(long[] array); @Override boolean retainAll(TLongCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override long set(int offset, long val); @Override void set(int offset, long[] values); @Override void set(int offset, long[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTLongArrayList subList(int begin, int end); @Override long sum(); @Override long[] toArray(); @Override long[] toArray(int offset, int len); @Override long[] toArray(long[] dest); @Override long[] toArray(long[] dest, int offset, int len); @Override long[] toArray(long[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TLongFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify1() { PETRIFIED_LIST.addAll(TEST_LONG_ARRAY); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify2() { PETRIFIED_LIST.addAll(TEST_LONG_COLLECTION); } @Test(expected = UnsupportedOperationException.class) public void testAddAllAfterPetrify3() { PETRIFIED_LIST.addAll(TEST_LONG_ARRAY_LIST); }
### Question: DefaultDataGroupAndTypeFactory implements DataGroupAndTypeFactory { @Override public DefaultDataGroupInfo createGroup(Toolbox toolbox, String providerType, String folderName, Consumer<DataGroupInfo> deleteListener) { DefaultDataGroupInfo group; if (deleteListener != null) { group = new DefaultDeletableDataGroupInfo(false, toolbox, providerType, folderName); group.setAssistant(new DeletableDataGroupInfoAssistant(MantleToolboxUtils.getMantleToolbox(toolbox), null, null, deleteListener)); } else { group = new DefaultDataGroupInfo(false, toolbox, providerType, folderName); } return group; } @Override DefaultDataGroupInfo createGroup(Toolbox toolbox, String providerType, String folderName, Consumer<DataGroupInfo> deleteListener); @Override DefaultDataTypeInfo createType(Toolbox toolbox, String providerType, String id, String typeName, String layerName); }### Answer: @Test public void testCreateGroup() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = support.createMock(Toolbox.class); support.replayAll(); DefaultDataGroupAndTypeFactory factory = new DefaultDataGroupAndTypeFactory(); DefaultDataGroupInfo group = factory.createGroup(toolbox, ourProviderType, ourFolderName, null); assertEquals(toolbox, group.getToolbox()); assertEquals(ourProviderType, group.getProviderType()); assertEquals(ourFolderName, group.getDisplayName()); support.verifyAll(); } @Test public void testCreateGroupDelete() { EasyMockSupport support = new EasyMockSupport(); MantleToolbox mantle = support.createMock(MantleToolbox.class); Toolbox toolbox = createToolbox(support, mantle); @SuppressWarnings("unchecked") Consumer<DataGroupInfo> deleteListener = support.createMock(Consumer.class); support.replayAll(); DefaultDataGroupAndTypeFactory factory = new DefaultDataGroupAndTypeFactory(); DefaultDataGroupInfo group = factory.createGroup(toolbox, ourProviderType, ourFolderName, deleteListener); assertEquals(toolbox, group.getToolbox()); assertEquals(ourProviderType, group.getProviderType()); assertEquals(ourFolderName, group.getDisplayName()); assertTrue(group instanceof DefaultDeletableDataGroupInfo); assertTrue(group.getAssistant() instanceof DeletableDataGroupInfoAssistant); support.verifyAll(); }
### Question: PetrifyableTLongArrayList extends AbstractPetrifyable implements PetrifyableTLongList { @Override public void clear() { myList.clear(); } PetrifyableTLongArrayList(); PetrifyableTLongArrayList(int capacity); PetrifyableTLongArrayList(long[] values); PetrifyableTLongArrayList(TLongCollection values); @Override boolean add(long val); @Override void add(long[] vals); @Override void add(long[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Long> collection); @Override boolean addAll(long[] array); @Override boolean addAll(TLongCollection collection); @Override int binarySearch(long value); @Override int binarySearch(long value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(long value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(long[] array); @Override boolean containsAll(TLongCollection collection); @Override void fill(int fromIndex, int toIndex, long val); @Override void fill(long val); @Override boolean forEach(TLongProcedure procedure); @Override boolean forEachDescending(TLongProcedure procedure); @Override long get(int offset); @Override long getNoEntryValue(); @Override long getSizeBytes(); @Override TLongList grep(TLongProcedure condition); @Override int indexOf(int offset, long value); @Override int indexOf(long value); @Override void insert(int offset, long value); @Override void insert(int offset, long[] values); @Override void insert(int offset, long[] values, int valOffset, int len); @Override TLongList inverseGrep(TLongProcedure condition); @Override boolean isEmpty(); @Override TLongIterator iterator(); @Override int lastIndexOf(int offset, long value); @Override int lastIndexOf(long value); @Override long max(); @Override long min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(long value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(long[] array); @Override boolean removeAll(TLongCollection collection); @Override long removeAt(int offset); @Override long replace(int offset, long val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(long[] array); @Override boolean retainAll(TLongCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override long set(int offset, long val); @Override void set(int offset, long[] values); @Override void set(int offset, long[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTLongArrayList subList(int begin, int end); @Override long sum(); @Override long[] toArray(); @Override long[] toArray(int offset, int len); @Override long[] toArray(long[] dest); @Override long[] toArray(long[] dest, int offset, int len); @Override long[] toArray(long[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TLongFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testClearAfterPetrify() { PETRIFIED_LIST.clear(); }
### Question: PetrifyableTLongArrayList extends AbstractPetrifyable implements PetrifyableTLongList { @Override public void fill(int fromIndex, int toIndex, long val) { myList.fill(fromIndex, toIndex, val); } PetrifyableTLongArrayList(); PetrifyableTLongArrayList(int capacity); PetrifyableTLongArrayList(long[] values); PetrifyableTLongArrayList(TLongCollection values); @Override boolean add(long val); @Override void add(long[] vals); @Override void add(long[] vals, int offset, int length); @Override boolean addAll(Collection<? extends Long> collection); @Override boolean addAll(long[] array); @Override boolean addAll(TLongCollection collection); @Override int binarySearch(long value); @Override int binarySearch(long value, int fromIndex, int toIndex); @Override void clear(); @Override boolean contains(long value); @Override boolean containsAll(Collection<?> collection); @Override boolean containsAll(long[] array); @Override boolean containsAll(TLongCollection collection); @Override void fill(int fromIndex, int toIndex, long val); @Override void fill(long val); @Override boolean forEach(TLongProcedure procedure); @Override boolean forEachDescending(TLongProcedure procedure); @Override long get(int offset); @Override long getNoEntryValue(); @Override long getSizeBytes(); @Override TLongList grep(TLongProcedure condition); @Override int indexOf(int offset, long value); @Override int indexOf(long value); @Override void insert(int offset, long value); @Override void insert(int offset, long[] values); @Override void insert(int offset, long[] values, int valOffset, int len); @Override TLongList inverseGrep(TLongProcedure condition); @Override boolean isEmpty(); @Override TLongIterator iterator(); @Override int lastIndexOf(int offset, long value); @Override int lastIndexOf(long value); @Override long max(); @Override long min(); @Override synchronized void petrify(); @Override void remove(int offset, int length); @Override boolean remove(long value); @Override boolean removeAll(Collection<?> collection); @Override boolean removeAll(long[] array); @Override boolean removeAll(TLongCollection collection); @Override long removeAt(int offset); @Override long replace(int offset, long val); @Override boolean retainAll(Collection<?> collection); @Override boolean retainAll(long[] array); @Override boolean retainAll(TLongCollection collection); @Override void reverse(); @Override void reverse(int from, int to); @Override long set(int offset, long val); @Override void set(int offset, long[] values); @Override void set(int offset, long[] values, int valOffset, int length); @Override void shuffle(Random rand); @Override int size(); @Override void sort(); @Override void sort(int fromIndex, int toIndex); @Override PetrifyableTLongArrayList subList(int begin, int end); @Override long sum(); @Override long[] toArray(); @Override long[] toArray(int offset, int len); @Override long[] toArray(long[] dest); @Override long[] toArray(long[] dest, int offset, int len); @Override long[] toArray(long[] dest, int sourcePos, int destPos, int len); @Override void transformValues(TLongFunction function); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify1() { PETRIFIED_LIST.fill(TEST_LONG); } @Test(expected = UnsupportedOperationException.class) public void testFillAfterPetrify2() { PETRIFIED_LIST.fill(0, 1, TEST_LONG); }