method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public ArrayListOfDoubles add(double e) { ensureCapacity(size + 1); array[size++] = e; return this; } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testIterable() { int size = 1000; Random r = new Random(); double[] doubles = new double[size]; ArrayListOfDoubles list = new ArrayListOfDoubles(); for (int i = 0; i < size; i++) { double k = r.nextDouble(); list.add(k); doubles[i] = k; } int i = 0; for (Double v : list) { assertEquals(doubles[i++], v, 10e-5); } }
|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public void setSize(int sz) { ensureCapacity(sz); size = sz; } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSetSize() { ArrayListOfDoubles list = new ArrayListOfDoubles(); list.add(5); assertEquals(1, list.size); assertEquals(5, list.get(0), 10e-6); list.setSize(5); assertEquals(5, list.size); assertEquals(0, list.get(1), 10e-6); assertEquals(0, list.get(2), 10e-6); assertEquals(0, list.get(3), 10e-6); assertEquals(0, list.get(4), 10e-6); list.add(12); assertEquals(6, list.size); assertEquals(12, list.get(5), 10e-6); }
|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public void sort() { trimToSize(); Arrays.sort(getArray()); } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSort() { ArrayListOfDoubles a = new ArrayListOfDoubles(); assertEquals(0, a.size()); a.add(5.2f).add(6f).add(5.9f).add(4.1f); assertEquals(4, a.size()); a.sort(); assertEquals(4, a.size()); assertTrue(Math.abs(a.get(0) - 4.1) < 0.0001); assertTrue(Math.abs(a.get(1) - 5.2) < 0.0001); assertTrue(Math.abs(a.get(2) - 5.9) < 0.0001); assertTrue(Math.abs(a.get(3) - 6) < 0.0001); }
|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public ArrayListOfDoubles subList(int start, int end) { ArrayListOfDoubles sublst = new ArrayListOfDoubles(end - start + 1); for (int i = start; i <= end; i++) { sublst.add(get(i)); } return sublst; } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSubList() { ArrayListOfDoubles a = new ArrayListOfDoubles(new double[] { 1, 2, 3, 4, 5, 6, 7 }); ArrayListOfDoubles c = a.subList(1, 5); assertEquals(5, c.size()); assertTrue(Math.abs(2 - c.get(0)) < 0.0001); assertTrue(Math.abs(3 - c.get(1)) < 0.0001); assertTrue(Math.abs(4 - c.get(2)) < 0.0001); assertTrue(Math.abs(5 - c.get(3)) < 0.0001); assertTrue(Math.abs(6 - c.get(4)) < 0.0001); a.clear(); assertEquals(5, c.size()); assertTrue(Math.abs(2 - c.get(0)) < 0.0001); assertTrue(Math.abs(3 - c.get(1)) < 0.0001); assertTrue(Math.abs(4 - c.get(2)) < 0.0001); assertTrue(Math.abs(5 - c.get(3)) < 0.0001); assertTrue(Math.abs(6 - c.get(4)) < 0.0001); }
|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public void addUnique(int[] arr) { for (int i = 0; i < arr.length; i++) { int elt = arr[i]; if (!contains(elt)) { add(elt); } } } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testAddUnique() { ArrayListOfDoubles a = new ArrayListOfDoubles(new double[] { 1, 2, 3, 4, 5, 6, 7 }); a.addUnique(new int[] { 8, 0, 2, 5, -1, 11, 9 }); assertEquals(12, a.size()); assertTrue(Math.abs(0 - a.get(8)) < 0.0001); assertTrue(Math.abs(-1 - a.get(9)) < 0.0001); assertTrue(Math.abs(11 - a.get(10)) < 0.0001); assertTrue(Math.abs(9 - a.get(11)) < 0.0001); }
|
### Question:
ArrayListOfFloatsWritable extends ArrayListOfFloats implements
WritableComparable<ArrayListOfFloatsWritable> { @Override public int compareTo(ArrayListOfFloatsWritable obj) { ArrayListOfFloatsWritable other = (ArrayListOfFloatsWritable) obj; if (isEmpty()) { if (other.isEmpty()) { return 0; } else { return -1; } } for (int i = 0; i < size(); i++) { if (other.size() <= i) { return 1; } if (get(i) < other.get(i)) { return -1; } else if (get(i) > other.get(i)) { return 1; } } if (other.size() > size()) { return -1; } else { return 0; } } ArrayListOfFloatsWritable(); ArrayListOfFloatsWritable(int initialCapacity); ArrayListOfFloatsWritable(ArrayListOfFloatsWritable other); ArrayListOfFloatsWritable(float[] arr); void readFields(DataInput in); void write(DataOutput out); @Override String toString(); static ArrayListOfFloatsWritable fromArrayListOfFloats(ArrayListOfFloats a); @Override int compareTo(ArrayListOfFloatsWritable obj); }### Answer:
@Test public void testCompare() { ArrayListOfFloatsWritable a = new ArrayListOfFloatsWritable(); a.add(one).add(three).add(five); ArrayListOfFloatsWritable b = new ArrayListOfFloatsWritable(); b.add(one).add(three).add(five).add(seven); assertTrue(b.compareTo(a) > 0); b.remove(3); assertTrue(b.compareTo(a) == 0); b.remove(2); assertTrue(b.compareTo(a) < 0); ArrayListOfFloatsWritable c = new ArrayListOfFloatsWritable(); assertTrue(b.compareTo(c) > 0); assertTrue(c.compareTo(a) < 0); assertTrue(a.compareTo(c) > 0); assertTrue(c.compareTo(b) < 0); }
@Test public void testCompare2() { ArrayListOfFloatsWritable a = new ArrayListOfFloatsWritable(); a.add(one).add(three).add(six); ArrayListOfFloatsWritable b = new ArrayListOfFloatsWritable(); b.add(one).add(three).add(four); assertTrue(a.compareTo(b) > 0); ArrayListOfFloatsWritable c = new ArrayListOfFloatsWritable(); c.add(one).add(three).add(four).add(nine); assertTrue(c.compareTo(a) < 0); assertTrue(b.compareTo(c) < 0); ArrayListOfFloatsWritable d = new ArrayListOfFloatsWritable(); d.add(two).add(four); ArrayListOfFloatsWritable e = new ArrayListOfFloatsWritable(); e.add(zero).add(two); assertTrue(d.compareTo(a) > 0); assertTrue(d.compareTo(b) > 0); assertTrue(d.compareTo(c) > 0); assertTrue(e.compareTo(a) < 0); assertTrue(e.compareTo(b) < 0); assertTrue(e.compareTo(c) < 0); assertTrue(e.compareTo(d) < 0); }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public int size() { return size; } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testInitialSize() { ArrayListOfShorts a = new ArrayListOfShorts(); assertEquals(0, a.size()); }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public short remove(int index) { if (index >= size) { throw new ArrayIndexOutOfBoundsException(); } short oldValue = array[index]; int numMoved = size - index - 1; if (numMoved > 0) { System.arraycopy(array, index + 1, array, index, numMoved); } size--; return oldValue; } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testArrayConstructor() { short[] arr = new short[] { 1, 2, 3, 4, 5 }; assertEquals(5, arr.length); ArrayListOfShorts list = new ArrayListOfShorts(arr); list.remove(2); assertEquals(1, arr[0]); assertEquals(2, arr[1]); assertEquals(3, arr[2]); assertEquals(4, arr[3]); assertEquals(5, arr[4]); }
@Test public void testRemove() { ArrayListOfShorts list = new ArrayListOfShorts(); for (int i = 0; i < 10; i++) { list.add((short) i); } list.remove(list.indexOf((short) 5)); assertEquals(9, list.size()); assertEquals(0, list.get(0)); assertEquals(1, list.get(1)); assertEquals(2, list.get(2)); assertEquals(3, list.get(3)); assertEquals(4, list.get(4)); assertEquals(6, list.get(5)); assertEquals(7, list.get(6)); assertEquals(8, list.get(7)); assertEquals(9, list.get(8)); list.remove(list.indexOf((short) 9)); assertEquals(8, list.size); assertEquals(0, list.get(0)); assertEquals(1, list.get(1)); assertEquals(2, list.get(2)); assertEquals(3, list.get(3)); assertEquals(4, list.get(4)); assertEquals(6, list.get(5)); assertEquals(7, list.get(6)); assertEquals(8, list.get(7)); }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public ArrayListOfShorts clone() { return new ArrayListOfShorts(Arrays.copyOf(array, this.size())); } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testClone() { int size = 10000; Random r = new Random(); int[] shorts = new int[size]; ArrayListOfShorts list1 = new ArrayListOfShorts(); for (int i = 0; i < size; i++) { short k = (short) r.nextInt(size); list1.add(k); shorts[i] = k; } ArrayListOfShorts list2 = list1.clone(); assertEquals(size, list1.size()); assertEquals(size, list2.size()); for (int i = 0; i < size; i++) { list2.set(i, (short) (shorts[i] + 1)); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(shorts[i], list1.get(i)); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(shorts[i] + 1, list2.get(i)); } }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public String toString(int n) { StringBuilder s = new StringBuilder(); s.append("["); int sz = size() > n ? n : size; for (int i = 0; i < sz; i++) { s.append(get(i)); if (i < sz - 1) { s.append(", "); } } s.append(size() > n ? String.format(" ... (%d more) ]", size() - n) : "]"); return s.toString(); } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testToString1() { assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", new ArrayListOfShorts((short) 1, (short) 11).toString()); assertEquals("[1, 2, 3, 4, 5 ... (5 more) ]", new ArrayListOfShorts((short) 1, (short) 11).toString(5)); assertEquals("[1, 2, 3, 4, 5]", new ArrayListOfShorts((short) 1, (short) 6).toString()); assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", new ArrayListOfShorts((short) 1, (short) 12).toString(11)); assertEquals("[]", new ArrayListOfShorts().toString()); }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public ArrayListOfShorts add(short e) { ensureCapacity(size + 1); array[size++] = e; return this; } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testIterable() { int size = 1000; Random r = new Random(); short[] shorts = new short[size]; ArrayListOfShorts list = new ArrayListOfShorts(); for (int i = 0; i < size; i++) { short k = (short) r.nextInt(size); list.add(k); shorts[i] = k; } int i = 0; for (Short v : list) { assertEquals(shorts[i++], (short) v); } }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public void setSize(int sz) { ensureCapacity(sz); size = sz; } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSetSize() { ArrayListOfShorts list = new ArrayListOfShorts(); list.add((short) 5); assertEquals(1, list.size); assertEquals(5, list.get(0)); list.setSize(5); assertEquals(5, list.size); assertEquals(0, list.get(1)); assertEquals(0, list.get(2)); assertEquals(0, list.get(3)); assertEquals(0, list.get(4)); list.add((short) 12); assertEquals(6, list.size); assertEquals(12, list.get(5)); }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public void sort() { trimToSize(); Arrays.sort(getArray()); } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSort() { ArrayListOfShorts a = new ArrayListOfShorts(); assertEquals(0, a.size()); a.add((short) 5); a.add((short) 6); a.add((short) 1); a.add((short) 4); assertEquals(4, a.size()); a.sort(); assertEquals(4, a.size()); assertEquals(1, a.get(0)); assertEquals(4, a.get(1)); assertEquals(5, a.get(2)); assertEquals(6, a.get(3)); }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public ArrayListOfShorts subList(int start, int end) { ArrayListOfShorts sublst = new ArrayListOfShorts(end - start + 1); for (int i = start; i <= end; i++) { sublst.add(get(i)); } return sublst; } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSubList() { ArrayListOfShorts a = new ArrayListOfShorts(new short[] { 1, 2, 3, 4, 5, 6, 7 }); ArrayListOfShorts b = a.subList(1, 5); assertEquals(5, b.size()); assertEquals(2, b.get(0)); assertEquals(3, b.get(1)); assertEquals(4, b.get(2)); assertEquals(5, b.get(3)); assertEquals(6, b.get(4)); a.clear(); assertEquals(5, b.size()); assertEquals(2, b.get(0)); assertEquals(3, b.get(1)); assertEquals(4, b.get(2)); assertEquals(5, b.get(3)); assertEquals(6, b.get(4)); }
|
### Question:
ArrayListOfShorts implements RandomAccess, Cloneable, Iterable<Short> { public void addUnique(short[] arr) { for (int i = 0; i < arr.length; i++) { short elt = arr[i]; if (!contains(elt)) { add(elt); } } } ArrayListOfShorts(int initialCapacity); ArrayListOfShorts(); ArrayListOfShorts(short[] a); ArrayListOfShorts(short first, short last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(short n); int indexOf(short n); int lastIndexOf(short n); ArrayListOfShorts clone(); short get(int index); short set(int index, short element); ArrayListOfShorts add(short e); ArrayListOfShorts add(int index, short element); short remove(int index); void clear(); short[] getArray(); Iterator<Short> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfShorts intersection(ArrayListOfShorts other); ArrayListOfShorts merge(ArrayListOfShorts sortedLst); ArrayListOfShorts subList(int start, int end); void addUnique(short[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testAddUnique() { ArrayListOfShorts a = new ArrayListOfShorts(new short[] { 1, 2, 3, 4, 5, 6, 7 }); a.addUnique(new short[] { 8, 0, 2, 5, -1, 11, 9 }); assertEquals(12, a.size()); assertEquals(0, a.get(8)); assertEquals(-1, a.get(9)); assertEquals(11, a.get(10)); assertEquals(9, a.get(11)); }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public int size() { return size; } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testInitialSize() { ArrayListOfLongs a = new ArrayListOfLongs(); assertEquals(0, a.size()); }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public long remove(int index) { if (index >= size) { throw new ArrayIndexOutOfBoundsException(); } long oldValue = array[index]; int numMoved = size - index - 1; if (numMoved > 0) { System.arraycopy(array, index + 1, array, index, numMoved); } size--; return oldValue; } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testArrayConstructor() { long[] arr = new long[] { 1, 2, 3, 4, 5 }; assertEquals(5, arr.length); ArrayListOfLongs list = new ArrayListOfLongs(arr); list.remove(2); assertEquals(1, arr[0]); assertEquals(2, arr[1]); assertEquals(3, arr[2]); assertEquals(4, arr[3]); assertEquals(5, arr[4]); }
@Test public void testRemove() { ArrayListOfLongs list = new ArrayListOfLongs(); for (int i = 0; i < 10; i++) { list.add(i); } list.remove(list.indexOf(5)); assertEquals(9, list.size()); assertEquals(0, list.get(0)); assertEquals(1, list.get(1)); assertEquals(2, list.get(2)); assertEquals(3, list.get(3)); assertEquals(4, list.get(4)); assertEquals(6, list.get(5)); assertEquals(7, list.get(6)); assertEquals(8, list.get(7)); assertEquals(9, list.get(8)); list.remove(list.indexOf(9)); assertEquals(8, list.size()); assertEquals(0, list.get(0)); assertEquals(1, list.get(1)); assertEquals(2, list.get(2)); assertEquals(3, list.get(3)); assertEquals(4, list.get(4)); assertEquals(6, list.get(5)); assertEquals(7, list.get(6)); assertEquals(8, list.get(7)); }
|
### Question:
Int2LongOpenHashMapWritable extends Int2LongOpenHashMap implements Writable { public void increment(int key) { increment(key, 1); } Int2LongOpenHashMapWritable(); void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); void write(DataOutput out); byte[] serialize(); static Int2LongOpenHashMapWritable create(DataInput in); static Int2LongOpenHashMapWritable create(byte[] bytes); void plus(Int2LongOpenHashMapWritable m); long dot(Int2LongOpenHashMapWritable m); void increment(int key); void increment(int key, long n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); long[] getValues(); void lazyplus(Int2LongOpenHashMapWritable m); Int2LongMap.Entry[] getEntriesSortedByValue(); Int2LongMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testIncrement() throws IOException { Int2LongOpenHashMapWritable m = new Int2LongOpenHashMapWritable(); m.put(2, 7L); m.put(1, 29L); assertEquals(7L, m.get(2)); assertEquals(29L, m.get(1)); m.increment(2); m.increment(1); m.increment(3); assertEquals(8L, m.get(2)); assertEquals(30L, m.get(1)); assertEquals(1L, m.get(3)); m.increment(1, 3L); m.increment(3, 5L); assertEquals(8L, m.get(2)); assertEquals(33L, m.get(1)); assertEquals(6L, m.get(3)); }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public ArrayListOfLongs clone() { return new ArrayListOfLongs(Arrays.copyOf(array, this.size())); } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testClone() { int size = 100000; Random r = new Random(); long[] longs = new long[size]; ArrayListOfLongs list1 = new ArrayListOfLongs(); for (int i = 0; i < size; i++) { long k = r.nextLong(); list1.add(k); longs[i] = k; } ArrayListOfLongs list2 = list1.clone(); assertEquals(size, list1.size()); assertEquals(size, list2.size()); for (int i = 0; i < size; i++) { list2.set(i, longs[i] + 1); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(longs[i], list1.get(i)); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(longs[i] + 1, list2.get(i)); } }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public String toString(int n) { StringBuilder s = new StringBuilder(); s.append("["); int sz = size() > n ? n : size; for (int i = 0; i < sz; i++) { s.append(get(i)); if (i < sz - 1) { s.append(", "); } } s.append(size() > n ? String.format(" ... (%d more) ]", size() - n) : "]"); return s.toString(); } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testToString1() { assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", new ArrayListOfLongs(1, 11).toString()); assertEquals("[1, 2, 3, 4, 5 ... (5 more) ]", new ArrayListOfLongs(1, 11).toString(5)); assertEquals("[1, 2, 3, 4, 5]", new ArrayListOfLongs(1, 6).toString()); assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", new ArrayListOfLongs(1, 12).toString(11)); assertEquals("[]", new ArrayListOfLongs().toString()); }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public ArrayListOfLongs add(long e) { ensureCapacity(size + 1); array[size++] = e; return this; } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testIterable() { int size = 1000; Random r = new Random(); long[] longs = new long[size]; ArrayListOfLongs list = new ArrayListOfLongs(); for (int i = 0; i < size; i++) { long k = r.nextLong(); list.add(k); longs[i] = k; } int i = 0; for (Long v : list) { assertEquals(longs[i++], (long) v); } }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public void setSize(int sz) { ensureCapacity(sz); size = sz; } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSetSize() { ArrayListOfLongs list = new ArrayListOfLongs(); list.add(5L); assertEquals(1, list.size); assertEquals(5L, list.get(0)); list.setSize(5); assertEquals(5L, list.size); assertEquals(0, list.get(1)); assertEquals(0, list.get(2)); assertEquals(0, list.get(3)); assertEquals(0, list.get(4)); list.add(12L); assertEquals(6, list.size); assertEquals(12L, list.get(5)); }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public void sort() { trimToSize(); Arrays.sort(getArray()); } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSort() { ArrayListOfLongs a = new ArrayListOfLongs(); assertEquals(0, a.size()); a.add(5).add(6).add(1).add(4); assertEquals(4, a.size()); a.sort(); assertEquals(4, a.size()); assertEquals(1, a.get(0)); assertEquals(4, a.get(1)); assertEquals(5, a.get(2)); assertEquals(6, a.get(3)); }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public ArrayListOfLongs subList(int start, int end) { ArrayListOfLongs sublst = new ArrayListOfLongs(end - start + 1); for (int i = start; i <= end; i++) { sublst.add(get(i)); } return sublst; } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSubList() { ArrayListOfLongs a = new ArrayListOfLongs(new long[] { 1, 2, 3, 4, 5, 6, 7 }); ArrayListOfLongs b = a.subList(1, 5); assertEquals(5, b.size()); assertEquals(2, b.get(0)); assertEquals(3, b.get(1)); assertEquals(4, b.get(2)); assertEquals(5, b.get(3)); assertEquals(6, b.get(4)); a.clear(); assertEquals(5, b.size()); assertEquals(2, b.get(0)); assertEquals(3, b.get(1)); assertEquals(4, b.get(2)); assertEquals(5, b.get(3)); assertEquals(6, b.get(4)); }
|
### Question:
ArrayListOfLongs implements RandomAccess, Cloneable, Iterable<Long> { public void addUnique(long[] arr) { for (int i = 0; i < arr.length; i++) { long elt = arr[i]; if (!contains(elt)) { add(elt); } } } ArrayListOfLongs(int initialCapacity); ArrayListOfLongs(); ArrayListOfLongs(long[] a); ArrayListOfLongs(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(long n); int indexOf(long n); int lastIndexOf(long n); ArrayListOfLongs clone(); long get(int index); long set(int index, long element); ArrayListOfLongs add(long e); ArrayListOfLongs add(int index, long element); long remove(int index); void clear(); long[] getArray(); Iterator<Long> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfLongs intersection(ArrayListOfLongs other); ArrayListOfLongs merge(ArrayListOfLongs sortedLst); ArrayListOfLongs subList(int start, int end); void addUnique(long[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testAddUnique() { ArrayListOfLongs a = new ArrayListOfLongs(new long[] { 1, 2, 3, 4, 5, 6, 7 }); a.addUnique(new long[] { 8, 0, 2, 5, -1, 11, 9 }); assertEquals(12, a.size()); assertEquals(0, a.get(8)); assertEquals(-1, a.get(9)); assertEquals(11, a.get(10)); assertEquals(9, a.get(11)); }
|
### Question:
ArrayListOfShortsWritable extends ArrayListOfShorts implements
WritableComparable<ArrayListOfShortsWritable> { @Override public String toString() { return toString(size()); } ArrayListOfShortsWritable(); ArrayListOfShortsWritable(int initialCapacity); ArrayListOfShortsWritable(short first, short last); ArrayListOfShortsWritable(ArrayListOfShortsWritable other); ArrayListOfShortsWritable(short[] arr); void readFields(DataInput in); void write(DataOutput out); @Override String toString(); static ArrayListOfShortsWritable fromArrayListOfShorts(ArrayListOfShorts a); @Override int compareTo(ArrayListOfShortsWritable obj); }### Answer:
@Test public void testToString() { assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", new ArrayListOfShortsWritable((short) 1, (short) 11).toString()); assertEquals("[1, 2, 3, 4, 5 ... (5 more) ]", new ArrayListOfShortsWritable((short) 1, (short) 11).toString(5)); assertEquals("[1, 2, 3, 4, 5]", new ArrayListOfShortsWritable((short) 1, (short) 6).toString()); assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", new ArrayListOfShortsWritable((short) 1, (short) 12).toString()); assertEquals("[]", new ArrayListOfShortsWritable().toString()); }
|
### Question:
ArrayListOfShortsWritable extends ArrayListOfShorts implements
WritableComparable<ArrayListOfShortsWritable> { @Override public int compareTo(ArrayListOfShortsWritable obj) { ArrayListOfShortsWritable other = (ArrayListOfShortsWritable) obj; if (isEmpty()) { if (other.isEmpty()) { return 0; } else { return -1; } } for (int i = 0; i < size(); i++) { if (other.size() <= i) { return 1; } if (get(i) < other.get(i)) { return -1; } else if (get(i) > other.get(i)) { return 1; } } if (other.size() > size()) { return -1; } else { return 0; } } ArrayListOfShortsWritable(); ArrayListOfShortsWritable(int initialCapacity); ArrayListOfShortsWritable(short first, short last); ArrayListOfShortsWritable(ArrayListOfShortsWritable other); ArrayListOfShortsWritable(short[] arr); void readFields(DataInput in); void write(DataOutput out); @Override String toString(); static ArrayListOfShortsWritable fromArrayListOfShorts(ArrayListOfShorts a); @Override int compareTo(ArrayListOfShortsWritable obj); }### Answer:
@Test public void testCompare() { ArrayListOfShortsWritable a = new ArrayListOfShortsWritable(); a.add(one).add(three).add(five); ArrayListOfShortsWritable b = new ArrayListOfShortsWritable(); b.add(one).add(three).add(five).add(seven); assertTrue(b.compareTo(a) > 0); b.remove(3); assertTrue(b.compareTo(a) == 0); b.remove(2); assertTrue(b.compareTo(a) < 0); ArrayListOfShortsWritable c = new ArrayListOfShortsWritable(); assertTrue(b.compareTo(c) > 0); assertTrue(c.compareTo(a) < 0); assertTrue(a.compareTo(c) > 0); assertTrue(c.compareTo(b) < 0); }
@Test public void testCompare2() { ArrayListOfShortsWritable a = new ArrayListOfShortsWritable(); a.add(one).add(three).add(six); ArrayListOfShortsWritable b = new ArrayListOfShortsWritable(); b.add(one).add(three).add(four); assertTrue(a.compareTo(b) > 0); ArrayListOfShortsWritable c = new ArrayListOfShortsWritable(); c.add(one).add(three).add(four).add(nine); assertTrue(c.compareTo(a) < 0); assertTrue(b.compareTo(c) < 0); ArrayListOfShortsWritable d = new ArrayListOfShortsWritable(); d.add(two).add(four); ArrayListOfShortsWritable e = new ArrayListOfShortsWritable(); e.add(zero).add(two); assertTrue(d.compareTo(a) > 0); assertTrue(d.compareTo(b) > 0); assertTrue(d.compareTo(c) > 0); assertTrue(e.compareTo(a) < 0); assertTrue(e.compareTo(b) < 0); assertTrue(e.compareTo(c) < 0); assertTrue(e.compareTo(d) < 0); }
|
### Question:
Int2LongOpenHashMapWritable extends Int2LongOpenHashMap implements Writable { public void plus(Int2LongOpenHashMapWritable m) { for (Int2LongMap.Entry e : m.int2LongEntrySet()) { int key = e.getIntKey(); long value = e.getLongValue(); if (this.containsKey(key)) { this.put(key, this.get(key) + value); } else { this.put(key, value); } } } Int2LongOpenHashMapWritable(); void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); void write(DataOutput out); byte[] serialize(); static Int2LongOpenHashMapWritable create(DataInput in); static Int2LongOpenHashMapWritable create(byte[] bytes); void plus(Int2LongOpenHashMapWritable m); long dot(Int2LongOpenHashMapWritable m); void increment(int key); void increment(int key, long n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); long[] getValues(); void lazyplus(Int2LongOpenHashMapWritable m); Int2LongMap.Entry[] getEntriesSortedByValue(); Int2LongMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testPlus() throws IOException { Int2LongOpenHashMapWritable m1 = new Int2LongOpenHashMapWritable(); m1.put(1, 5L); m1.put(2, 22L); Int2LongOpenHashMapWritable m2 = new Int2LongOpenHashMapWritable(); m2.put(1, 4L); m2.put(3, 5L); m1.plus(m2); assertEquals(3L, m1.size()); assertEquals(9L, m1.get(1)); assertEquals(22L, m1.get(2)); assertEquals(5L, m1.get(3)); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public Multiplication createRandomMultiplication() { int factorA = randomGeneratorService.generateRandomFactor(); int factorB = randomGeneratorService.generateRandomFactor(); return new Multiplication(factorA, factorB); } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService); @Override Multiplication createRandomMultiplication(); @Override boolean checkAttempt(final MultiplicationResultAttempt resultAttempt); }### Answer:
@Test public void createRandomMultiplicationTest() { given(randomGeneratorService.generateRandomFactor()).willReturn(50, 30); Multiplication multiplication = multiplicationServiceImpl.createRandomMultiplication(); assertThat(multiplication.getFactorA()).isEqualTo(50); assertThat(multiplication.getFactorB()).isEqualTo(30); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public boolean checkAttempt(final MultiplicationResultAttempt resultAttempt) { return resultAttempt.getResultAttempt() == resultAttempt.getMultiplication().getFactorA() * resultAttempt.getMultiplication().getFactorB(); } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService); @Override Multiplication createRandomMultiplication(); @Override boolean checkAttempt(final MultiplicationResultAttempt resultAttempt); }### Answer:
@Test public void checkCorrectAttemptTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt(user, multiplication, 3000); boolean attemptResult = multiplicationServiceImpl.checkAttempt(attempt); assertThat(attemptResult).isTrue(); }
@Test public void checkWrongAttemptTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt(user, multiplication, 3010); boolean attemptResult = multiplicationServiceImpl.checkAttempt(attempt); assertThat(attemptResult).isFalse(); }
|
### Question:
GameServiceImpl implements GameService { @Override public GameStats retrieveStatsForUser(final Long userId) { Integer score = scoreCardRepository.getTotalScoreForUser(userId); if(score == null) { return new GameStats(userId, 0, Collections.emptyList()); } List<BadgeCard> badgeCards = badgeCardRepository .findByUserIdOrderByBadgeTimestampDesc(userId); return new GameStats(userId, score, badgeCards.stream() .map(BadgeCard::getBadge).collect(Collectors.toList())); } GameServiceImpl(ScoreCardRepository scoreCardRepository,
BadgeCardRepository badgeCardRepository,
MultiplicationResultAttemptClient attemptClient); @Override GameStats newAttemptForUser(final Long userId,
final Long attemptId,
final boolean correct); @Override GameStats retrieveStatsForUser(final Long userId); @Override ScoreCard getScoreForAttempt(final Long attemptId); static final int LUCKY_NUMBER; }### Answer:
@Test public void retrieveStatsForUserTest() { Long userId = 1L; int totalScore = 1000; BadgeCard badgeCard = new BadgeCard(userId, Badge.SILVER_MULTIPLICATOR); given(scoreCardRepository.getTotalScoreForUser(userId)) .willReturn(totalScore); given(badgeCardRepository.findByUserIdOrderByBadgeTimestampDesc(userId)) .willReturn(Collections.singletonList(badgeCard)); GameStats stats = gameService.retrieveStatsForUser(userId); assertThat(stats.getScore()).isEqualTo(totalScore); assertThat(stats.getBadges()).containsOnly(Badge.SILVER_MULTIPLICATOR); }
|
### Question:
ScoreController { @GetMapping("/{attemptId}") public ScoreCard getScoreForAttempt( @PathVariable("attemptId") final Long attemptId) { return gameService.getScoreForAttempt(attemptId); } ScoreController(final GameService gameService); @GetMapping("/{attemptId}") ScoreCard getScoreForAttempt(
@PathVariable("attemptId") final Long attemptId); }### Answer:
@Test public void getScoreForAttemptTest() throws Exception { ScoreCard scoreCard = new ScoreCard(1L, 5L, 10L, System.currentTimeMillis(), 100); given(gameService.getScoreForAttempt(10L)).willReturn(scoreCard); MockHttpServletResponse response = mvc.perform( get("/scores/10") .accept(MediaType.APPLICATION_JSON)) .andReturn().getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); assertThat(response.getContentAsString()) .isEqualTo(json.write(scoreCard).getJson()); }
|
### Question:
LeaderBoardController { @GetMapping public List<LeaderBoardRow> getLeaderBoard() { return leaderBoardService.getCurrentLeaderBoard(); } LeaderBoardController(final LeaderBoardService leaderBoardService); @GetMapping List<LeaderBoardRow> getLeaderBoard(); }### Answer:
@Test public void getLeaderBoardTest() throws Exception{ LeaderBoardRow leaderBoardRow1 = new LeaderBoardRow(1L, 500L); LeaderBoardRow leaderBoardRow2 = new LeaderBoardRow(2L, 400L); List<LeaderBoardRow> leaderBoard = new ArrayList<>(); Collections.addAll(leaderBoard, leaderBoardRow1, leaderBoardRow2); given(leaderBoardService.getCurrentLeaderBoard()).willReturn(leaderBoard); MockHttpServletResponse response = mvc.perform( get("/leaders") .accept(MediaType.APPLICATION_JSON)) .andReturn().getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); assertThat(response.getContentAsString()) .isEqualTo(json.write(leaderBoard).getJson()); }
|
### Question:
EventHandler { @RabbitListener(queues = "${multiplication.queue}") void handleMultiplicationSolved(final MultiplicationSolvedEvent event) { log.info("Multiplication Solved Event received: {}", event.getMultiplicationResultAttemptId()); try { gameService.newAttemptForUser(event.getUserId(), event.getMultiplicationResultAttemptId(), event.isCorrect()); } catch (final Exception e) { log.error("Error when trying to process MultiplicationSolvedEvent", e); throw new AmqpRejectAndDontRequeueException(e); } } EventHandler(final GameService gameService); }### Answer:
@Test public void multiplicationAttemptReceivedTest() { Long userId = 1L; Long attemptId = 8L; boolean correct = true; GameStats gameStatsExpected = new GameStats(); MultiplicationSolvedEvent event = new MultiplicationSolvedEvent(attemptId, userId, correct); given(gameService.newAttemptForUser(userId, attemptId, correct)).willReturn(gameStatsExpected); eventHandler.handleMultiplicationSolved(event); verify(gameService).newAttemptForUser(userId, attemptId, correct); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public Multiplication createRandomMultiplication() { int factorA = randomGeneratorService.generateRandomFactor(); int factorB = randomGeneratorService.generateRandomFactor(); return new Multiplication(factorA, factorB); } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository,
final EventDispatcher eventDispatcher); @Override Multiplication createRandomMultiplication(); @Transactional @Override MultiplicationResultAttempt checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(final String userAlias); @Override MultiplicationResultAttempt getResultById(final Long resultId); }### Answer:
@Test public void createRandomMultiplicationTest() { given(randomGeneratorService.generateRandomFactor()).willReturn(50, 30); Multiplication multiplication = multiplicationServiceImpl.createRandomMultiplication(); assertThat(multiplication.getFactorA()).isEqualTo(50); assertThat(multiplication.getFactorB()).isEqualTo(30); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Transactional @Override public MultiplicationResultAttempt checkAttempt(final MultiplicationResultAttempt attempt) { Optional<User> user = userRepository.findByAlias(attempt.getUser().getAlias()); Assert.isTrue(!attempt.isCorrect(), "You can't send an attempt marked as correct!!"); boolean isCorrect = attempt.getResultAttempt() == attempt.getMultiplication().getFactorA() * attempt.getMultiplication().getFactorB(); MultiplicationResultAttempt checkedAttempt = new MultiplicationResultAttempt( user.orElse(attempt.getUser()), attempt.getMultiplication(), attempt.getResultAttempt(), isCorrect ); MultiplicationResultAttempt storedAttempt = attemptRepository.save(checkedAttempt); eventDispatcher.send( new MultiplicationSolvedEvent(checkedAttempt.getId(), checkedAttempt.getUser().getId(), checkedAttempt.isCorrect()) ); return storedAttempt; } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository,
final EventDispatcher eventDispatcher); @Override Multiplication createRandomMultiplication(); @Transactional @Override MultiplicationResultAttempt checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(final String userAlias); @Override MultiplicationResultAttempt getResultById(final Long resultId); }### Answer:
@Test public void checkCorrectAttemptTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt( user, multiplication, 3000, false); MultiplicationResultAttempt verifiedAttempt = new MultiplicationResultAttempt( user, multiplication, 3000, true); MultiplicationSolvedEvent event = new MultiplicationSolvedEvent(attempt.getId(), attempt.getUser().getId(), true); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); given(attemptRepository.save(verifiedAttempt)).willReturn(verifiedAttempt); MultiplicationResultAttempt resultAttempt = multiplicationServiceImpl.checkAttempt(attempt); assertThat(resultAttempt.isCorrect()).isTrue(); verify(attemptRepository).save(verifiedAttempt); verify(eventDispatcher).send(eq(event)); }
@Test public void checkWrongAttemptTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt( user, multiplication, 3010, false); MultiplicationResultAttempt storedAttempt = new MultiplicationResultAttempt( user, multiplication, 3010, false); MultiplicationSolvedEvent event = new MultiplicationSolvedEvent(attempt.getId(), attempt.getUser().getId(), false); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); given(attemptRepository.save(attempt)).willReturn(storedAttempt); MultiplicationResultAttempt resultAttempt = multiplicationServiceImpl.checkAttempt(attempt); assertThat(resultAttempt.isCorrect()).isFalse(); verify(attemptRepository).save(attempt); verify(eventDispatcher).send(eq(event)); }
|
### Question:
UserController { @GetMapping("/{userId}") public User getUserById(@PathVariable("userId") final Long userId){ return userRepository.findById(userId) .orElseThrow(() -> new IllegalArgumentException( "The requested userId [" + userId + "] does not exist.")); } UserController(UserRepository userRepository); @GetMapping("/{userId}") User getUserById(@PathVariable("userId") final Long userId); }### Answer:
@Test public void getUserByIdTest() throws Exception { long userId = 1; String userAlias = "john"; given(userRepository.findById(userId)) .willReturn(Optional.of(new User(userId, userAlias))); MockHttpServletResponse response = mvc.perform( get("/users/" + userId) .accept(MediaType.APPLICATION_JSON)) .andReturn().getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); assertThat(response.getContentAsString()) .isEqualTo(json.write(new User(userId, userAlias)).getJson()); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public Multiplication createRandomMultiplication() { int factorA = randomGeneratorService.generateRandomFactor(); int factorB = randomGeneratorService.generateRandomFactor(); return new Multiplication(factorA, factorB); } @Autowired MultiplicationServiceImpl(RandomGeneratorService randomGeneratorService); @Override Multiplication createRandomMultiplication(); }### Answer:
@Test public void createRandomMultiplicationTest() { given(randomGeneratorService.generateRandomFactor()).willReturn(50, 30); Multiplication multiplication = multiplicationServiceImpl.createRandomMultiplication(); assertThat(multiplication.getFactorA()).isEqualTo(50); assertThat(multiplication.getFactorB()).isEqualTo(30); assertThat(multiplication.getResult()).isEqualTo(1500); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public List<MultiplicationResultAttempt> getStatsForUser(final String userAlias) { return attemptRepository.findTop5ByUserAliasOrderByIdDesc(userAlias); } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository,
final EventDispatcher eventDispatcher); @Override Multiplication createRandomMultiplication(); @Transactional @Override MultiplicationResultAttempt checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(final String userAlias); @Override MultiplicationResultAttempt getResultById(final Long resultId); }### Answer:
@Test public void retrieveStatsTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt1 = new MultiplicationResultAttempt( user, multiplication, 3010, false); MultiplicationResultAttempt attempt2 = new MultiplicationResultAttempt( user, multiplication, 3051, false); List<MultiplicationResultAttempt> latestAttempts = Lists.newArrayList(attempt1, attempt2); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); given(attemptRepository.findTop5ByUserAliasOrderByIdDesc("john_doe")) .willReturn(latestAttempts); List<MultiplicationResultAttempt> latestAttemptsResult = multiplicationServiceImpl.getStatsForUser("john_doe"); assertThat(latestAttemptsResult).isEqualTo(latestAttempts); }
|
### Question:
GameServiceImpl implements GameService { @Override public GameStats retrieveStatsForUser(final Long userId) { int score = scoreCardRepository.getTotalScoreForUser(userId); List<BadgeCard> badgeCards = badgeCardRepository .findByUserIdOrderByBadgeTimestampDesc(userId); return new GameStats(userId, score, badgeCards.stream() .map(BadgeCard::getBadge).collect(Collectors.toList())); } GameServiceImpl(ScoreCardRepository scoreCardRepository,
BadgeCardRepository badgeCardRepository,
MultiplicationResultAttemptClient attemptClient); @Override GameStats newAttemptForUser(final Long userId,
final Long attemptId,
final boolean correct); @Override GameStats retrieveStatsForUser(final Long userId); static final int LUCKY_NUMBER; }### Answer:
@Test public void retrieveStatsForUserTest() { Long userId = 1L; int totalScore = 1000; BadgeCard badgeCard = new BadgeCard(userId, Badge.SILVER_MULTIPLICATOR); given(scoreCardRepository.getTotalScoreForUser(userId)) .willReturn(totalScore); given(badgeCardRepository.findByUserIdOrderByBadgeTimestampDesc(userId)) .willReturn(Collections.singletonList(badgeCard)); GameStats stats = gameService.retrieveStatsForUser(userId); assertThat(stats.getScore()).isEqualTo(totalScore); assertThat(stats.getBadges()).containsOnly(Badge.SILVER_MULTIPLICATOR); }
|
### Question:
RandomGeneratorServiceImpl implements RandomGeneratorService { @Override public int generateRandomFactor() { return new Random().nextInt((MAXIMUM_FACTOR - MINIMUM_FACTOR) + 1) + MINIMUM_FACTOR; } @Override int generateRandomFactor(); }### Answer:
@Test public void generateRandomFactorIsBetweenExpectedLimits() throws Exception { List<Integer> randomFactors = IntStream.range(0, 1000) .map(i -> randomGeneratorServiceImpl.generateRandomFactor()) .boxed().collect(Collectors.toList()); assertThat(randomFactors).containsOnlyElementsOf(IntStream.range(11, 100) .boxed().collect(Collectors.toList())); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public Multiplication createRandomMultiplication() { int factorA = randomGeneratorService.generateRandomFactor(); int factorB = randomGeneratorService.generateRandomFactor(); return new Multiplication(factorA, factorB); } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository); @Override Multiplication createRandomMultiplication(); @Transactional @Override boolean checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(String userAlias); }### Answer:
@Test public void createRandomMultiplicationTest() { given(randomGeneratorService.generateRandomFactor()).willReturn(50, 30); Multiplication multiplication = multiplicationServiceImpl.createRandomMultiplication(); assertThat(multiplication.getFactorA()).isEqualTo(50); assertThat(multiplication.getFactorB()).isEqualTo(30); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Transactional @Override public boolean checkAttempt(final MultiplicationResultAttempt attempt) { Optional<User> user = userRepository.findByAlias(attempt.getUser().getAlias()); Assert.isTrue(!attempt.isCorrect(), "You can't send an attempt marked as correct!!"); boolean isCorrect = attempt.getResultAttempt() == attempt.getMultiplication().getFactorA() * attempt.getMultiplication().getFactorB(); MultiplicationResultAttempt checkedAttempt = new MultiplicationResultAttempt( user.orElse(attempt.getUser()), attempt.getMultiplication(), attempt.getResultAttempt(), isCorrect ); attemptRepository.save(checkedAttempt); return isCorrect; } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository); @Override Multiplication createRandomMultiplication(); @Transactional @Override boolean checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(String userAlias); }### Answer:
@Test public void checkCorrectAttemptTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt( user, multiplication, 3000, false); MultiplicationResultAttempt verifiedAttempt = new MultiplicationResultAttempt( user, multiplication, 3000, true); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); boolean attemptResult = multiplicationServiceImpl.checkAttempt(attempt); assertThat(attemptResult).isTrue(); verify(attemptRepository).save(verifiedAttempt); }
@Test public void checkWrongAttemptTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt( user, multiplication, 3010, false); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); boolean attemptResult = multiplicationServiceImpl.checkAttempt(attempt); assertThat(attemptResult).isFalse(); verify(attemptRepository).save(attempt); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public List<MultiplicationResultAttempt> getStatsForUser(String userAlias) { return attemptRepository.findTop5ByUserAliasOrderByIdDesc(userAlias); } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository); @Override Multiplication createRandomMultiplication(); @Transactional @Override boolean checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(String userAlias); }### Answer:
@Test public void retrieveStatsTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt1 = new MultiplicationResultAttempt( user, multiplication, 3010, false); MultiplicationResultAttempt attempt2 = new MultiplicationResultAttempt( user, multiplication, 3051, false); List<MultiplicationResultAttempt> latestAttempts = Lists.newArrayList(attempt1, attempt2); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); given(attemptRepository.findTop5ByUserAliasOrderByIdDesc("john_doe")) .willReturn(latestAttempts); List<MultiplicationResultAttempt> latestAttemptsResult = multiplicationServiceImpl.getStatsForUser("john_doe"); assertThat(latestAttemptsResult).isEqualTo(latestAttempts); }
|
### Question:
MultiplicationController { @GetMapping("/random") Multiplication getRandomMultiplication() { return multiplicationService.createRandomMultiplication(); } @Autowired MultiplicationController(final MultiplicationService multiplicationService); }### Answer:
@Test public void getRandomMultiplicationTest() throws Exception{ given(multiplicationService.createRandomMultiplication()) .willReturn(new Multiplication(70, 20)); MockHttpServletResponse response = mvc.perform( get("/multiplications/random") .accept(MediaType.APPLICATION_JSON)) .andReturn().getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); assertThat(response.getContentAsString()) .isEqualTo(json.write(new Multiplication(70, 20)).getJson()); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public Multiplication createRandomMultiplication() { int factorA = randomGeneratorService.generateRandomFactor(); int factorB = randomGeneratorService.generateRandomFactor(); return new Multiplication(factorA, factorB); } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository,
final EventDispatcher eventDispatcher); @Override Multiplication createRandomMultiplication(); @Transactional @Override boolean checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(final String userAlias); @Override MultiplicationResultAttempt getResultById(final Long resultId); }### Answer:
@Test public void createRandomMultiplicationTest() { given(randomGeneratorService.generateRandomFactor()).willReturn(50, 30); Multiplication multiplication = multiplicationServiceImpl.createRandomMultiplication(); assertThat(multiplication.getFactorA()).isEqualTo(50); assertThat(multiplication.getFactorB()).isEqualTo(30); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Transactional @Override public boolean checkAttempt(final MultiplicationResultAttempt attempt) { Optional<User> user = userRepository.findByAlias(attempt.getUser().getAlias()); Assert.isTrue(!attempt.isCorrect(), "You can't send an attempt marked as correct!!"); boolean isCorrect = attempt.getResultAttempt() == attempt.getMultiplication().getFactorA() * attempt.getMultiplication().getFactorB(); MultiplicationResultAttempt checkedAttempt = new MultiplicationResultAttempt( user.orElse(attempt.getUser()), attempt.getMultiplication(), attempt.getResultAttempt(), isCorrect ); attemptRepository.save(checkedAttempt); eventDispatcher.send( new MultiplicationSolvedEvent(checkedAttempt.getId(), checkedAttempt.getUser().getId(), checkedAttempt.isCorrect()) ); return isCorrect; } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository,
final EventDispatcher eventDispatcher); @Override Multiplication createRandomMultiplication(); @Transactional @Override boolean checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(final String userAlias); @Override MultiplicationResultAttempt getResultById(final Long resultId); }### Answer:
@Test public void checkCorrectAttemptTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt( user, multiplication, 3000, false); MultiplicationResultAttempt verifiedAttempt = new MultiplicationResultAttempt( user, multiplication, 3000, true); MultiplicationSolvedEvent event = new MultiplicationSolvedEvent(attempt.getId(), attempt.getUser().getId(), true); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); boolean attemptResult = multiplicationServiceImpl.checkAttempt(attempt); assertThat(attemptResult).isTrue(); verify(attemptRepository).save(verifiedAttempt); verify(eventDispatcher).send(eq(event)); }
@Test public void checkWrongAttemptTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt( user, multiplication, 3010, false); MultiplicationSolvedEvent event = new MultiplicationSolvedEvent(attempt.getId(), attempt.getUser().getId(), false); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); boolean attemptResult = multiplicationServiceImpl.checkAttempt(attempt); assertThat(attemptResult).isFalse(); verify(attemptRepository).save(attempt); verify(eventDispatcher).send(eq(event)); }
|
### Question:
MultiplicationController { @GetMapping("/random") Multiplication getRandomMultiplication() { log.info("Generating a random multiplication from server @ {}", serverPort); return multiplicationService.createRandomMultiplication(); } @Autowired MultiplicationController(final MultiplicationService multiplicationService, @Value("${server.port}") int serverPort); }### Answer:
@Test public void getRandomMultiplicationTest() throws Exception{ given(multiplicationService.createRandomMultiplication()) .willReturn(new Multiplication(70, 20)); MockHttpServletResponse response = mvc.perform( get("/multiplications/random") .accept(MediaType.APPLICATION_JSON)) .andReturn().getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); assertThat(response.getContentAsString()) .isEqualTo(json.write(new Multiplication(70, 20)).getJson()); }
|
### Question:
MultiplicationServiceImpl implements MultiplicationService { @Override public List<MultiplicationResultAttempt> getStatsForUser(final String userAlias) { return attemptRepository.findTop5ByUserAliasOrderByIdDesc(userAlias); } @Autowired MultiplicationServiceImpl(final RandomGeneratorService randomGeneratorService,
final MultiplicationResultAttemptRepository attemptRepository,
final UserRepository userRepository,
final EventDispatcher eventDispatcher); @Override Multiplication createRandomMultiplication(); @Transactional @Override boolean checkAttempt(final MultiplicationResultAttempt attempt); @Override List<MultiplicationResultAttempt> getStatsForUser(final String userAlias); @Override MultiplicationResultAttempt getResultById(final Long resultId); }### Answer:
@Test public void retrieveStatsTest() { Multiplication multiplication = new Multiplication(50, 60); User user = new User("john_doe"); MultiplicationResultAttempt attempt1 = new MultiplicationResultAttempt( user, multiplication, 3010, false); MultiplicationResultAttempt attempt2 = new MultiplicationResultAttempt( user, multiplication, 3051, false); List<MultiplicationResultAttempt> latestAttempts = Lists.newArrayList(attempt1, attempt2); given(userRepository.findByAlias("john_doe")).willReturn(Optional.empty()); given(attemptRepository.findTop5ByUserAliasOrderByIdDesc("john_doe")) .willReturn(latestAttempts); List<MultiplicationResultAttempt> latestAttemptsResult = multiplicationServiceImpl.getStatsForUser("john_doe"); assertThat(latestAttemptsResult).isEqualTo(latestAttempts); }
|
### Question:
MultiplicationResultAttemptController { @GetMapping("/{resultId}") ResponseEntity<MultiplicationResultAttempt> getResultById(final @PathVariable("resultId") Long resultId) { return ResponseEntity.ok( multiplicationService.getResultById(resultId) ); } @Autowired MultiplicationResultAttemptController(final MultiplicationService multiplicationService); }### Answer:
@Test public void getResultByIdTest() throws Exception { User user = new User("john_doe"); Multiplication multiplication = new Multiplication(50, 70); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt( user, multiplication, 3500, true); given(multiplicationService.getResultById(4L)).willReturn(attempt); MockHttpServletResponse response = mvc.perform( get("/results/4")) .andReturn().getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); assertThat(response.getContentAsString()).isEqualTo( jsonResultAttempt.write(attempt).getJson()); }
|
### Question:
MultiplicationResultAttemptController { @GetMapping("/{resultId}") ResponseEntity<MultiplicationResultAttempt> getResultById(final @PathVariable("resultId") Long resultId) { log.info("Retrieving result {} from server @ {}", resultId, serverPort); return ResponseEntity.ok( multiplicationService.getResultById(resultId) ); } @Autowired MultiplicationResultAttemptController(
final MultiplicationService multiplicationService,
@Value("${server.port}") int serverPort); }### Answer:
@Test public void getResultByIdTest() throws Exception { User user = new User("john_doe"); Multiplication multiplication = new Multiplication(50, 70); MultiplicationResultAttempt attempt = new MultiplicationResultAttempt( user, multiplication, 3500, true); given(multiplicationService.getResultById(4L)).willReturn(attempt); MockHttpServletResponse response = mvc.perform( get("/results/4")) .andReturn().getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); assertThat(response.getContentAsString()).isEqualTo( jsonResultAttempt.write(attempt).getJson()); }
|
### Question:
UserController { @GetMapping("/{userId}") public User getUserById(@PathVariable("userId") final Long userId){ return userRepository.findOne(userId); } UserController(UserRepository userRepository); @GetMapping("/{userId}") User getUserById(@PathVariable("userId") final Long userId); }### Answer:
@Test public void getUserByIdTest() throws Exception { long userId = 1; String userAlias = "john"; given(userRepository.findOne(userId)) .willReturn(new User(userId, userAlias)); MockHttpServletResponse response = mvc.perform( get("/users/" + userId) .accept(MediaType.APPLICATION_JSON)) .andReturn().getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); assertThat(response.getContentAsString()) .isEqualTo(json.write(new User(userId, userAlias)).getJson()); }
|
### Question:
LeaderBoardServiceImpl implements LeaderBoardService { @Override public List<LeaderBoardRow> getCurrentLeaderBoard() { return scoreCardRepository.findFirst10(); } LeaderBoardServiceImpl(ScoreCardRepository scoreCardRepository); @Override List<LeaderBoardRow> getCurrentLeaderBoard(); }### Answer:
@Test public void retrieveLeaderBoardTest() { Long userId = 1L; LeaderBoardRow leaderRow1 = new LeaderBoardRow(userId, 300L); List<LeaderBoardRow> expectedLeaderBoard = Collections.singletonList(leaderRow1); given(scoreCardRepository.findFirst10()).willReturn(expectedLeaderBoard); List<LeaderBoardRow> leaderBoard = leaderBoardService.getCurrentLeaderBoard(); assertThat(leaderBoard).isEqualTo(expectedLeaderBoard); }
|
### Question:
CMOdataHTTPFactory extends BasicAuthHttpClientFactory { @Override public DefaultHttpClient create(final HttpMethod method, final URI uri) { final DefaultHttpClient httpClient = super.create(method, uri); httpClient.getParams().setParameter(CoreProtocolPNames.USER_AGENT, format("SAP CM Client/%s based on %s", VersionHelper.getShortVersion(), USER_AGENT)); httpClient.setCookieStore(this.cookieStore); return httpClient; } CMOdataHTTPFactory(String username, String password); @Override DefaultHttpClient create(final HttpMethod method, final URI uri); }### Answer:
@Test public void testUserAgentStringContainsCMClientHint() throws Exception { HttpClient httpClient = new CMOdataHTTPFactory("me", "*****").create(HttpMethod.GET, new URI("http: assertThat((String)httpClient.getParams().getParameter(CoreProtocolPNames.USER_AGENT), containsString("SAP CM Client")); }
|
### Question:
Commands { private static void printHelp() { String cmd = "<CMD>"; String CRLF = "\r\n"; StringWriter subCommandsHelp = new StringWriter(); commands.stream().map(it -> { CommandDescriptor cDesc = it.getAnnotation(CommandDescriptor.class); return format("%s (%s)", cDesc.name(), cDesc.type());}) .sorted().forEach(subcmd -> subCommandsHelp.append(StringUtils.repeat(' ', 4)) .append(subcmd) .append(CRLF) ); String cmdLineSyntax = format("%s [COMMON_OPTIONS...] <subcommand> [SUBCOMMAND_OPTIONS] <parameters...>", cmd); String header = "Manages communication with the SAP CM System.\r\nCOMMON OPTIONS:"; String footer = format("Subcommands:%s%s%sType '%s <subcommand> --help' for more details.%s", CRLF, subCommandsHelp.toString(), CRLF, cmd, CRLF); new HelpFormatter().printHelp( cmdLineSyntax, header, Helpers.getStandardOptions(), footer); } final static void main(String[] args); }### Answer:
@Test public void testPrintHelp() throws Exception { Commands.main(new String[] {"--help"}); String help = IOUtils.toString(result.toByteArray(), "UTF-8"); assertThat(help, Matchers.containsString("Prints this help.")); }
|
### Question:
AdminServer extends Server { public AdminServer withChannel(String channelName, int nodePort) { if (adminService == null) { adminService = new AdminService(); } adminService.withChannel(channelName, nodePort); return this; } AdminServer withChannel(String channelName, int nodePort); List<String> getChannelNames(); List<Channel> getChannels(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); AdminService createAdminService(); AdminService getAdminService(); }### Answer:
@Test public void whenChannelsLabelsAnnotationsAreTheSame_objectsAreEqual() { server1.withChannel("nap1", 0); server1.addPodLabel("label1", VALUE1); server1.addPodAnnotation("annotation1", VALUE2); server1.withChannel("nap2", 1); server2.withChannel("nap2", 1); server2.withChannel("nap1", 0); server2.addPodAnnotation("annotation1", VALUE2); server2.addPodLabel("label1", VALUE1); assertThat(server1, equalTo(server2)); }
@Test public void whenChannelsDifferByName_objectsAreNotEqual() { server1.withChannel("nap1", 0); server2.withChannel("nap2", 0); assertThat(server1, not(equalTo(server2))); }
|
### Question:
DomainSpec extends BaseConfiguration { public DomainSpec withImage(String image) { setImage(image); return this; } DomainSpec withCluster(Cluster cluster); String getDomainUid(); void setDomainUid(String domainUid); DomainSpec withDomainUid(String domainUid); void setDomainHome(String domainHome); @Nullable @Override String getServerStartPolicy(); @Override void setServerStartPolicy(String serverStartPolicy); DomainSpec withImage(String image); DomainSpec withWebLogicCredentialsSecret(V1SecretReference webLogicCredentialsSecret); DomainSpec withOpssKeyPassPhrase(V1SecretReference opssKeyPassPhrase); String getImage(); void setImage(@Nullable String image); String getImagePullPolicy(); void setImagePullPolicy(@Nullable String imagePullPolicy); @Nullable List<V1LocalObjectReference> getImagePullSecrets(); void setImagePullSecrets(@Nullable List<V1LocalObjectReference> imagePullSecrets); void setImagePullSecret(@Nullable V1LocalObjectReference imagePullSecret); void setLogHome(String logHome); void setLogHomeEnabled(Boolean logHomeEnabled); void setDataHome(String dataHome); DomainSpec withIncludeServerOutInPodLog(boolean includeServerOutInPodLog); void setHttpAccessLogInLogHome(boolean httpAccessLogInLogHome); void setDomainHomeInImage(boolean domainHomeInImage); DomainSpec withDomainHomeInImage(boolean domainHomeInImage); void setDomainHomeSourceType(DomainSourceType domainHomeSourceType); String getIntrospectVersion(); void setIntrospectVersion(String introspectVersion); Configuration getConfiguration(); void setConfiguration(Configuration configuration); Integer getReplicas(); void setReplicas(Integer replicas); DomainSpec withReplicas(Integer replicas); boolean isAllowReplicasBelowMinDynClusterSize(); Integer getMaxClusterConcurrentStartup(); DomainSpec withConfigOverrides(@Nullable String overrides); void setConfigOverrideSecrets(@Nullable List<String> overridesSecretNames); OverrideDistributionStrategy getOverrideDistributionStrategy(); String getOpssWalletFileSecret(); String getWdtConfigMap(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); void setAllowReplicasBelowMinDynClusterSize(Boolean allowReplicasBelowMinDynClusterSize); void setMaxClusterConcurrentStartup(Integer maxClusterConcurrentStartup); AdminServer getAdminServer(); List<ManagedServer> getManagedServers(); List<Cluster> getClusters(); }### Answer:
@Test public void whenEffectiveDomainSpecsWithLatestImage_domainSpecNotEquals() { DomainSpec spec1 = new DomainSpec().withImage(getLatestDefaultImage()); DomainSpec spec2 = new DomainSpec(); assertThat("Expected effective image values to NOT be equal", spec1, not(equalTo(spec2))); }
@Test public void whenEffectiveDomainSpecsWithDefaultImage_domainSpecEquals() { DomainSpec spec1 = new DomainSpec().withImage(KubernetesConstants.DEFAULT_IMAGE); DomainSpec spec2 = new DomainSpec(); assertThat("Expected effective image values to be equal", spec1, equalTo(spec2)); }
|
### Question:
DomainStatusUpdater { static Step createEndProgressingStep(Step next) { return new EndProgressingStep(next); } private DomainStatusUpdater(); static Step createStatusUpdateStep(Step next); static Step createProgressingStep(String reason, boolean isPreserveAvailable, Step next); static Step createProgressingStep(DomainPresenceInfo info, String reason, boolean isPreserveAvailable,
Step next); static Step createAvailableStep(String reason, Step next); static Step createFailedStep(CallResponse<?> callResponse, Step next); static Step createFailedStep(String reason, String message, Step next); static Step createFailedStep(DomainPresenceInfo info, String reason, String message, Step next); static final String INSPECTING_DOMAIN_PROGRESS_REASON; static final String ADMIN_SERVER_STARTING_PROGRESS_REASON; static final String MANAGED_SERVERS_STARTING_PROGRESS_REASON; static final String SERVERS_READY_REASON; static final String ALL_STOPPED_AVAILABLE_REASON; static final String BAD_DOMAIN; static final String ERR_INTROSPECTOR; static final String BAD_TOPOLOGY; }### Answer:
@Test public void whenDomainHasNoConditions_endProgressingStepDoesNothing() { testSupport.runSteps(DomainStatusUpdater.createEndProgressingStep(endStep)); assertThat(testSupport.getNumCalls(), equalTo(0)); }
@Test public void whenDomainHasProgressingTrueCondition_endProgressingStepRemovesIt() { domain.getStatus().addCondition(new DomainCondition(Progressing).withStatus("True")); testSupport.runSteps(DomainStatusUpdater.createEndProgressingStep(endStep)); assertThat(getRecordedDomain(), not(hasCondition(Progressing))); }
@Test public void whenDomainHasProgressingNotTrueCondition_endProgressingStepIgnoresIt() { domain.getStatus().addCondition(new DomainCondition(Progressing).withStatus("?")); testSupport.runSteps(DomainStatusUpdater.createEndProgressingStep(endStep)); assertThat(testSupport.getNumCalls(), equalTo(0)); }
@Test public void whenDomainHasAvailableCondition_endProgressingStepIgnoresIt() { domain.getStatus().addCondition(new DomainCondition(Available)); testSupport.runSteps(DomainStatusUpdater.createEndProgressingStep(endStep)); assertThat(testSupport.getNumCalls(), equalTo(0)); }
@Test public void whenDomainHasFailedCondition_endProgressingStepIgnoresIt() { domain.getStatus().addCondition(new DomainCondition(Failed)); testSupport.runSteps(DomainStatusUpdater.createEndProgressingStep(endStep)); assertThat(testSupport.getNumCalls(), equalTo(0)); }
|
### Question:
ClusterStatus implements Comparable<ClusterStatus>, PatchableComponent<ClusterStatus> { @Override public int compareTo(@Nonnull ClusterStatus o) { return OperatorUtils.compareSortingStrings(clusterName, o.clusterName); } ClusterStatus(); ClusterStatus(ClusterStatus other); String getClusterName(); void setClusterName(String clusterName); ClusterStatus withClusterName(String clusterName); Integer getReplicas(); void setReplicas(Integer replicas); ClusterStatus withReplicas(Integer replicas); ClusterStatus withReadyReplicas(Integer readyReplicas); ClusterStatus withMaximumReplicas(Integer maximumReplicas); ClusterStatus withMinimumReplicas(Integer minimumReplicas); ClusterStatus withReplicasGoal(Integer replicasGoal); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(@Nonnull ClusterStatus o); @Override boolean isPatchableFrom(ClusterStatus other); }### Answer:
@Test public void verifyThat_cluster1_before_cluster2() { assertThat("ClusterStatus for cluster1 should be ordered before ClusterStatus for cluster2", cluster1.compareTo(cluster2), lessThan(0)); assertThat("ClusterStatus for cluster2 should be ordered after ClusterStatus for cluster1", cluster2.compareTo(cluster1), greaterThan(0)); }
@Test public void verifyThat_cluster1_before_cluster10() { assertThat("ClusterStatus for cluster1 should be ordered before ClusterStatus for cluster10", cluster1.compareTo(cluster10), lessThan(0)); assertThat("ClusterStatus for cluster10 should be ordered after ClusterStatus for cluster1", cluster10.compareTo(cluster1), greaterThan(0)); }
@Test public void verifyThat_cluster2_before_cluster10() { assertThat("ClusterStatus for cluster2 should be ordered before ClusterStatus for cluster10", cluster2.compareTo(cluster10), lessThan(0)); assertThat("ClusterStatus for cluster10 should be ordered after ClusterStatus for cluster2", cluster10.compareTo(cluster2), greaterThan(0)); }
@Test public void verifyThat_nullCluster_before_cluster1() { assertThat("ClusterStatus without cluster name should be ordered before ClusterStatus for cluster1", nullCluster.compareTo(cluster1), lessThan(0)); assertThat("ClusterStatus for cluster1 should be ordered after ClusterStatus without cluster name", cluster1.compareTo(nullCluster), greaterThan(0)); }
|
### Question:
DomainStatusUpdater { public static Step createAvailableStep(String reason, Step next) { return new AvailableStep(reason, next); } private DomainStatusUpdater(); static Step createStatusUpdateStep(Step next); static Step createProgressingStep(String reason, boolean isPreserveAvailable, Step next); static Step createProgressingStep(DomainPresenceInfo info, String reason, boolean isPreserveAvailable,
Step next); static Step createAvailableStep(String reason, Step next); static Step createFailedStep(CallResponse<?> callResponse, Step next); static Step createFailedStep(String reason, String message, Step next); static Step createFailedStep(DomainPresenceInfo info, String reason, String message, Step next); static final String INSPECTING_DOMAIN_PROGRESS_REASON; static final String ADMIN_SERVER_STARTING_PROGRESS_REASON; static final String MANAGED_SERVERS_STARTING_PROGRESS_REASON; static final String SERVERS_READY_REASON; static final String ALL_STOPPED_AVAILABLE_REASON; static final String BAD_DOMAIN; static final String ERR_INTROSPECTOR; static final String BAD_TOPOLOGY; }### Answer:
@Test public void whenDomainLacksStatus_availableStepUpdatesDomainWithAvailableTrueAndReason() { domain.setStatus(null); testSupport.runSteps(DomainStatusUpdater.createAvailableStep(reason, endStep)); assertThat(getRecordedDomain(), hasCondition(Available).withStatus("True").withReason(reason)); }
@Test public void whenDomainLacksAvailableCondition_availableStepUpdatesDomainWithAvailableTrueAndReason() { testSupport.runSteps(DomainStatusUpdater.createAvailableStep(reason, endStep)); assertThat(getRecordedDomain(), hasCondition(Available).withStatus("True").withReason(reason)); }
@Test public void whenDomainHasAvailableFalseCondition_availableStepUpdatesItWithTrueAndReason() { domain.getStatus().addCondition(new DomainCondition(Available).withStatus("False")); testSupport.runSteps(DomainStatusUpdater.createAvailableStep(reason, endStep)); assertThat(getRecordedDomain(), hasCondition(Available).withStatus("True").withReason(reason)); assertThat(getRecordedDomain().getStatus().getConditions(), hasSize(1)); }
@Test public void whenDomainHasProgressingCondition_availableStepRemovesIt() { domain.getStatus().addCondition(new DomainCondition(Progressing)); testSupport.runSteps(DomainStatusUpdater.createAvailableStep(reason, endStep)); assertThat(getRecordedDomain(), hasCondition(Available).withStatus("True").withReason(reason)); assertThat(getRecordedDomain(), not(hasCondition(Progressing))); }
@Test public void whenDomainHasFailedCondition_availableStepRemovesIt() { domain.getStatus().addCondition(new DomainCondition(Failed)); testSupport.runSteps(DomainStatusUpdater.createAvailableStep(reason, endStep)); assertThat(getRecordedDomain(), not(hasCondition(Failed))); }
|
### Question:
DomainStatusUpdater { public static Step createFailedStep(CallResponse<?> callResponse, Step next) { FailureStatusSource failure = UnrecoverableErrorBuilder.fromFailedCall(callResponse); LOGGER.severe(MessageKeys.CALL_FAILED, failure.getMessage(), failure.getReason()); ApiException apiException = callResponse.getE(); if (apiException != null) { LOGGER.fine(MessageKeys.EXCEPTION, apiException); } return createFailedStep(failure.getReason(), failure.getMessage(), next); } private DomainStatusUpdater(); static Step createStatusUpdateStep(Step next); static Step createProgressingStep(String reason, boolean isPreserveAvailable, Step next); static Step createProgressingStep(DomainPresenceInfo info, String reason, boolean isPreserveAvailable,
Step next); static Step createAvailableStep(String reason, Step next); static Step createFailedStep(CallResponse<?> callResponse, Step next); static Step createFailedStep(String reason, String message, Step next); static Step createFailedStep(DomainPresenceInfo info, String reason, String message, Step next); static final String INSPECTING_DOMAIN_PROGRESS_REASON; static final String ADMIN_SERVER_STARTING_PROGRESS_REASON; static final String MANAGED_SERVERS_STARTING_PROGRESS_REASON; static final String SERVERS_READY_REASON; static final String ALL_STOPPED_AVAILABLE_REASON; static final String BAD_DOMAIN; static final String ERR_INTROSPECTOR; static final String BAD_TOPOLOGY; }### Answer:
@Test public void whenDomainLacksStatus_failedStepUpdatesDomainWithFailedTrueAndException() { domain.setStatus(null); testSupport.runSteps(DomainStatusUpdater.createFailedStep(failure, endStep)); assertThat( getRecordedDomain(), hasCondition(Failed).withStatus("True").withReason("Exception").withMessage(message)); }
@Test public void whenDomainLacksFailedCondition_failedStepUpdatesDomainWithFailedTrueAndException() { testSupport.runSteps(DomainStatusUpdater.createFailedStep(failure, endStep)); assertThat( getRecordedDomain(), hasCondition(Failed).withStatus("True").withReason("Exception").withMessage(message)); }
@Test public void whenDomainHasFailedFalseCondition_failedStepUpdatesItWithTrueAndException() { domain.getStatus().addCondition(new DomainCondition(Failed).withStatus("False")); testSupport.runSteps(DomainStatusUpdater.createFailedStep(failure, endStep)); assertThat( getRecordedDomain(), hasCondition(Failed).withStatus("True").withReason("Exception").withMessage(message)); assertThat(getRecordedDomain().getStatus().getConditions(), hasSize(1)); }
@Test public void whenDomainHasProgressingTrueCondition_failedStepRemovesIt() { domain.getStatus().addCondition(new DomainCondition(Progressing).withStatus("True")); testSupport.runSteps(DomainStatusUpdater.createFailedStep(failure, endStep)); assertThat(getRecordedDomain(), not(hasCondition(Progressing))); }
@Test public void failedStepWithFailureMessage_doesNotContainValidationWarnings() { info.addValidationWarning(validationWarning); testSupport.addToPacket(DOMAIN_TOPOLOGY, configSupport.createDomainConfig()); testSupport.runSteps(DomainStatusUpdater.createFailedStep(failure, endStep)); assertThat(getRecordedDomain().getStatus().getMessage(), not(containsString(validationWarning))); }
|
### Question:
LoggingFacade { public void info(String msg) { if (isInfoEnabled()) { CallerDetails details = inferCaller(); logger.logp(Level.INFO, details.clazz, details.method, msg); } } LoggingFacade(Logger logger); static Object convertArraysForLogging(Object value, boolean password); void config(String msg); void config(String msg, Object... params); void config(String msg, Throwable thrown); void entering(); void entering(Object... params); void exiting(); void exiting(Object result); void fine(String msg); void fine(String msg, Object... params); void fine(String msg, Throwable thrown); void finer(String msg); void finer(String msg, Object... params); void finer(String msg, Throwable thrown); void finest(String msg); void finest(String msg, Object... params); void finest(String msg, Throwable thrown); Level getLevel(); void setLevel(Level newLevel); String getName(); Logger getUnderlyingLogger(); void info(String msg); void info(String msg, Object... params); void info(LoggingFilter loggingFilter, String msg, Object... params); void info(String msg, Throwable thrown); boolean isConfigEnabled(); boolean isFineEnabled(); boolean isFinerEnabled(); boolean isFinestEnabled(); boolean isInfoEnabled(); boolean isLoggable(Level level); boolean isSevereEnabled(); boolean isWarningEnabled(); void log(Level level, String msg); void log(Level level, String msg, Object... params); void log(Level level, String msg, Throwable thrown); void severe(String msg); void severe(String msg, Object... params); void severe(LoggingFilter loggingFilter, String msg, Object... params); void severe(String msg, Throwable thrown); void severe(LoggingFilter loggingFilter, String msg, Throwable thrown); void throwing(Throwable pending); void warning(String msg); void warning(String msg, Object... params); void warning(LoggingFilter loggingFilter, String msg, Object... params); void warning(String msg, Throwable thrown); void trace(String msg); void trace(String msg, Object... args); ResourceBundle getResourceBundle(); String formatMessage(String msgId, Object... params); static final String TRACE; }### Answer:
@Test public void verifyInfoMessageLoggedIfLoggingFilterIsNull() { loggingFacade.info((LoggingFilter) null, "msg"); assertThat(mockLogger.isLogpCalled(), is(true)); }
@Test public void verifyInfoMessageLoggedIfLoggingFilterAllows() { final String message = "info message"; loggingFacade.info(MockLoggingFilter.createWithReturnValue(true), message); assertThat(mockLogger.isLogpCalled(), is(true)); assertThat(mockLogger.getMessageLevel(), is(Level.INFO)); assertThat(mockLogger.getMessage(), is(message)); }
@Test public void verifyInfoMessageNotLoggedIfLoggingFilterDenies() { loggingFacade.info(MockLoggingFilter.createWithReturnValue(false), "msg"); assertThat(mockLogger.isLogpCalled(), is(false)); }
|
### Question:
LoggingFacade { public void warning(String msg) { if (isWarningEnabled()) { CallerDetails details = inferCaller(); logger.logp(Level.WARNING, details.clazz, details.method, msg); } } LoggingFacade(Logger logger); static Object convertArraysForLogging(Object value, boolean password); void config(String msg); void config(String msg, Object... params); void config(String msg, Throwable thrown); void entering(); void entering(Object... params); void exiting(); void exiting(Object result); void fine(String msg); void fine(String msg, Object... params); void fine(String msg, Throwable thrown); void finer(String msg); void finer(String msg, Object... params); void finer(String msg, Throwable thrown); void finest(String msg); void finest(String msg, Object... params); void finest(String msg, Throwable thrown); Level getLevel(); void setLevel(Level newLevel); String getName(); Logger getUnderlyingLogger(); void info(String msg); void info(String msg, Object... params); void info(LoggingFilter loggingFilter, String msg, Object... params); void info(String msg, Throwable thrown); boolean isConfigEnabled(); boolean isFineEnabled(); boolean isFinerEnabled(); boolean isFinestEnabled(); boolean isInfoEnabled(); boolean isLoggable(Level level); boolean isSevereEnabled(); boolean isWarningEnabled(); void log(Level level, String msg); void log(Level level, String msg, Object... params); void log(Level level, String msg, Throwable thrown); void severe(String msg); void severe(String msg, Object... params); void severe(LoggingFilter loggingFilter, String msg, Object... params); void severe(String msg, Throwable thrown); void severe(LoggingFilter loggingFilter, String msg, Throwable thrown); void throwing(Throwable pending); void warning(String msg); void warning(String msg, Object... params); void warning(LoggingFilter loggingFilter, String msg, Object... params); void warning(String msg, Throwable thrown); void trace(String msg); void trace(String msg, Object... args); ResourceBundle getResourceBundle(); String formatMessage(String msgId, Object... params); static final String TRACE; }### Answer:
@Test public void verifyWarningMessageLoggedIfLoggingFilterIsNull() { loggingFacade.warning((LoggingFilter) null, "msg"); assertThat(mockLogger.isLogpCalled(), is(true)); }
@Test public void verifyWarningMessageLoggedIfLoggingFilterAllows() { final String message = "warning message"; loggingFacade.warning(MockLoggingFilter.createWithReturnValue(true), message); assertThat(mockLogger.isLogpCalled(), is(true)); assertThat(mockLogger.getMessageLevel(), is(Level.WARNING)); assertThat(mockLogger.getMessage(), is(message)); }
@Test public void verifyWarningMessageNotLoggedIfLoggingFilterDenies() { loggingFacade.warning(MockLoggingFilter.createWithReturnValue(false), "msg"); assertThat(mockLogger.isLogpCalled(), is(false)); }
|
### Question:
LoggingFacade { public void severe(String msg) { if (isSevereEnabled()) { CallerDetails details = inferCaller(); logger.logp(Level.SEVERE, details.clazz, details.method, msg); } } LoggingFacade(Logger logger); static Object convertArraysForLogging(Object value, boolean password); void config(String msg); void config(String msg, Object... params); void config(String msg, Throwable thrown); void entering(); void entering(Object... params); void exiting(); void exiting(Object result); void fine(String msg); void fine(String msg, Object... params); void fine(String msg, Throwable thrown); void finer(String msg); void finer(String msg, Object... params); void finer(String msg, Throwable thrown); void finest(String msg); void finest(String msg, Object... params); void finest(String msg, Throwable thrown); Level getLevel(); void setLevel(Level newLevel); String getName(); Logger getUnderlyingLogger(); void info(String msg); void info(String msg, Object... params); void info(LoggingFilter loggingFilter, String msg, Object... params); void info(String msg, Throwable thrown); boolean isConfigEnabled(); boolean isFineEnabled(); boolean isFinerEnabled(); boolean isFinestEnabled(); boolean isInfoEnabled(); boolean isLoggable(Level level); boolean isSevereEnabled(); boolean isWarningEnabled(); void log(Level level, String msg); void log(Level level, String msg, Object... params); void log(Level level, String msg, Throwable thrown); void severe(String msg); void severe(String msg, Object... params); void severe(LoggingFilter loggingFilter, String msg, Object... params); void severe(String msg, Throwable thrown); void severe(LoggingFilter loggingFilter, String msg, Throwable thrown); void throwing(Throwable pending); void warning(String msg); void warning(String msg, Object... params); void warning(LoggingFilter loggingFilter, String msg, Object... params); void warning(String msg, Throwable thrown); void trace(String msg); void trace(String msg, Object... args); ResourceBundle getResourceBundle(); String formatMessage(String msgId, Object... params); static final String TRACE; }### Answer:
@Test public void verifySevereMessageLoggedIfLoggingFilterIsNull() { loggingFacade.severe((LoggingFilter) null, "msg"); assertThat(mockLogger.isLogpCalled(), is(true)); }
@Test public void verifySevereMessageLoggedIfLoggingFilterAllows() { final String message = "severe message"; loggingFacade.severe(MockLoggingFilter.createWithReturnValue(true), message); assertThat(mockLogger.isLogpCalled(), is(true)); assertThat(mockLogger.getMessageLevel(), is(Level.SEVERE)); assertThat(mockLogger.getMessage(), is(message)); }
@Test public void verifySevereMessageNotLoggedIfLoggingFilterDenies() { loggingFacade.severe(MockLoggingFilter.createWithReturnValue(false), "msg"); assertThat(mockLogger.isLogpCalled(), is(false)); }
@Test public void verifySevereMessageWithThrowableLoggedIfLoggingFilterIsNull() { loggingFacade.severe((LoggingFilter) null, "msg", new Throwable()); assertThat(mockLogger.isLogpCalled(), is(true)); }
@Test public void verifySevereMessageWithThrowableLoggedIfLoggingFilterAllows() { final String message = "severe message"; final Throwable throwable = new Throwable("throwable"); loggingFacade.severe(MockLoggingFilter.createWithReturnValue(true), message, throwable); assertThat(mockLogger.isLogpCalled(), is(true)); assertThat(mockLogger.getMessageLevel(), is(Level.SEVERE)); assertThat(mockLogger.getMessage(), is(message)); assertThat(mockLogger.getMessageThrowable(), is(throwable)); }
@Test public void verifySevereMessageWithThrowableNotLoggedIfLoggingFilterDenies() { loggingFacade.severe(MockLoggingFilter.createWithReturnValue(false), "msg", new Throwable()); assertThat(mockLogger.isLogpCalled(), is(false)); }
|
### Question:
LoggingFacade { public String formatMessage(String msgId, Object... params) { if (params == null || params.length == 0) { return getResourceBundle().getString(msgId); } String msg = getResourceBundle().getString(msgId); MessageFormat formatter = new MessageFormat(msg); return formatter.format(params); } LoggingFacade(Logger logger); static Object convertArraysForLogging(Object value, boolean password); void config(String msg); void config(String msg, Object... params); void config(String msg, Throwable thrown); void entering(); void entering(Object... params); void exiting(); void exiting(Object result); void fine(String msg); void fine(String msg, Object... params); void fine(String msg, Throwable thrown); void finer(String msg); void finer(String msg, Object... params); void finer(String msg, Throwable thrown); void finest(String msg); void finest(String msg, Object... params); void finest(String msg, Throwable thrown); Level getLevel(); void setLevel(Level newLevel); String getName(); Logger getUnderlyingLogger(); void info(String msg); void info(String msg, Object... params); void info(LoggingFilter loggingFilter, String msg, Object... params); void info(String msg, Throwable thrown); boolean isConfigEnabled(); boolean isFineEnabled(); boolean isFinerEnabled(); boolean isFinestEnabled(); boolean isInfoEnabled(); boolean isLoggable(Level level); boolean isSevereEnabled(); boolean isWarningEnabled(); void log(Level level, String msg); void log(Level level, String msg, Object... params); void log(Level level, String msg, Throwable thrown); void severe(String msg); void severe(String msg, Object... params); void severe(LoggingFilter loggingFilter, String msg, Object... params); void severe(String msg, Throwable thrown); void severe(LoggingFilter loggingFilter, String msg, Throwable thrown); void throwing(Throwable pending); void warning(String msg); void warning(String msg, Object... params); void warning(LoggingFilter loggingFilter, String msg, Object... params); void warning(String msg, Throwable thrown); void trace(String msg); void trace(String msg, Object... args); ResourceBundle getResourceBundle(); String formatMessage(String msgId, Object... params); static final String TRACE; }### Answer:
@Test public void verifyGetFormattedMessage_withArgs_returnsFormattedMessage() { assertThat(loggingFacade.formatMessage(MessageKeys.CYCLING_SERVERS, "domain1", "list1"), is("Cycling of servers for Domain with UID domain1 in the list list1 now")); }
@Test public void verifyGetFormattedMessage_withNoArgs_returnsFormattedMessage() { assertThat(loggingFacade.formatMessage(MessageKeys.RESOURCE_BUNDLE_NOT_FOUND), is("Could not find the resource bundle")); }
|
### Question:
OncePerMessageLoggingFilter implements LoggingFilter { @Override public synchronized boolean canLog(String msg) { if (filtering && messagesLogged.contains(msg)) { return false; } messagesLogged.add(msg); return true; } synchronized OncePerMessageLoggingFilter setFiltering(boolean value); synchronized OncePerMessageLoggingFilter resetLogHistory(); @Override synchronized boolean canLog(String msg); }### Answer:
@Test public void verifyCanLogReturnsTrueForRepeatedMessageWithoutFiltering() { final String message = "some log message"; OncePerMessageLoggingFilter loggingFilter = new OncePerMessageLoggingFilter(); assertThat(loggingFilter.canLog(message), is(true)); assertThat(loggingFilter.canLog(message), is(true)); }
|
### Question:
SemanticVersion implements Comparable<SemanticVersion> { @Override public int compareTo(@NotNull SemanticVersion o) { if (o == null) { return 1; } int majorDiff = this.major - o.major; if (majorDiff != 0) { return majorDiff; } int minorDiff = this.minor - o.minor; if (minorDiff != 0) { return minorDiff; } return this.revision - o.revision; } SemanticVersion(int major, int minor); SemanticVersion(int major, int minor, int revision); SemanticVersion(String fullVersion); int getMajor(); int getMinor(); int getRevision(); Compatibility getCompatibilityWith(String minimumVersion); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int compareTo(@NotNull SemanticVersion o); }### Answer:
@Test public void whenVersionsSame_compareReportsZero() { SemanticVersion first = new SemanticVersion("5.6.7"); SemanticVersion second = new SemanticVersion("5.6.7"); assertThat(first.compareTo(second), equalTo(0)); }
@Test public void whenVersionsSameWithDefaultRevisionZero_compareReportsZero() { SemanticVersion first = new SemanticVersion("5.6"); SemanticVersion second = new SemanticVersion("5.6.0"); assertThat(first.compareTo(second), equalTo(0)); }
@Test public void whenMajorVersionIsLower_compareReportsLower() { SemanticVersion first = new SemanticVersion("5.6.7"); SemanticVersion second = new SemanticVersion("10.3.4"); assertThat(first.compareTo(second), lessThan(0)); }
@Test public void whenMajorVersionIsGreater_compareReportsGreater() { SemanticVersion first = new SemanticVersion("5.6.7"); SemanticVersion second = new SemanticVersion("2.8.9"); assertThat(first.compareTo(second), greaterThan(0)); }
@Test public void whenMinorVersionIsLower_compareReportsLower() { SemanticVersion first = new SemanticVersion("5.6.7"); SemanticVersion second = new SemanticVersion("5.7.2"); assertThat(first.compareTo(second), lessThan(0)); }
@Test public void whenMinorVersionIsGreater_compareReportsGreater() { SemanticVersion first = new SemanticVersion("5.6.7"); SemanticVersion second = new SemanticVersion("5.5.9"); assertThat(first.compareTo(second), greaterThan(0)); }
@Test public void whenRevisionVersionIsLower_compareReportsLower() { SemanticVersion first = new SemanticVersion("5.6.7"); SemanticVersion second = new SemanticVersion("5.6.8"); assertThat(first.compareTo(second), lessThan(0)); }
@Test public void whenRevisionVersionIsGreater_compareReportsGreater() { SemanticVersion first = new SemanticVersion("5.6.7"); SemanticVersion second = new SemanticVersion("5.6.6"); assertThat(first.compareTo(second), greaterThan(0)); }
|
### Question:
Cluster extends BaseConfiguration implements Comparable<Cluster> { public void setClusterName(@Nonnull String clusterName) { this.clusterName = clusterName; } String getClusterName(); void setClusterName(@Nonnull String clusterName); Integer getReplicas(); void setReplicas(Integer replicas); Boolean isAllowReplicasBelowMinDynClusterSize(); void setAllowReplicasBelowMinDynClusterSize(Boolean value); Integer getMaxConcurrentStartup(); void setMaxConcurrentStartup(Integer value); @Nullable @Override String getServerStartPolicy(); @Override void setServerStartPolicy(String serverStartPolicy); KubernetesResource getClusterService(); void setClusterService(KubernetesResource clusterService); Map<String, String> getClusterLabels(); Map<String, String> getClusterAnnotations(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(@Nonnull Cluster o); }### Answer:
@Test public void whenNamesAreTheSame_objectsAreEqual() { cluster1.setClusterName("one"); cluster2.setClusterName("one"); assertThat(cluster1, equalTo(cluster2)); }
@Test public void whenNamesDiffer_objectsAreNotEqual() { cluster1.setClusterName("one"); cluster2.setClusterName("two"); assertThat(cluster1, not(equalTo(cluster2))); }
|
### Question:
JobHelper { static boolean creatingServers(DomainPresenceInfo info) { Domain dom = info.getDomain(); DomainSpec spec = dom.getSpec(); List<Cluster> clusters = spec.getClusters(); List<ManagedServer> servers = spec.getManagedServers(); for (Cluster cluster : clusters) { int replicaCount = dom.getReplicaCount(cluster.getClusterName()); String clusterServerStartPolicy = cluster.getServerStartPolicy(); LOGGER.fine( "Start Policy: " + clusterServerStartPolicy + ", replicaCount: " + replicaCount + " for cluster: " + cluster); if ((clusterServerStartPolicy == null || !clusterServerStartPolicy.equals(ConfigurationConstants.START_NEVER)) && replicaCount > 0) { return true; } } String domainServerStartPolicy = dom.getSpec().getServerStartPolicy(); if (domainServerStartPolicy == null || !domainServerStartPolicy.equals(ConfigurationConstants.START_NEVER)) { return true; } for (ManagedServer server : servers) { String serverStartPolicy = server.getServerStartPolicy(); if (serverStartPolicy == null || !serverStartPolicy.equals(ConfigurationConstants.START_NEVER)) { return true; } } return false; } private JobHelper(); static Step createDomainIntrospectorJobStep(Step next); static Step deleteDomainIntrospectorJobStep(Step next); }### Answer:
@Test public void creatingServers_true_whenClusterReplicas_gt_0() { configureCluster("cluster1").withReplicas(1); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(true)); }
@Test public void creatingServers_false_whenClusterReplicas_is_0() { configureCluster("cluster1").withReplicas(0); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(false)); }
@Test public void creatingServers_true_whenDomainReplicas_gt_0_and_cluster_has_no_replicas() { configureDomain().withDefaultReplicaCount(1); configureCluster("cluster1"); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(true)); }
@Test public void creatingServers_false_whenDomainReplicas_is_0_and_cluster_has_no_replicas() { configureDomain().withDefaultReplicaCount(0); configureCluster("cluster1"); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(false)); }
@Test public void creatingServers_false_when_no_domain_nor_cluster_replicas() { configureCluster("cluster1"); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(false)); }
@Test public void creatingServers_false_when_noCluster_and_Start_Never_startPolicy() { assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(false)); }
@Test public void creatingServers_true_when_noCluster_and_Start_If_Needed_startPolicy() { configureDomain() .withDefaultServerStartPolicy(ConfigurationConstants.START_IF_NEEDED); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(true)); }
@Test public void creatingServers_true_when_noCluster_and_Start_Always_startPolicy() { configureDomain() .withDefaultServerStartPolicy(ConfigurationConstants.START_ALWAYS); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(true)); }
@Test public void creatingServers_false_when_server_with_Start_Never_startPolicy() { configureServer("managed-server1") .withServerStartPolicy(ConfigurationConstants.START_NEVER); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(false)); }
@Test public void creatingServers_true_when_server_with_Start_If_Needed_startPolicy() { configureServer("managed-server1") .withServerStartPolicy(ConfigurationConstants.START_IF_NEEDED); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(true)); }
@Test public void creatingServers_true_when_server_with_Start_Always_startPolicy() { configureServer("managed-server1") .withServerStartPolicy(ConfigurationConstants.START_ALWAYS); assertThat(JobHelper.creatingServers(domainPresenceInfo), equalTo(true)); }
|
### Question:
Cluster extends BaseConfiguration implements Comparable<Cluster> { public void setReplicas(Integer replicas) { this.replicas = replicas; } String getClusterName(); void setClusterName(@Nonnull String clusterName); Integer getReplicas(); void setReplicas(Integer replicas); Boolean isAllowReplicasBelowMinDynClusterSize(); void setAllowReplicasBelowMinDynClusterSize(Boolean value); Integer getMaxConcurrentStartup(); void setMaxConcurrentStartup(Integer value); @Nullable @Override String getServerStartPolicy(); @Override void setServerStartPolicy(String serverStartPolicy); KubernetesResource getClusterService(); void setClusterService(KubernetesResource clusterService); Map<String, String> getClusterLabels(); Map<String, String> getClusterAnnotations(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(@Nonnull Cluster o); }### Answer:
@Test public void whenReplicasAreTheSame_objectsAreEqual() { cluster1.setReplicas(3); cluster2.setReplicas(3); assertThat(cluster1, equalTo(cluster2)); }
@Test public void whenReplicasDiffer_objectsAreNotEqual() { cluster1.setReplicas(3); assertThat(cluster1, not(equalTo(cluster2))); }
|
### Question:
JobHelper { static String createJobName(String domainUid) { return LegalNames.toJobIntrospectorName(domainUid); } private JobHelper(); static Step createDomainIntrospectorJobStep(Step next); static Step deleteDomainIntrospectorJobStep(Step next); }### Answer:
@Test public void introspectorPodContainerSpec_hasJobNameAsContainerName() { V1JobSpec jobSpec = createJobSpec(); assertThat( getMatchingContainer(domainPresenceInfo, jobSpec).map(V1Container::getName).orElse(null), is(JobHelper.createJobName(UID))); }
|
### Question:
FileGroupReader { Map<String, String> loadFilesFromClasspath() { synchronized (FileGroupReader.class) { try { try (ScriptPath scriptPath = getScriptPath()) { return loadContents(scriptPath.getScriptsDir()); } } catch (Exception e) { LOGGER.warning(MessageKeys.EXCEPTION, e); throw new RuntimeException(e); } } } FileGroupReader(String pathToGroup); }### Answer:
@Test public void afterLoadScriptsFromClasspath_haveScriptNamesAsKeys() { Map<String, String> scripts = scriptReader.loadFilesFromClasspath(); assertThat(scripts.keySet(), containsInAnyOrder(SCRIPT_NAMES)); }
|
### Question:
FileGroupReader { static Map<String, String> loadContents(Path rootDir) throws IOException { try (Stream<Path> walk = Files.walk(rootDir, 1)) { return walk.filter(path -> !Files.isDirectory(path)) .collect(Collectors.toMap(FileGroupReader::asString, FileGroupReader::readContents)); } } FileGroupReader(String pathToGroup); }### Answer:
@Test public void loadFilesFromMemory() throws IOException { fileSystem.defineFile("group/a.b", "1234"); fileSystem.defineFile("group/x/c.d", "5678"); Path p = fileSystem.getPath("group"); Map<String, String> map = FileGroupReader.loadContents(p); assertThat(map, hasEntry("group/a.b", "1234")); assertThat(map, hasEntry("group/x/c.d", "5678")); }
|
### Question:
ResourceVersion implements Comparable<ResourceVersion> { public Integer getVersion() { return version; } ResourceVersion(String value); boolean isWellFormed(); boolean isGA(); boolean isAlpha(); boolean isBeta(); String getPrefix(); Integer getVersion(); String getPrerelease(); Integer getPrereleaseVersion(); @Override int compareTo(ResourceVersion o); String toString(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void whenParsed_verifyVersions() { ResourceVersion rv; rv = new ResourceVersion("v1"); assertThat(rv.getVersion(), equalTo(1)); rv = new ResourceVersion("v27"); assertThat(rv.getVersion(), equalTo(27)); rv = new ResourceVersion("v100alpha42"); assertThat(rv.getVersion(), equalTo(100)); }
@Test public void whenNotWellFormedButLegalParsed_verifyVersions() { ResourceVersion rv; rv = new ResourceVersion("token20"); assertThat(rv.getVersion(), equalTo(20)); rv = new ResourceVersion("r100"); assertThat(rv.getVersion(), equalTo(100)); rv = new ResourceVersion("prefix3"); assertThat(rv.getVersion(), equalTo(3)); }
|
### Question:
ResourceVersion implements Comparable<ResourceVersion> { public boolean isWellFormed() { return "v".equals(prefix) && version != null; } ResourceVersion(String value); boolean isWellFormed(); boolean isGA(); boolean isAlpha(); boolean isBeta(); String getPrefix(); Integer getVersion(); String getPrerelease(); Integer getPrereleaseVersion(); @Override int compareTo(ResourceVersion o); String toString(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void whenParsed_verifyWellFormed() { ResourceVersion rv; rv = new ResourceVersion("v1"); assert (rv.isWellFormed()); rv = new ResourceVersion("v27"); assert (rv.isWellFormed()); rv = new ResourceVersion("v100alpha42"); assert (rv.isWellFormed()); rv = new ResourceVersion("token20"); assert (!rv.isWellFormed()); rv = new ResourceVersion("r100"); assert (!rv.isWellFormed()); rv = new ResourceVersion("prefix3"); assert (!rv.isWellFormed()); }
|
### Question:
ResourceVersion implements Comparable<ResourceVersion> { public String getPrefix() { return prefix; } ResourceVersion(String value); boolean isWellFormed(); boolean isGA(); boolean isAlpha(); boolean isBeta(); String getPrefix(); Integer getVersion(); String getPrerelease(); Integer getPrereleaseVersion(); @Override int compareTo(ResourceVersion o); String toString(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void whenParsed_verifyPrefix() { ResourceVersion rv; rv = new ResourceVersion("v1"); assertThat(rv.getPrefix(), equalTo("v")); rv = new ResourceVersion("token20"); assertThat(rv.getPrefix(), equalTo("token")); rv = new ResourceVersion("r100"); assertThat(rv.getPrefix(), equalTo("r")); rv = new ResourceVersion("prefix3"); assertThat(rv.getPrefix(), equalTo("prefix")); }
|
### Question:
ResourceVersion implements Comparable<ResourceVersion> { public String getPrerelease() { return prerelease; } ResourceVersion(String value); boolean isWellFormed(); boolean isGA(); boolean isAlpha(); boolean isBeta(); String getPrefix(); Integer getVersion(); String getPrerelease(); Integer getPrereleaseVersion(); @Override int compareTo(ResourceVersion o); String toString(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void whenParsed_verifyPrerelease() { ResourceVersion rv; rv = new ResourceVersion("v1"); assertNull(rv.getPrerelease()); rv = new ResourceVersion("v100alpha42"); assertThat(rv.getPrerelease(), equalTo("alpha")); }
|
### Question:
ResourceVersion implements Comparable<ResourceVersion> { public Integer getPrereleaseVersion() { return prereleaseVersion; } ResourceVersion(String value); boolean isWellFormed(); boolean isGA(); boolean isAlpha(); boolean isBeta(); String getPrefix(); Integer getVersion(); String getPrerelease(); Integer getPrereleaseVersion(); @Override int compareTo(ResourceVersion o); String toString(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void whenParsed_verifyPrereleaseVersion() { ResourceVersion rv; rv = new ResourceVersion("v1"); assertNull(rv.getPrereleaseVersion()); rv = new ResourceVersion("v100alpha42"); assertThat(rv.getPrereleaseVersion(), equalTo(42)); }
|
### Question:
ResourceVersion implements Comparable<ResourceVersion> { public String toString() { return value; } ResourceVersion(String value); boolean isWellFormed(); boolean isGA(); boolean isAlpha(); boolean isBeta(); String getPrefix(); Integer getVersion(); String getPrerelease(); Integer getPrereleaseVersion(); @Override int compareTo(ResourceVersion o); String toString(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void whenMultipleValues_sort() { List<String> values = Arrays.asList( "v11beta2", "foo1", "v3beta2", "v2", "v1", "v3beta1", "v11alpha2", "v10beta3", "v10", "foo10", "v12alpha1"); List<ResourceVersion> rvs = values.stream().map(e -> new ResourceVersion(e)).collect(Collectors.toList()); Collections.sort(rvs); List<String> actual = rvs.stream().map(e -> e.toString()).collect(Collectors.toList()); List<String> expected = Arrays.asList( "foo10", "foo1", "v11alpha2", "v12alpha1", "v3beta1", "v3beta2", "v10beta3", "v11beta2", "v1", "v2", "v10"); assertEquals(expected, actual); }
|
### Question:
ClientPool extends Pool<ApiClient> { public static ClientPool getInstance() { return SINGLETON; } static void initialize(ThreadFactory threadFactory); static ClientPool getInstance(); }### Answer:
@Test public void onTake_returnApiClient() { assertThat(ClientPool.getInstance().take(), instanceOf(ApiClient.class)); }
@Test public void afterRecycle_takeReturnsSameClient() { ApiClient apiClient = ClientPool.getInstance().take(); ClientPool.getInstance().recycle(apiClient); assertThat(ClientPool.getInstance().take(), sameInstance(apiClient)); }
|
### Question:
LegalNames { public static String toServerServiceName(String domainUid, String serverName) { return toServerName(domainUid, serverName); } static String toServerServiceName(String domainUid, String serverName); static String toEventName(String domainUid, String serverName); static String toPodName(String domainUid, String serverName); static String toClusterServiceName(String domainUid, String clusterName); static String toJobIntrospectorName(String domainUid); static String toExternalServiceName(String domainUid, String serverName); static String toDns1123LegalName(String value); static boolean isDns1123Required(String fieldName); static final String DOMAIN_INTROSPECTOR_JOB_SUFFIX; static final String DNS_1123_FIELDS_PARAM; }### Answer:
@Test public void createValidServerServiceNames() throws Exception { assertThat(toServerServiceName("abc", "cls1"), equalTo("abc-cls1")); assertThat(toServerServiceName("Abc", "cLs1"), equalTo("abc-cls1")); assertThat(toServerServiceName("Abc", "cls_1"), equalTo("abc-cls-1")); }
|
### Question:
LegalNames { public static String toClusterServiceName(String domainUid, String clusterName) { return toDns1123LegalName(String.format(CLUSTER_SERVICE_PATTERN, domainUid, clusterName)); } static String toServerServiceName(String domainUid, String serverName); static String toEventName(String domainUid, String serverName); static String toPodName(String domainUid, String serverName); static String toClusterServiceName(String domainUid, String clusterName); static String toJobIntrospectorName(String domainUid); static String toExternalServiceName(String domainUid, String serverName); static String toDns1123LegalName(String value); static boolean isDns1123Required(String fieldName); static final String DOMAIN_INTROSPECTOR_JOB_SUFFIX; static final String DNS_1123_FIELDS_PARAM; }### Answer:
@Test public void createValidClusterServiceNames() throws Exception { assertThat(toClusterServiceName("abc", "cls1"), equalTo("abc-cluster-cls1")); assertThat(toClusterServiceName("Abc", "cLs1"), equalTo("abc-cluster-cls1")); assertThat(toClusterServiceName("Abc", "cls_1"), equalTo("abc-cluster-cls-1")); }
|
### Question:
PodHelper { public static Step deletePodStep(String serverName, Step next) { return new DeletePodStep(serverName, next); } private PodHelper(); static V1Pod createAdminServerPodModel(Packet packet); static V1Pod createManagedServerPodModel(Packet packet); static boolean isReady(V1Pod pod); static List<String> getScheduledPods(DomainPresenceInfo info, String clusterName); static List<String> getReadyPods(DomainPresenceInfo info, String clusterName); static boolean getScheduledStatus(V1Pod pod); static boolean getReadyStatus(V1Pod pod); static boolean isDeleting(V1Pod pod); static boolean isFailed(V1Pod pod); static String getPodDomainUid(V1Pod pod); static String getPodServerName(V1Pod pod); static Step createAdminPodStep(Step next); static Step createManagedPodStep(Step next); static Step deletePodStep(String serverName, Step next); }### Answer:
@Test public void afterDeletePodStepRun_markedForDeleteInSko() { testSupport.defineResources(pod); domainPresenceInfo.setServerPod(SERVER_NAME, pod); testSupport.runSteps(PodHelper.deletePodStep(SERVER_NAME, terminalStep)); MatcherAssert.assertThat( domainPresenceInfo.isServerPodBeingDeleted(SERVER_NAME), is(Boolean.TRUE)); }
@Test public void whenDeleteFails_reportCompletionFailure() { testSupport.failOnResource(POD, POD_NAME, NS, HTTP_BAD_REQUEST); domainPresenceInfo.setServerPod(SERVER_NAME, pod); testSupport.runSteps(PodHelper.deletePodStep(SERVER_NAME, terminalStep)); testSupport.verifyCompletionThrowable(FailureStatusSourceException.class); }
@Test public void whenDeletePodStepRunWithNoPod_doNotSendDeleteCall() { testSupport.runSteps(PodHelper.deletePodStep(SERVER_NAME, terminalStep)); MatcherAssert.assertThat(domainPresenceInfo.getServerPod(SERVER_NAME), nullValue()); }
@Test public void afterDeletePodStepRun_runSpecifiedNextStep() { testSupport.runSteps(PodHelper.deletePodStep(SERVER_NAME, terminalStep)); MatcherAssert.assertThat(terminalStep.wasRun(), is(true)); }
|
### Question:
KubernetesUtils { public static boolean isFirstNewer(V1ObjectMeta first, V1ObjectMeta second) { if (second == null) { return true; } if (first == null) { return false; } DateTime time1 = first.getCreationTimestamp(); DateTime time2 = second.getCreationTimestamp(); if (time1.equals(time2)) { return getResourceVersion(first).compareTo(getResourceVersion(second)) > 0; } else { return time1.isAfter(time2); } } static boolean isFirstNewer(V1ObjectMeta first, V1ObjectMeta second); static BigInteger getResourceVersion(V1ObjectMeta metadata); static BigInteger getResourceVersion(String resVersion); static V1ObjectMeta withOperatorLabels(String uid, V1ObjectMeta meta); }### Answer:
@Test public void whenCreationTimesDiffer_metadataWithLaterTimeIsNewer() { V1ObjectMeta meta1 = new V1ObjectMeta().creationTimestamp(new DateTime(2)).resourceVersion("2"); V1ObjectMeta meta2 = new V1ObjectMeta().creationTimestamp(new DateTime(1)).resourceVersion("1"); assertThat(KubernetesUtils.isFirstNewer(meta1, meta2), is(true)); assertThat(KubernetesUtils.isFirstNewer(meta2, meta1), is(false)); }
@Test public void whenCreationTimesMatch_metadataWithHigherResourceVersionIsNewer() { V1ObjectMeta meta1 = new V1ObjectMeta().creationTimestamp(new DateTime(1)).resourceVersion("2"); V1ObjectMeta meta2 = new V1ObjectMeta().creationTimestamp(new DateTime(1)).resourceVersion("1"); assertThat(KubernetesUtils.isFirstNewer(meta1, meta2), is(true)); assertThat(KubernetesUtils.isFirstNewer(meta2, meta1), is(false)); }
@Test public void whenCreationTimesAndResourceVersionsMatch_neitherIsNewer() { V1ObjectMeta meta1 = new V1ObjectMeta().creationTimestamp(new DateTime(1)).resourceVersion("2"); V1ObjectMeta meta2 = new V1ObjectMeta().creationTimestamp(new DateTime(1)).resourceVersion("2"); assertThat(KubernetesUtils.isFirstNewer(meta2, meta1), is(false)); assertThat(KubernetesUtils.isFirstNewer(meta1, meta2), is(false)); }
@Test public void whenHaveLargeResourceVersionsAndSameTime_succeedIsFirstNewer() { DateTime now = DateTime.now(); String resVersion = "2733280673"; String evenBiggerResVersion = "2733280673000"; V1ObjectMeta first = new V1ObjectMeta().creationTimestamp(now).resourceVersion(resVersion); V1ObjectMeta second = new V1ObjectMeta().creationTimestamp(now).resourceVersion(evenBiggerResVersion); assertThat(KubernetesUtils.isFirstNewer(first, second), is(false)); }
@Test public void whenHaveNonParsableResourceVersionsAndSameTime_succeedIsFirstNewer() { DateTime now = DateTime.now(); String resVersion = "ThisIsNotANumber"; String differentResVersion = "SomeOtherValueAlsoNotANumber"; V1ObjectMeta first = new V1ObjectMeta().creationTimestamp(now).resourceVersion(resVersion); V1ObjectMeta second = new V1ObjectMeta().creationTimestamp(now).resourceVersion(differentResVersion); assertThat(KubernetesUtils.isFirstNewer(first, second), is(false)); }
|
### Question:
KubernetesUtils { public static BigInteger getResourceVersion(V1ObjectMeta metadata) { return getResourceVersion(Optional.ofNullable(metadata).map(V1ObjectMeta::getResourceVersion).orElse(null)); } static boolean isFirstNewer(V1ObjectMeta first, V1ObjectMeta second); static BigInteger getResourceVersion(V1ObjectMeta metadata); static BigInteger getResourceVersion(String resVersion); static V1ObjectMeta withOperatorLabels(String uid, V1ObjectMeta meta); }### Answer:
@Test public void whenHaveSmallResourceVersion_parseCorrectly() { String resVersion = "1"; BigInteger bigInteger = KubernetesUtils.getResourceVersion(resVersion); assertThat(bigInteger, is(BigInteger.ONE)); }
@Test public void whenHaveNullResourceVersion_parseCorrectly() { BigInteger bigInteger = KubernetesUtils.getResourceVersion((String) null); assertThat(bigInteger, is(BigInteger.ZERO)); }
@Test public void whenHaveOpaqueResourceVersion_parseCorrectly() { String resVersion = "123NotANumber456"; BigInteger bigInteger = KubernetesUtils.getResourceVersion(resVersion); assertThat(bigInteger, is(BigInteger.ZERO)); }
|
### Question:
ConfigMapHelper { public static Step createScriptConfigMapStep(String operatorNamespace, String domainNamespace) { return new ScriptConfigMapStep(operatorNamespace, domainNamespace); } private ConfigMapHelper(); static Step createScriptConfigMapStep(String operatorNamespace, String domainNamespace); static int getModelInImageSpecHash(String imageName); static String getIntrospectorConfigMapName(String domainUid); static Step createIntrospectorConfigMapStep(Step next); static Step reportTopologyErrorsAndStop(); static Step deleteIntrospectorConfigMapStep(String domainUid, String namespace, Step next); static Step readExistingIntrospectorConfigMap(String ns, String domainUid); static Step readIntrospectionVersionStep(String ns, String domainUid); }### Answer:
@Test public void whenUnableToReadConfigMap_reportFailure() { testSupport.failOnResource(CONFIG_MAP, SCRIPT_CONFIG_MAP_NAME, DOMAIN_NS, 401); Step scriptConfigMapStep = ConfigMapHelper.createScriptConfigMapStep(OPERATOR_NS, DOMAIN_NS); testSupport.runSteps(scriptConfigMapStep); testSupport.verifyCompletionThrowable(FailureStatusSourceException.class); }
@Test public void whenNoConfigMap_createIt() { testSupport.runSteps(ConfigMapHelper.createScriptConfigMapStep(OPERATOR_NS, DOMAIN_NS)); assertThat(testSupport.getResources(CONFIG_MAP), notNullValue()); assertThat(logRecords, containsInfo(CM_CREATED)); }
@Test public void whenNoConfigMap_retryOnFailure() { testSupport.addRetryStrategy(retryStrategy); testSupport.failOnCreate(CONFIG_MAP, SCRIPT_CONFIG_MAP_NAME, DOMAIN_NS, 401); Step scriptConfigMapStep = ConfigMapHelper.createScriptConfigMapStep(OPERATOR_NS, DOMAIN_NS); testSupport.runSteps(scriptConfigMapStep); testSupport.verifyCompletionThrowable(FailureStatusSourceException.class); assertThat(retryStrategy.getConflictStep(), sameInstance(scriptConfigMapStep)); }
@Test public void whenMatchingConfigMapExists_addToPacket() { testSupport.defineResources(defaultConfigMap); Packet packet = testSupport.runSteps(ConfigMapHelper.createScriptConfigMapStep(OPERATOR_NS, DOMAIN_NS)); assertThat(logRecords, containsFine(CM_EXISTS)); assertThat(packet, hasEntry(SCRIPT_CONFIG_MAP, defaultConfigMap)); }
@Test public void whenExistingConfigMapIsMissingData_replaceIt() { testSupport.defineResources(defineConfigMap(PARTIAL_SCRIPT_NAMES)); testSupport.runSteps(ConfigMapHelper.createScriptConfigMapStep(OPERATOR_NS, DOMAIN_NS)); assertThat(logRecords, containsInfo(CM_REPLACED)); assertThat(getScriptConfigKeys(), containsInAnyOrder(COMBINED_SCRIPT_NAMES)); }
@Test public void whenExistingConfigMapHasExtraData_dontRemoveIt() { testSupport.defineResources(defineConfigMap(PARTIAL_SCRIPT_NAMES)); testSupport.runSteps(ConfigMapHelper.createScriptConfigMapStep(OPERATOR_NS, DOMAIN_NS)); assertThat(logRecords, containsInfo(CM_REPLACED)); assertThat(getScriptConfigKeys(), hasItem(ADDITIONAL_NAME)); }
|
### Question:
DomainPresenceInfo { public V1Service getClusterService(String clusterName) { return clusters.get(clusterName); } DomainPresenceInfo(Domain domain); DomainPresenceInfo(String namespace, String domainUid); void setServerService(String serverName, V1Service service); V1Service getServerService(String serverName); V1Service removeServerService(String serverName); static Optional<DomainPresenceInfo> fromPacket(Packet packet); void setServerPod(String serverName, V1Pod pod); V1Pod getServerPod(String serverName); Stream<V1Pod> getServerPods(); Boolean isServerPodBeingDeleted(String serverName); void setServerPodBeingDeleted(String serverName, Boolean isBeingDeleted); Collection<String> getServerNames(); void setServerPodFromEvent(String serverName, V1Pod event); boolean deleteServerPodFromEvent(String serverName, V1Pod event); LastKnownStatus getLastKnownServerStatus(String serverName); void updateLastKnownServerStatus(String serverName, String status); V1Service getClusterService(String clusterName); V1Service getExternalService(String serverName); boolean isNotDeleting(); void setDeleting(boolean deleting); boolean isPopulated(); void setPopulated(boolean populated); int incrementAndGetFailureCount(); void complete(); Domain getDomain(); void setDomain(Domain domain); String getDomainUid(); String getNamespace(); ConcurrentMap<String, ServerKubernetesObjects> getServers(); Collection<ServerStartupInfo> getServerStartupInfo(); void setServerStartupInfo(Collection<ServerStartupInfo> serverStartupInfo); @Override String toString(); void addValidationWarning(String validationWarning); void clearValidationWarnings(); String getValidationWarningsAsString(); }### Answer:
@Test public void whenNoneDefined_getClusterServiceReturnsNull() { assertThat(info.getClusterService("cluster"), nullValue()); }
|
### Question:
DomainPresenceInfo { public V1Service getServerService(String serverName) { return getSko(serverName).getService().get(); } DomainPresenceInfo(Domain domain); DomainPresenceInfo(String namespace, String domainUid); void setServerService(String serverName, V1Service service); V1Service getServerService(String serverName); V1Service removeServerService(String serverName); static Optional<DomainPresenceInfo> fromPacket(Packet packet); void setServerPod(String serverName, V1Pod pod); V1Pod getServerPod(String serverName); Stream<V1Pod> getServerPods(); Boolean isServerPodBeingDeleted(String serverName); void setServerPodBeingDeleted(String serverName, Boolean isBeingDeleted); Collection<String> getServerNames(); void setServerPodFromEvent(String serverName, V1Pod event); boolean deleteServerPodFromEvent(String serverName, V1Pod event); LastKnownStatus getLastKnownServerStatus(String serverName); void updateLastKnownServerStatus(String serverName, String status); V1Service getClusterService(String clusterName); V1Service getExternalService(String serverName); boolean isNotDeleting(); void setDeleting(boolean deleting); boolean isPopulated(); void setPopulated(boolean populated); int incrementAndGetFailureCount(); void complete(); Domain getDomain(); void setDomain(Domain domain); String getDomainUid(); String getNamespace(); ConcurrentMap<String, ServerKubernetesObjects> getServers(); Collection<ServerStartupInfo> getServerStartupInfo(); void setServerStartupInfo(Collection<ServerStartupInfo> serverStartupInfo); @Override String toString(); void addValidationWarning(String validationWarning); void clearValidationWarnings(); String getValidationWarningsAsString(); }### Answer:
@Test public void whenNoneDefined_getServerServiceReturnsNull() { assertThat(info.getServerService("admin"), nullValue()); }
|
### Question:
DomainPresenceInfo { public V1Service getExternalService(String serverName) { return getSko(serverName).getExternalService().get(); } DomainPresenceInfo(Domain domain); DomainPresenceInfo(String namespace, String domainUid); void setServerService(String serverName, V1Service service); V1Service getServerService(String serverName); V1Service removeServerService(String serverName); static Optional<DomainPresenceInfo> fromPacket(Packet packet); void setServerPod(String serverName, V1Pod pod); V1Pod getServerPod(String serverName); Stream<V1Pod> getServerPods(); Boolean isServerPodBeingDeleted(String serverName); void setServerPodBeingDeleted(String serverName, Boolean isBeingDeleted); Collection<String> getServerNames(); void setServerPodFromEvent(String serverName, V1Pod event); boolean deleteServerPodFromEvent(String serverName, V1Pod event); LastKnownStatus getLastKnownServerStatus(String serverName); void updateLastKnownServerStatus(String serverName, String status); V1Service getClusterService(String clusterName); V1Service getExternalService(String serverName); boolean isNotDeleting(); void setDeleting(boolean deleting); boolean isPopulated(); void setPopulated(boolean populated); int incrementAndGetFailureCount(); void complete(); Domain getDomain(); void setDomain(Domain domain); String getDomainUid(); String getNamespace(); ConcurrentMap<String, ServerKubernetesObjects> getServers(); Collection<ServerStartupInfo> getServerStartupInfo(); void setServerStartupInfo(Collection<ServerStartupInfo> serverStartupInfo); @Override String toString(); void addValidationWarning(String validationWarning); void clearValidationWarnings(); String getValidationWarningsAsString(); }### Answer:
@Test public void whenNoneDefined_getExternalServiceReturnsNull() { assertThat(info.getExternalService("admin"), nullValue()); }
|
### Question:
DomainPresenceInfo { public V1Pod getServerPod(String serverName) { return getPod(getSko(serverName)); } DomainPresenceInfo(Domain domain); DomainPresenceInfo(String namespace, String domainUid); void setServerService(String serverName, V1Service service); V1Service getServerService(String serverName); V1Service removeServerService(String serverName); static Optional<DomainPresenceInfo> fromPacket(Packet packet); void setServerPod(String serverName, V1Pod pod); V1Pod getServerPod(String serverName); Stream<V1Pod> getServerPods(); Boolean isServerPodBeingDeleted(String serverName); void setServerPodBeingDeleted(String serverName, Boolean isBeingDeleted); Collection<String> getServerNames(); void setServerPodFromEvent(String serverName, V1Pod event); boolean deleteServerPodFromEvent(String serverName, V1Pod event); LastKnownStatus getLastKnownServerStatus(String serverName); void updateLastKnownServerStatus(String serverName, String status); V1Service getClusterService(String clusterName); V1Service getExternalService(String serverName); boolean isNotDeleting(); void setDeleting(boolean deleting); boolean isPopulated(); void setPopulated(boolean populated); int incrementAndGetFailureCount(); void complete(); Domain getDomain(); void setDomain(Domain domain); String getDomainUid(); String getNamespace(); ConcurrentMap<String, ServerKubernetesObjects> getServers(); Collection<ServerStartupInfo> getServerStartupInfo(); void setServerStartupInfo(Collection<ServerStartupInfo> serverStartupInfo); @Override String toString(); void addValidationWarning(String validationWarning); void clearValidationWarnings(); String getValidationWarningsAsString(); }### Answer:
@Test public void whenNoneDefined_getServerPodReturnsNull() { assertThat(info.getServerPod("myserver"), nullValue()); }
|
### Question:
RollingHelper { public static Step rollServers(Map<String, StepAndPacket> rolling, Step next) { return new RollingStep(rolling, next); } private RollingHelper(); static Step rollServers(Map<String, StepAndPacket> rolling, Step next); }### Answer:
@Test public void verifyThatManagedServerPodsAreReplacedInOrder() { initializeExistingPods(); testSupport.addToPacket(SERVERS_TO_ROLL, rolling); SERVER_NAMES.forEach(s -> rolling.put(s, createRollingStepAndPacket(s))); testSupport.runSteps(RollingHelper.rollServers(rolling, terminalStep)); assertThat(logRecords, containsInOrder( containsInfo(MANAGED_POD_REPLACED, SERVER1_NAME), containsInfo(MANAGED_POD_REPLACED, SERVER2_NAME), containsInfo(MANAGED_POD_REPLACED, SERVER10_NAME) )); }
@Test public void verifyThatWhenRollingIsEmpty_NoManagedServerPodsAreReplaced() { initializeExistingPods(); testSupport.addToPacket(SERVERS_TO_ROLL, rolling); testSupport.runSteps(RollingHelper.rollServers(rolling, terminalStep)); assertThat(logRecords, empty()); }
|
### Question:
DomainTopology { public static DomainTopology parseDomainTopologyYaml(String topologyYaml, Consumer<List<String>> errorReporter) { final DomainTopology domainTopology = parseDomainTopologyYaml(topologyYaml); if (domainTopology == null || domainTopology.getDomainValid()) { return domainTopology; } else { errorReporter.accept(domainTopology.validationErrors); return null; } } @SuppressWarnings("unused") // Used by parser DomainTopology(); DomainTopology(WlsDomainConfig domain); static DomainTopology parseDomainTopologyYaml(String topologyYaml, Consumer<List<String>> errorReporter); static DomainTopology parseDomainTopologyYaml(String topologyYaml); boolean getDomainValid(); @SuppressWarnings("unused") // used by parser void setDomainValid(boolean domainValid); @SuppressWarnings("unused") // used by parser void setValidationErrors(List<String> validationErrors); WlsDomainConfig getDomain(); void setDomain(WlsDomainConfig domain); List<String> getValidationErrors(); String toString(); }### Answer:
@Test public void parseDomainTopologyYaml() { DomainTopology domainTopology = DomainTopology.parseDomainTopologyYaml(DOMAIN_TOPOLOGY); assertNotNull(domainTopology); assertTrue(domainTopology.getDomainValid()); WlsDomainConfig wlsDomainConfig = domainTopology.getDomain(); assertNotNull(wlsDomainConfig); assertEquals("base_domain", wlsDomainConfig.getName()); assertEquals("admin-server", wlsDomainConfig.getAdminServerName()); Map<String, WlsClusterConfig> wlsClusterConfigs = wlsDomainConfig.getClusterConfigs(); assertEquals(1, wlsClusterConfigs.size()); WlsClusterConfig wlsClusterConfig = wlsClusterConfigs.get("cluster-1"); assertNotNull(wlsClusterConfig); List<WlsServerConfig> wlsServerConfigs = wlsClusterConfig.getServers(); assertEquals(2, wlsServerConfigs.size()); Map<String, WlsServerConfig> serverConfigMap = wlsDomainConfig.getServerConfigs(); assertEquals(3, serverConfigMap.size()); assertTrue(serverConfigMap.containsKey("admin-server")); assertTrue(serverConfigMap.containsKey("server1")); assertTrue(serverConfigMap.containsKey("server2")); WlsServerConfig adminServerConfig = serverConfigMap.get("admin-server"); assertEquals(7099, adminServerConfig.getAdminPort().intValue()); assertTrue(adminServerConfig.isAdminPortEnabled()); WlsServerConfig server2Config = serverConfigMap.get("server2"); assertEquals("domain1-managed-server2", server2Config.getListenAddress()); assertEquals(9004, server2Config.getListenPort().intValue()); assertEquals(8004, server2Config.getSslListenPort().intValue()); assertTrue(server2Config.isSslPortEnabled()); List<NetworkAccessPoint> server2ConfigNaps = server2Config.getNetworkAccessPoints(); assertEquals(1, server2ConfigNaps.size()); NetworkAccessPoint server2ConfigNap = server2ConfigNaps.get(0); assertEquals("nap2", server2ConfigNap.getName()); assertEquals("t3", server2ConfigNap.getProtocol()); assertEquals(8005, server2ConfigNap.getListenPort().intValue()); assertEquals(8005, server2ConfigNap.getPublicPort().intValue()); }
|
### Question:
HealthCheckHelper { public static V1SubjectRulesReviewStatus performSecurityChecks( KubernetesVersion version, String operatorNamespace, String namespace) { String ns = namespace != null ? namespace : operatorNamespace; if (DEFAULT_NAMESPACE.equals(operatorNamespace)) { LOGGER.fine(MessageKeys.NAMESPACE_IS_DEFAULT); } AuthorizationProxy ap = new AuthorizationProxy(); LOGGER.fine(MessageKeys.VERIFY_ACCESS_START, ns); V1SelfSubjectRulesReview review = ap.review(ns); if (review != null) { V1SubjectRulesReviewStatus status = review.getStatus(); List<V1ResourceRule> rules = status.getResourceRules(); if (namespace != null) { for (Resource r : namespaceAccessChecks.keySet()) { for (Operation op : namespaceAccessChecks.get(r)) { check(rules, r, op, namespace); } } } if (!Main.isDedicated() && operatorNamespace.equals(ns)) { for (Resource r : clusterAccessChecks.keySet()) { for (Operation op : clusterAccessChecks.get(r)) { check(rules, r, op, ns); } } } return status; } return null; } private HealthCheckHelper(); static V1SubjectRulesReviewStatus performSecurityChecks(
KubernetesVersion version, String operatorNamespace, String namespace); static boolean check(
List<V1ResourceRule> rules, Resource res, Operation op); static KubernetesVersion performK8sVersionCheck(); }### Answer:
@Test public void whenRulesReviewSupported_accessGrantedForEverything() { expectSelfSubjectRulesReview(); for (String ns : TARGET_NAMESPACES) { HealthCheckHelper.performSecurityChecks(RULES_REVIEW_VERSION, OPERATOR_NAMESPACE, ns); } }
@Test public void whenRulesReviewSupportedAndNoNamespaceAccess_logWarning() { accessChecks.setMayAccessNamespace(false); expectSelfSubjectRulesReview(); for (String ns : TARGET_NAMESPACES) { HealthCheckHelper.performSecurityChecks(RULES_REVIEW_VERSION, OPERATOR_NAMESPACE, ns); } assertThat(logRecords, containsWarning(VERIFY_ACCESS_DENIED_WITH_NS)); }
|
### Question:
ServerStatusReader { static Step createDomainStatusReaderStep( DomainPresenceInfo info, long timeoutSeconds, Step next) { return new DomainStatusReaderStep(info, timeoutSeconds, next); } private ServerStatusReader(); }### Answer:
@Test public void whenNoServersPresent_packetContainsEmptyStateAndHealthMaps() { Packet packet = testSupport.runSteps(ServerStatusReader.createDomainStatusReaderStep(info, 0, endStep)); assertThat((Map<?, ?>) packet.get(SERVER_STATE_MAP), Matchers.anEmptyMap()); assertThat((Map<?, ?>) packet.get(SERVER_HEALTH_MAP), Matchers.anEmptyMap()); }
@Test public void whenServersLackPods_packetContainsEmptyStateAndHealthMaps() { Packet packet = testSupport.runSteps(ServerStatusReader.createDomainStatusReaderStep(info, 0, endStep)); assertThat((Map<?, ?>) packet.get(SERVER_STATE_MAP), Matchers.anEmptyMap()); assertThat((Map<?, ?>) packet.get(SERVER_HEALTH_MAP), Matchers.anEmptyMap()); }
@Test public void whenServerPodsReturnNodeManagerStatus_recordInStateMap() { info.setServerPod("server1", createPod("server1")); info.setServerPod("server2", createPod("server2")); execFactory.defineResponse("server1", "server1 status"); execFactory.defineResponse("server2", "server2 status"); Packet packet = testSupport.runSteps(ServerStatusReader.createDomainStatusReaderStep(info, 0, endStep)); Map<String, String> serverStates = getServerStates(packet); assertThat(serverStates, hasEntry("server1", "server1 status")); assertThat(serverStates, hasEntry("server2", "server2 status")); }
@Test public void createDomainStatusReaderStep_initializesRemainingServersHealthRead_withNumServers() { info.setServerPod("server1", createPod("server1")); info.setServerPod("server2", createPod("server2")); Packet packet = testSupport.runSteps(ServerStatusReader.createDomainStatusReaderStep(info, 0, endStep)); assertThat( ((AtomicInteger) packet.get(ProcessingConstants.REMAINING_SERVERS_HEALTH_TO_READ)).get(), is(2)); }
@Test public void whenPodNotReadyAndHasLastKnownState_recordInStateMap() { info.setServerPod("server1", createPod("server1")); info.updateLastKnownServerStatus("server1", "not ready yet"); execFactory.defineResponse("server1", "still not ready yet"); Packet packet = testSupport.runSteps(ServerStatusReader.createDomainStatusReaderStep(info, 0, endStep)); Map<String, String> serverStates = getServerStates(packet); assertThat(serverStates, hasEntry("server1", "still not ready yet")); }
@Test public void whenPodIsReady_startHealthStepForIt() { info.setServerPod("server1", createPod("server1")); setReadyStatus(info.getServerPod("server1")); execFactory.defineResponse("server1", "RUNNING"); testSupport.runSteps(ServerStatusReader.createDomainStatusReaderStep(info, 0, endStep)); assertThat(stepFactory.serverNames, contains("server1")); }
|
### Question:
JobWatcher extends Watcher<V1Job> implements WatchListener<V1Job> { public static boolean isComplete(V1Job job) { if (job == null) { return false; } V1JobStatus status = job.getStatus(); LOGGER.fine( "JobWatcher.isComplete status of job " + job.getMetadata().getName() + ": " + status); if (status != null) { List<V1JobCondition> conds = status.getConditions(); if (conds != null) { for (V1JobCondition cond : conds) { if ("Complete".equals(cond.getType())) { if ("True".equals(cond.getStatus())) { LOGGER.info(MessageKeys.JOB_IS_COMPLETE, job.getMetadata().getName(), status); return true; } } } } } return false; } private JobWatcher(
String namespace,
String initialResourceVersion,
WatchTuning tuning,
AtomicBoolean isStopping); static @Nonnull JobWatcher getOrCreateFor(Domain domain); @Override String getNamespace(); static JobWatcher create(
ThreadFactory factory,
String ns,
String initialResourceVersion,
WatchTuning tuning,
AtomicBoolean isStopping); static boolean isComplete(V1Job job); @Override WatchI<V1Job> initiateWatch(WatchBuilder watchBuilder); void receivedResponse(Watch.Response<V1Job> item); Step waitForReady(V1Job job, Step next); }### Answer:
@Test public void whenJobHasNoStatus_reportNotComplete() { assertThat(JobWatcher.isComplete(cachedJob), is(false)); }
@Test public void whenJobHasNoCondition_reportNotComplete() { cachedJob.status(new V1JobStatus()); assertThat(JobWatcher.isComplete(cachedJob), is(false)); }
@Test public void whenJobConditionTypeFailed_reportNotComplete() { cachedJob.status(new V1JobStatus().addConditionsItem(new V1JobCondition().type("Failed"))); assertThat(JobWatcher.isComplete(cachedJob), is(false)); }
@Test public void whenJobConditionStatusFalse_reportNotComplete() { cachedJob.status( new V1JobStatus().addConditionsItem(new V1JobCondition().type("Complete").status("False"))); assertThat(JobWatcher.isComplete(cachedJob), is(false)); }
@Test public void whenJobRunningAndReadyConditionIsTrue_reportComplete() { markJobCompleted(cachedJob); assertThat(JobWatcher.isComplete(cachedJob), is(true)); }
|
### Question:
JobWatcher extends Watcher<V1Job> implements WatchListener<V1Job> { static boolean isFailed(V1Job job) { if (job == null) { return false; } V1JobStatus status = job.getStatus(); if (status != null) { if (status.getFailed() != null && status.getFailed() > 0) { LOGGER.severe(MessageKeys.JOB_IS_FAILED, job.getMetadata().getName()); return true; } } return false; } private JobWatcher(
String namespace,
String initialResourceVersion,
WatchTuning tuning,
AtomicBoolean isStopping); static @Nonnull JobWatcher getOrCreateFor(Domain domain); @Override String getNamespace(); static JobWatcher create(
ThreadFactory factory,
String ns,
String initialResourceVersion,
WatchTuning tuning,
AtomicBoolean isStopping); static boolean isComplete(V1Job job); @Override WatchI<V1Job> initiateWatch(WatchBuilder watchBuilder); void receivedResponse(Watch.Response<V1Job> item); Step waitForReady(V1Job job, Step next); }### Answer:
@Test public void whenJobHasNoStatus_reportNotFailed() { assertThat(JobWatcher.isFailed(cachedJob), is(false)); }
@Test public void whenJobHasFailedCount_reportFailed() { cachedJob.status(new V1JobStatus().failed(1)); assertThat(JobWatcher.isFailed(cachedJob), is(true)); }
|
### Question:
JobWatcher extends Watcher<V1Job> implements WatchListener<V1Job> { static String getFailedReason(V1Job job) { V1JobStatus status = job.getStatus(); if (status != null && status.getConditions() != null) { for (V1JobCondition cond : status.getConditions()) { if ("Failed".equals(cond.getType()) && "True".equals(cond.getStatus())) { return cond.getReason(); } } } return null; } private JobWatcher(
String namespace,
String initialResourceVersion,
WatchTuning tuning,
AtomicBoolean isStopping); static @Nonnull JobWatcher getOrCreateFor(Domain domain); @Override String getNamespace(); static JobWatcher create(
ThreadFactory factory,
String ns,
String initialResourceVersion,
WatchTuning tuning,
AtomicBoolean isStopping); static boolean isComplete(V1Job job); @Override WatchI<V1Job> initiateWatch(WatchBuilder watchBuilder); void receivedResponse(Watch.Response<V1Job> item); Step waitForReady(V1Job job, Step next); }### Answer:
@Test public void whenJobHasFailedReason_getFailedReasonReturnsIt() { setFailedWithReason(cachedJob, "AReason"); assertThat(JobWatcher.getFailedReason(cachedJob), is("AReason")); }
@Test public void whenJobHasNoFailedReason_getFailedReasonReturnsNull() { setFailedWithReason(cachedJob, null); assertThat(JobWatcher.getFailedReason(cachedJob), nullValue()); }
@Test public void whenJobHasNoFailedCondition_getFailedReasonReturnsNull() { cachedJob.status(new V1JobStatus().addConditionsItem(createCondition("Complete"))); assertThat(JobWatcher.getFailedReason(cachedJob), nullValue()); }
@Test public void whenJobHasNoJobCondition_getFailedReasonReturnsNull() { cachedJob.status(new V1JobStatus().conditions(Collections.emptyList())); assertThat(JobWatcher.getFailedReason(cachedJob), nullValue()); }
|
### Question:
JobWatcher extends Watcher<V1Job> implements WatchListener<V1Job> { public Step waitForReady(V1Job job, Step next) { return new WaitForJobReadyStep(job, next); } private JobWatcher(
String namespace,
String initialResourceVersion,
WatchTuning tuning,
AtomicBoolean isStopping); static @Nonnull JobWatcher getOrCreateFor(Domain domain); @Override String getNamespace(); static JobWatcher create(
ThreadFactory factory,
String ns,
String initialResourceVersion,
WatchTuning tuning,
AtomicBoolean isStopping); static boolean isComplete(V1Job job); @Override WatchI<V1Job> initiateWatch(WatchBuilder watchBuilder); void receivedResponse(Watch.Response<V1Job> item); Step waitForReady(V1Job job, Step next); }### Answer:
@Test public void waitForReady_returnsAStep() { JobWatcher watcher = createWatcher(new AtomicBoolean(true)); assertThat(watcher.waitForReady(cachedJob, null), instanceOf(Step.class)); }
|
### Question:
WlsDomainConfig implements WlsDomain { public String getName() { return name; } WlsDomainConfig(); WlsDomainConfig(String name); WlsDomainConfig(
String name,
String adminServerName,
Map<String, WlsClusterConfig> wlsClusterConfigs,
Map<String, WlsServerConfig> wlsServerConfigs,
Map<String, WlsServerConfig> wlsServerTemplates,
Map<String, WlsMachineConfig> wlsMachineConfigs); static WlsDomainConfig create(String jsonResult); static String getRetrieveServersSearchUrl(); static String getRetrieveServersSearchPayload(); String getClusterName(String serverName); String getName(); String getAdminServerName(); void setAdminServerName(String adminServerName); synchronized Map<String, WlsClusterConfig> getClusterConfigs(); List<WlsClusterConfig> getConfiguredClusters(); void setConfiguredClusters(List<WlsClusterConfig> configuredClusters); synchronized Map<String, WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); List<WlsServerConfig> getServerTemplates(); void setServerTemplates(List<WlsServerConfig> serverTemplates); synchronized Map<String, WlsMachineConfig> getMachineConfigs(); synchronized WlsClusterConfig getClusterConfig(String clusterName); synchronized WlsServerConfig getServerConfig(String serverName); synchronized boolean containsCluster(String clusterName); synchronized boolean containsServer(String serverName); synchronized WlsMachineConfig getMachineConfig(String machineName); @Override @Nonnull String[] getClusterNames(); @Override int getReplicaLimit(String clusterName); WlsDomainConfig withAdminServer(String adminServerName, String listenAddress, int port); WlsDomainConfig addWlsServer(String name, String listenAddress, int port); WlsDomainConfig withCluster(WlsClusterConfig clusterConfig); Map<String, Object> toTopology(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); void processDynamicClusters(); }### Answer:
@Test public void verifyDomainNameLoadedFromJsonString() { createDomainConfig(JSON_STRING_1_CLUSTER); assertEquals("base_domain", wlsDomainConfig.getName()); }
|
### Question:
WlsDomainConfig implements WlsDomain { public synchronized Map<String, WlsServerConfig> getServerConfigs() { Map<String, WlsServerConfig> serverConfigs = new HashMap<>(); for (WlsServerConfig serverConfig : servers) { serverConfigs.put(serverConfig.getName(), serverConfig); } return serverConfigs; } WlsDomainConfig(); WlsDomainConfig(String name); WlsDomainConfig(
String name,
String adminServerName,
Map<String, WlsClusterConfig> wlsClusterConfigs,
Map<String, WlsServerConfig> wlsServerConfigs,
Map<String, WlsServerConfig> wlsServerTemplates,
Map<String, WlsMachineConfig> wlsMachineConfigs); static WlsDomainConfig create(String jsonResult); static String getRetrieveServersSearchUrl(); static String getRetrieveServersSearchPayload(); String getClusterName(String serverName); String getName(); String getAdminServerName(); void setAdminServerName(String adminServerName); synchronized Map<String, WlsClusterConfig> getClusterConfigs(); List<WlsClusterConfig> getConfiguredClusters(); void setConfiguredClusters(List<WlsClusterConfig> configuredClusters); synchronized Map<String, WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); List<WlsServerConfig> getServerTemplates(); void setServerTemplates(List<WlsServerConfig> serverTemplates); synchronized Map<String, WlsMachineConfig> getMachineConfigs(); synchronized WlsClusterConfig getClusterConfig(String clusterName); synchronized WlsServerConfig getServerConfig(String serverName); synchronized boolean containsCluster(String clusterName); synchronized boolean containsServer(String serverName); synchronized WlsMachineConfig getMachineConfig(String machineName); @Override @Nonnull String[] getClusterNames(); @Override int getReplicaLimit(String clusterName); WlsDomainConfig withAdminServer(String adminServerName, String listenAddress, int port); WlsDomainConfig addWlsServer(String name, String listenAddress, int port); WlsDomainConfig withCluster(WlsClusterConfig clusterConfig); Map<String, Object> toTopology(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); void processDynamicClusters(); }### Answer:
@Test public void verifyGetServerConfigsDoesNotIncludeDynamicServers() { createDomainConfig(JSON_STRING_MIXED_CLUSTER); assertEquals(6, wlsDomainConfig.getServerConfigs().size()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.