method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public void addUnique(int[] arr) { for (int i = 0; i < arr.length; i++) { int elt = arr[i]; if (!contains(elt)) { add(elt); } } } ArrayListOfInts(int initialCapacity); ArrayListOfInts(); ArrayListOfInts(int[] a); ArrayListOfInts(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(int n); int indexOf(int n); int lastIndexOf(int n); ArrayListOfInts clone(); int get(int index); int set(int index, int element); ArrayListOfInts add(int e); ArrayListOfInts add(int index, int element); int remove(int index); void clear(); int[] getArray(); Iterator<Integer> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfInts intersection(ArrayListOfInts other); ArrayListOfInts merge(ArrayListOfInts sortedLst); ArrayListOfInts mergeNoDuplicates(ArrayListOfInts sortedLst); ArrayListOfInts subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testAddUnique() { ArrayListOfInts a = new ArrayListOfInts(new int[] { 1, 2, 3, 4, 5, 6, 7 }); a.addUnique(new int[] { 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:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public int size() { return size; } 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 testInitialSize() { ArrayListOfDoubles a = new ArrayListOfDoubles(); assertEquals(0, a.size()); }
|
### 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 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:
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 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:
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 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:
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:
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 { @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:
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:
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:
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:
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:
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:
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:
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:
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:
WlsClusterConfig { public synchronized int getClusterSize() { return servers.size(); } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void verifyClusterSizeIs0IfNoServers() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1"); assertEquals(0, wlsClusterConfig.getClusterSize()); }
|
### Question:
WlsClusterConfig { public synchronized boolean hasStaticServers() { return !servers.isEmpty(); } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void verifyHasStaticServersIsFalseIfNoServers() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1"); assertFalse(wlsClusterConfig.hasStaticServers()); }
@Test public void verifyHasStaticServersIsFalseForDynamicCluster() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1", createDynamicServersConfig(2, 5, 1, "ms-", "clsuter1")); assertFalse(wlsClusterConfig.hasStaticServers()); }
|
### Question:
WlsClusterConfig { public boolean hasDynamicServers() { return dynamicServersConfig != null; } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void verifyHasDynamicServersIsFalsefNoDynamicServers() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1"); assertFalse(wlsClusterConfig.hasDynamicServers()); }
@Test public void verifyHasDynamicServersIsTrueForDynamicCluster() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1", createDynamicServersConfig(2, 5, 1, "ms-", "clsuter1")); assertTrue(wlsClusterConfig.hasDynamicServers()); }
|
### Question:
WlsClusterConfig { public synchronized int getMaxClusterSize() { return hasDynamicServers() ? getClusterSize() + getMaxDynamicClusterSize() : getClusterSize(); } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void verifyMaxClusterSizeIsSameAsDynamicSizeForDynamicCluster() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1", createDynamicServersConfig(2, 5, 1, "ms-", "clsuter1")); assertEquals(5, wlsClusterConfig.getMaxClusterSize()); }
@Test public void verifyMaxClusterSizeForDynamicCluster() { WlsDynamicServersConfig wlsDynamicServersConfig = createDynamicServersConfig(1, 1, 1, "ms-", "cluster1"); WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1", wlsDynamicServersConfig); assertThat(wlsClusterConfig.getMaxClusterSize(), equalTo(1)); }
|
### Question:
WlsClusterConfig { public int getDynamicClusterSize() { return dynamicServersConfig != null ? dynamicServersConfig.getDynamicClusterSize() : -1; } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void verifyDynamicClusterSizeIsNeg1IfNoDynamicServers() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1"); assertEquals(-1, wlsClusterConfig.getDynamicClusterSize()); }
|
### Question:
WlsClusterConfig { public int getMinDynamicClusterSize() { return dynamicServersConfig != null ? dynamicServersConfig.getMinDynamicClusterSize() : -1; } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void verifyMinDynamicClusterSizeIsNeg1IfNoDynamicServers() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1"); assertEquals(-1, wlsClusterConfig.getMinDynamicClusterSize()); }
|
### Question:
WlsClusterConfig { public String getUpdateDynamicClusterSizeUrl() { return "/management/weblogic/latest/edit/clusters/" + name + "/dynamicServers"; } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void verifyGetUpdateDynamicClusterSizeUrlIncludesClusterName() { WlsDynamicServersConfig wlsDynamicServersConfig = createDynamicServersConfig(1, 1, 1, "ms-", "cluster1"); WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1", wlsDynamicServersConfig); assertEquals( wlsClusterConfig.getUpdateDynamicClusterSizeUrl(), "/management/weblogic/latest/edit/clusters/cluster1/dynamicServers"); }
|
### Question:
WlsClusterConfig { public String getUpdateDynamicClusterSizePayload(final int clusterSize) { return "{ dynamicClusterSize: " + clusterSize + " }"; } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void verifyGetUpdateDynamicClusterSizePayload() { WlsDynamicServersConfig wlsDynamicServersConfig = createDynamicServersConfig(1, 5, 1, "ms-", "cluster1"); WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("cluster1", wlsDynamicServersConfig); assertEquals( wlsClusterConfig.getUpdateDynamicClusterSizePayload(2), "{ dynamicClusterSize: 2 }"); }
|
### Question:
WlsClusterConfig { static boolean checkUpdateDynamicClusterSizeJsonResult(String jsonResult) { final String expectedResult = "{}"; boolean result = false; if (expectedResult.equals(jsonResult)) { result = true; } return result; } WlsClusterConfig(); WlsClusterConfig(String clusterName); WlsClusterConfig(String clusterName, WlsDynamicServersConfig dynamicServersConfig); boolean hasNamedServer(String serverName); synchronized WlsClusterConfig addServerConfig(WlsServerConfig wlsServerConfig); synchronized int getClusterSize(); synchronized int getMaxClusterSize(); int getMinClusterSize(); String getClusterName(); String getName(); void setName(String name); WlsDynamicServersConfig getDynamicServersConfig(); void setDynamicServersConfig(WlsDynamicServersConfig dynamicServersConfig); WlsDomainConfig getWlsDomainConfig(); void setWlsDomainConfig(WlsDomainConfig wlsDomainConfig); synchronized List<WlsServerConfig> getServerConfigs(); List<WlsServerConfig> getServers(); void setServers(List<WlsServerConfig> servers); synchronized boolean hasStaticServers(); boolean hasDynamicServers(); int getDynamicClusterSize(); int getMaxDynamicClusterSize(); int getMinDynamicClusterSize(); String getUpdateDynamicClusterSizeUrl(); String getUpdateDynamicClusterSizePayload(final int clusterSize); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer:
@Test public void checkDynamicClusterSizeJsonResultReturnsFalseOnNull() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("someCluster"); assertFalse(wlsClusterConfig.checkUpdateDynamicClusterSizeJsonResult(null)); }
@Test public void checkDynamicClusterSizeJsonResultReturnsFalseOnUnexpectedString() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("someCluster"); assertFalse(wlsClusterConfig.checkUpdateDynamicClusterSizeJsonResult("{ xyz }")); }
@Test public void checkDynamicClusterSizeJsonResultReturnsTrueWithExpectedString() { WlsClusterConfig wlsClusterConfig = new WlsClusterConfig("someCluster"); assertTrue(wlsClusterConfig.checkUpdateDynamicClusterSizeJsonResult("{}")); }
|
### Question:
DomainCondition implements Comparable<DomainCondition>, PatchableComponent<DomainCondition> { public DateTime getLastTransitionTime() { return lastTransitionTime; } DomainCondition(DomainConditionType conditionType); DomainCondition(DomainCondition other); DateTime getLastProbeTime(); void setLastProbeTime(DateTime lastProbeTime); DomainCondition withLastProbeTime(DateTime lastProbeTime); DateTime getLastTransitionTime(); String getMessage(); DomainCondition withMessage(String message); String getReason(); DomainCondition withReason(String reason); String getStatus(); DomainCondition withStatus(String status); DomainConditionType getType(); boolean hasType(DomainConditionType type); @Override boolean isPatchableFrom(DomainCondition other); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(DomainCondition o); }### Answer:
@Test public void whenCreated_conditionHasLastTransitionTime() { assertThat(new DomainCondition(Available).getLastTransitionTime(), SystemClockTestSupport.isDuringTest()); }
|
### Question:
WatchBuilder { public WatchI<V1Pod> createPodWatch(String namespace) throws ApiException { return FACTORY.createWatch( ClientPool.getInstance(), callParams, V1Pod.class, new ListPodCall(namespace)); } WatchBuilder(); WatchI<V1Service> createServiceWatch(String namespace); WatchI<V1Pod> createPodWatch(String namespace); WatchI<V1Job> createJobWatch(String namespace); WatchI<V1Event> createEventWatch(String namespace); WatchI<Domain> createDomainWatch(String namespace); WatchI<V1ConfigMap> createConfigMapWatch(String namespace); WatchI<V1Namespace> createNamespacesWatch(); WatchBuilder withFieldSelector(String fieldSelector); WatchBuilder withLabelSelector(String labelSelector); WatchBuilder withLabelSelectors(String... labelSelectors); WatchBuilder withResourceVersion(String resourceVersion); WatchBuilder withTimeoutSeconds(Integer timeoutSeconds); }### Answer:
@Test public void whenPodWatchFindsNoData_hasNextReturnsFalse() throws Exception { defineHttpResponse(POD_RESOURCE, NO_RESPONSES); WatchI<V1Pod> podWatch = new WatchBuilder().createPodWatch(NAMESPACE); assertThat(podWatch.hasNext(), is(false)); }
|
### Question:
PodWatcher extends Watcher<V1Pod> implements WatchListener<V1Pod>, PodAwaiterStepFactory { public Step waitForReady(V1Pod pod, Step next) { return new WaitForPodReadyStep(pod, next); } private PodWatcher(
String namespace,
String initialResourceVersion,
WatchTuning tuning,
WatchListener<V1Pod> listener,
AtomicBoolean isStopping); static PodWatcher create(
ThreadFactory factory,
String ns,
String initialResourceVersion,
WatchTuning tuning,
WatchListener<V1Pod> listener,
AtomicBoolean isStopping); @Override WatchI<V1Pod> initiateWatch(WatchBuilder watchBuilder); @Override String getNamespace(); void receivedResponse(Watch.Response<V1Pod> item); Step waitForReady(V1Pod pod, Step next); Step waitForDelete(V1Pod pod, Step next); }### Answer:
@Test public void waitForReady_returnsAStep() { AtomicBoolean stopping = new AtomicBoolean(true); PodWatcher watcher = createWatcher(stopping); assertThat(watcher.waitForReady(createPod(), null), Matchers.instanceOf(Step.class)); }
@Test public void whenPodInitiallyReady_waitForReadyProceedsImmediately() { AtomicBoolean stopping = new AtomicBoolean(false); PodWatcher watcher = createWatcher(stopping); V1Pod pod = createPod(); markPodReady(pod); try { testSupport.runSteps(watcher.waitForReady(pod, terminalStep)); assertThat(terminalStep.wasRun(), is(true)); } finally { stopping.set(true); } }
|
### Question:
PodWatcher extends Watcher<V1Pod> implements WatchListener<V1Pod>, PodAwaiterStepFactory { public Step waitForDelete(V1Pod pod, Step next) { return new WaitForPodDeleteStep(pod, next); } private PodWatcher(
String namespace,
String initialResourceVersion,
WatchTuning tuning,
WatchListener<V1Pod> listener,
AtomicBoolean isStopping); static PodWatcher create(
ThreadFactory factory,
String ns,
String initialResourceVersion,
WatchTuning tuning,
WatchListener<V1Pod> listener,
AtomicBoolean isStopping); @Override WatchI<V1Pod> initiateWatch(WatchBuilder watchBuilder); @Override String getNamespace(); void receivedResponse(Watch.Response<V1Pod> item); Step waitForReady(V1Pod pod, Step next); Step waitForDelete(V1Pod pod, Step next); }### Answer:
@Test public void whenPodDeletedOnFirstRead_runNextStep() { AtomicBoolean stopping = new AtomicBoolean(false); PodWatcher watcher = createWatcher(stopping); try { testSupport.runSteps(watcher.waitForDelete(createPod(), terminalStep)); assertThat(terminalStep.wasRun(), is(true)); } finally { stopping.set(true); } }
@Test public void whenPodNotDeletedOnFirstRead_dontRunNextStep() { AtomicBoolean stopping = new AtomicBoolean(false); PodWatcher watcher = createWatcher(stopping); testSupport.defineResources(createPod()); try { testSupport.runSteps(watcher.waitForDelete(createPod(), terminalStep)); assertThat(terminalStep.wasRun(), is(false)); } finally { stopping.set(true); } }
|
### Question:
DomainCondition implements Comparable<DomainCondition>, PatchableComponent<DomainCondition> { public boolean hasType(DomainConditionType type) { return type == this.type; } DomainCondition(DomainConditionType conditionType); DomainCondition(DomainCondition other); DateTime getLastProbeTime(); void setLastProbeTime(DateTime lastProbeTime); DomainCondition withLastProbeTime(DateTime lastProbeTime); DateTime getLastTransitionTime(); String getMessage(); DomainCondition withMessage(String message); String getReason(); DomainCondition withReason(String reason); String getStatus(); DomainCondition withStatus(String status); DomainConditionType getType(); boolean hasType(DomainConditionType type); @Override boolean isPatchableFrom(DomainCondition other); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(DomainCondition o); }### Answer:
@Test public void predicateDetectsType() { assertThat(new DomainCondition(Failed).hasType(Failed), is(true)); assertThat(new DomainCondition(Progressing).hasType(Available), is(false)); }
|
### Question:
DomainStatus { DateTime getStartTime() { return startTime; } DomainStatus(); DomainStatus(DomainStatus that); @Nonnull List<DomainCondition> getConditions(); DomainStatus addCondition(DomainCondition newCondition); boolean hasConditionWith(Predicate<DomainCondition> predicate); void removeConditionIf(Predicate<DomainCondition> predicate); String getMessage(); void setMessage(String message); DomainStatus withMessage(String message); String getReason(); void setReason(String reason); DomainStatus withReason(String reason); Integer getReplicas(); void setReplicas(Integer replicas); DomainStatus withReplicas(Integer replicas); List<ServerStatus> getServers(); void setServers(List<ServerStatus> servers); DomainStatus withServers(List<ServerStatus> servers); DomainStatus addServer(ServerStatus server); List<ClusterStatus> getClusters(); void setClusters(List<ClusterStatus> clusters); DomainStatus addCluster(ClusterStatus cluster); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); void createPatchFrom(JsonPatchBuilder builder, @Nullable DomainStatus oldStatus); }### Answer:
@Test public void whenCreated_statusHasCreationTime() { assertThat(domainStatus.getStartTime(), SystemClockTestSupport.isDuringTest()); }
|
### Question:
AdminServer extends Server { public AdminService getAdminService() { return adminService; } 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 whenConstructedWithAdminService_mayAddLabels() { configureAdminServer() .configureAdminService() .withServiceLabel(NAME1, VALUE1) .withServiceLabel(NAME2, VALUE2); assertThat( domain.getAdminServerSpec().getAdminService().getLabels(), both(hasEntry(NAME1, VALUE1)).and(hasEntry(NAME2, VALUE2))); }
@Test public void whenConstructedWithAdminService_mayAddAnnotations() { configureAdminServer() .configureAdminService() .withServiceAnnotation(NAME1, VALUE1) .withServiceAnnotation(NAME2, VALUE2); assertThat( domain.getAdminServerSpec().getAdminService().getAnnotations(), both(hasEntry(NAME1, VALUE1)).and(hasEntry(NAME2, VALUE2))); }
@Test public void callingGetAdminService_doesNotChangeTheObject() { server1.getAdminService(); assertThat(server1, equalTo(server2)); }
|
### Question:
YamlDocGenerator { String generateForClass(Map<String, Object> classSchema) { StringBuilder sb = new StringBuilder(CLASS_TABLE_HEADER); Map<String, Object> properties = Optional.ofNullable(subMap(classSchema, "properties")).orElse(new HashMap<>()); for (String propertyName : getSortedKeys(properties)) { sb.append("\n").append(generateForProperty(propertyName, properties)); } return sb.toString(); } YamlDocGenerator(Map<String, Object> schema); String generate(String schemaName); String generate(String reference, Map<String, Object> schema); void useKubernetesVersion(String k8sVersion); String getKubernetesSchemaMarkdown(); String getKubernetesSchemaMarkdownFile(); }### Answer:
@Test public void generateMarkdownForSimpleObject() { YamlDocGenerator generator = new YamlDocGenerator(new HashMap<>()); String markdown = generator.generateForClass(generateSchema(SimpleObject.class)); assertThat( markdown, containsString( String.join( "\n", tableHeader(), tableEntry("`aaBoolean`", "Boolean", "A flag"), tableEntry("`aaString`", "string", "A string"), tableEntry("`depth`", "number", "")))); }
|
### Question:
SchemaGenerator { public void useKubernetesVersion(String version) throws IOException { KubernetesSchemaReference reference = KubernetesSchemaReference.create(version); URL cacheUrl = reference.getKubernetesSchemaCacheUrl(); if (cacheUrl == null) { throw new IOException("No schema cached for Kubernetes " + version); } addExternalSchema(reference.getKubernetesSchemaUrl(), cacheUrl); } static String prettyPrint(Object schema); void useKubernetesVersion(String version); void addExternalSchema(URL schemaUrl, URL cacheUrl); void setIncludeAdditionalProperties(boolean includeAdditionalProperties); void setSupportObjectReferences(boolean supportObjectReferences); void setIncludeSchemaReference(boolean includeSchemaReference); void addPackageToSuppressDescriptions(String packageName); Map<String, Object> generate(Class someClass); }### Answer:
@Test(expected = IOException.class) public void whenNonCachedK8sVersionSpecified_throwException() throws IOException { generator.useKubernetesVersion("1.12.0"); }
|
### Question:
KubernetesApiNames { public static boolean matches(String className, Class<?> candidateClass) { if (!candidateClass.getName().startsWith("io.kubernetes.client")) { return false; } String[] parts = className.split("\\."); if (parts.length < 2) { return false; } String last = parts[parts.length - 1]; String nextToLast = parts[parts.length - 2]; String simpleName = candidateClass.getSimpleName(); return matches(simpleName, nextToLast, last); } static boolean matches(String className, Class<?> candidateClass); }### Answer:
@Test public void matchTopLevelClass() { assertThat(KubernetesApiNames.matches("io.k8s.api.core.v1.EnvVar", V1EnvVar.class), is(true)); }
@Test public void matchNestedClass() { assertThat(KubernetesApiNames.matches("io.k8s.api.core.v1.EnvVar", V1.EnvVar.class), is(true)); }
@Test public void dontMatchOthers() { assertThat(KubernetesApiNames.matches("abc", V1EnvVarSource.class), is(false)); assertThat( KubernetesApiNames.matches("io.k8s.api.core.v1.EnvVar", V1EnvVarSource.class), is(false)); }
|
### Question:
DomainStatus { public boolean hasConditionWith(Predicate<DomainCondition> predicate) { return !getConditionsMatching(predicate).isEmpty(); } DomainStatus(); DomainStatus(DomainStatus that); @Nonnull List<DomainCondition> getConditions(); DomainStatus addCondition(DomainCondition newCondition); boolean hasConditionWith(Predicate<DomainCondition> predicate); void removeConditionIf(Predicate<DomainCondition> predicate); String getMessage(); void setMessage(String message); DomainStatus withMessage(String message); String getReason(); void setReason(String reason); DomainStatus withReason(String reason); Integer getReplicas(); void setReplicas(Integer replicas); DomainStatus withReplicas(Integer replicas); List<ServerStatus> getServers(); void setServers(List<ServerStatus> servers); DomainStatus withServers(List<ServerStatus> servers); DomainStatus addServer(ServerStatus server); List<ClusterStatus> getClusters(); void setClusters(List<ClusterStatus> clusters); DomainStatus addCluster(ClusterStatus cluster); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); void createPatchFrom(JsonPatchBuilder builder, @Nullable DomainStatus oldStatus); }### Answer:
@Test public void beforeConditionAdded_statusFailsPredicate() { assertThat(domainStatus.hasConditionWith(c -> c.hasType(Available)), is(false)); }
|
### Question:
AdminServer extends Server { public AdminService createAdminService() { if (adminService == null) { adminService = new AdminService(); } return adminService; } 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 whenHaveSameAdminServiceLabels_objectsAreEqual() { server1.createAdminService().withServiceLabel(NAME1, VALUE1).withServiceLabel(NAME2, VALUE2); server2.createAdminService().withServiceLabel(NAME2, VALUE2).withServiceLabel(NAME1, VALUE1); assertThat(server1, equalTo(server2)); }
@Test public void whenHaveDifferentAdminServiceLabels_objectsAreNotEqual() { server1.createAdminService().withServiceLabel(NAME1, VALUE1).withServiceLabel(NAME2, VALUE2); server2.createAdminService().withServiceLabel(NAME1, VALUE2).withServiceLabel(NAME2, VALUE1); assertThat(server1, not(equalTo(server2))); }
@Test public void whenHaveSameAdminServiceAnnotations_objectsAreEqual() { server1 .createAdminService() .withServiceAnnotation(NAME1, VALUE1) .withServiceAnnotation(NAME2, VALUE2); server2 .createAdminService() .withServiceAnnotation(NAME2, VALUE2) .withServiceAnnotation(NAME1, VALUE1); assertThat(server1, equalTo(server2)); }
@Test public void whenHaveDifferentAdminServiceAnnotations_objectsAreNotEqual() { server1 .createAdminService() .withServiceAnnotation(NAME1, VALUE1) .withServiceAnnotation(NAME2, VALUE2); server2 .createAdminService() .withServiceAnnotation(NAME1, VALUE2) .withServiceAnnotation(NAME2, VALUE1); assertThat(server1, not(equalTo(server2))); }
|
### Question:
DomainStatus { public DomainStatus addServer(ServerStatus server) { synchronized (servers) { for (ListIterator<ServerStatus> it = servers.listIterator(); it.hasNext(); ) { if (Objects.equals(it.next().getServerName(), server.getServerName())) { it.remove(); } } servers.add(server); Collections.sort(servers); } return this; } DomainStatus(); DomainStatus(DomainStatus that); @Nonnull List<DomainCondition> getConditions(); DomainStatus addCondition(DomainCondition newCondition); boolean hasConditionWith(Predicate<DomainCondition> predicate); void removeConditionIf(Predicate<DomainCondition> predicate); String getMessage(); void setMessage(String message); DomainStatus withMessage(String message); String getReason(); void setReason(String reason); DomainStatus withReason(String reason); Integer getReplicas(); void setReplicas(Integer replicas); DomainStatus withReplicas(Integer replicas); List<ServerStatus> getServers(); void setServers(List<ServerStatus> servers); DomainStatus withServers(List<ServerStatus> servers); DomainStatus addServer(ServerStatus server); List<ClusterStatus> getClusters(); void setClusters(List<ClusterStatus> clusters); DomainStatus addCluster(ClusterStatus cluster); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); void createPatchFrom(JsonPatchBuilder builder, @Nullable DomainStatus oldStatus); }### Answer:
@Test public void whenHasServerStatusWithHealth_cloneIsEqual() { domainStatus.addServer(new ServerStatus().withHealth(new ServerHealth().withOverallHealth("peachy"))); DomainStatus clone = new DomainStatus(this.domainStatus); assertThat(clone, equalTo(domainStatus)); }
@Test public void whenHasServerStatusWithoutHealth_cloneIsEqual() { domainStatus.addServer(new ServerStatus().withServerName("myserver")); DomainStatus clone = new DomainStatus(this.domainStatus); assertThat(clone, equalTo(domainStatus)); }
|
### Question:
RestBackendImpl implements RestBackend { @Override public Set<String> getDomainUids() { LOGGER.entering(); authorize(null, Operation.list); Set<String> result = new TreeSet<>(); List<Domain> domains = getDomainsList(); for (Domain domain : domains) { result.add(domain.getDomainUid()); } LOGGER.exiting(result); return result; } RestBackendImpl(String principal, String accessToken, Collection<String> targetNamespaces); @Override Set<String> getDomainUids(); @Override boolean isDomainUid(String domainUid); @Override void performDomainAction(String domainUid, DomainAction params); @Override Set<String> getClusters(String domainUid); @Override boolean isCluster(String domainUid, String cluster); @Override void scaleCluster(String domainUid, String cluster, int managedServerCount); static final String INITIAL_VERSION; }### Answer:
@Test public void retrieveRegisteredDomainIds() { assertThat(restBackend.getDomainUids(), containsInAnyOrder(NAME1, NAME2)); }
|
### Question:
RestBackendImpl implements RestBackend { @Override public boolean isDomainUid(String domainUid) { return getDomain(domainUid).isPresent(); } RestBackendImpl(String principal, String accessToken, Collection<String> targetNamespaces); @Override Set<String> getDomainUids(); @Override boolean isDomainUid(String domainUid); @Override void performDomainAction(String domainUid, DomainAction params); @Override Set<String> getClusters(String domainUid); @Override boolean isCluster(String domainUid, String cluster); @Override void scaleCluster(String domainUid, String cluster, int managedServerCount); static final String INITIAL_VERSION; }### Answer:
@Test public void validateKnownUid() { assertThat(restBackend.isDomainUid(NAME2), is(true)); }
@Test public void rejectUnknownUid() { assertThat(restBackend.isDomainUid("no_such_uid"), is(false)); }
|
### Question:
RestBackendImpl implements RestBackend { @Override public Set<String> getClusters(String domainUid) { LOGGER.entering(domainUid); verifyDomain(domainUid); authorize(domainUid, Operation.get); Map<String, WlsClusterConfig> wlsClusterConfigs = getWlsConfiguredClusters(domainUid); Set<String> result = wlsClusterConfigs.keySet(); LOGGER.exiting(result); return result; } RestBackendImpl(String principal, String accessToken, Collection<String> targetNamespaces); @Override Set<String> getDomainUids(); @Override boolean isDomainUid(String domainUid); @Override void performDomainAction(String domainUid, DomainAction params); @Override Set<String> getClusters(String domainUid); @Override boolean isCluster(String domainUid, String cluster); @Override void scaleCluster(String domainUid, String cluster, int managedServerCount); static final String INITIAL_VERSION; }### Answer:
@Test public void retrieveDefinedClusters() { configSupport.addWlsCluster("cluster1", "ms1", "ms2", "ms3"); configSupport.addWlsCluster("cluster2", "ms4", "ms5", "ms6"); setupScanCache(); assertThat(restBackend.getClusters(NAME1), containsInAnyOrder("cluster1", "cluster2")); }
|
### Question:
RestBackendImpl implements RestBackend { @Override public boolean isCluster(String domainUid, String cluster) { LOGGER.entering(domainUid, cluster); authorize(domainUid, Operation.list); boolean result = getClusters(domainUid).contains(cluster); LOGGER.exiting(result); return result; } RestBackendImpl(String principal, String accessToken, Collection<String> targetNamespaces); @Override Set<String> getDomainUids(); @Override boolean isDomainUid(String domainUid); @Override void performDomainAction(String domainUid, DomainAction params); @Override Set<String> getClusters(String domainUid); @Override boolean isCluster(String domainUid, String cluster); @Override void scaleCluster(String domainUid, String cluster, int managedServerCount); static final String INITIAL_VERSION; }### Answer:
@Test public void acceptDefinedClusterName() { configSupport.addWlsCluster("cluster1", "ms1", "ms2", "ms3"); configSupport.addWlsCluster("cluster2", "ms4", "ms5", "ms6"); setupScanCache(); assertThat(restBackend.isCluster(NAME1, "cluster1"), is(true)); }
@Test public void rejectUndefinedClusterName() { configSupport.addWlsCluster("cluster1", "ms1", "ms2", "ms3"); configSupport.addWlsCluster("cluster2", "ms4", "ms5", "ms6"); setupScanCache(); assertThat(restBackend.isCluster(NAME1, "cluster3"), is(false)); }
|
### Question:
RestBackendImpl implements RestBackend { WlsDomainConfig getWlsDomainConfig(String domainUid) { for (String ns : targetNamespaces) { WlsDomainConfig config = INSTANCE.getWlsDomainConfig(ns, domainUid); if (config != null) { return config; } } return new WlsDomainConfig(null); } RestBackendImpl(String principal, String accessToken, Collection<String> targetNamespaces); @Override Set<String> getDomainUids(); @Override boolean isDomainUid(String domainUid); @Override void performDomainAction(String domainUid, DomainAction params); @Override Set<String> getClusters(String domainUid); @Override boolean isCluster(String domainUid, String cluster); @Override void scaleCluster(String domainUid, String cluster, int managedServerCount); static final String INITIAL_VERSION; }### Answer:
@Test public void verify_getWlsDomainConfig_returnsWlsDomainConfig() { WlsDomainConfig wlsDomainConfig = ((RestBackendImpl) restBackend).getWlsDomainConfig(NAME1); assertThat(wlsDomainConfig.getName(), equalTo(NAME1)); }
@Test public void verify_getWlsDomainConfig_doesNotReturnNull_whenNoSuchDomainUid() { WlsDomainConfig wlsDomainConfig = ((RestBackendImpl) restBackend).getWlsDomainConfig("NoSuchDomainUID"); assertThat(wlsDomainConfig, notNullValue()); }
@Test public void verify_getWlsDomainConfig_doesNotReturnNull_whenScanIsNull() { config = null; WlsDomainConfig wlsDomainConfig = ((RestBackendImpl) restBackend).getWlsDomainConfig(NAME1); assertThat(wlsDomainConfig, notNullValue()); }
|
### Question:
HttpResponseStep extends Step { @Override public NextAction apply(Packet packet) { return Optional.ofNullable(getResponse(packet)).map(r -> doApply(packet, r)).orElse(doNext(packet)); } HttpResponseStep(Step next); @Override NextAction apply(Packet packet); abstract NextAction onSuccess(Packet packet, HttpResponse<String> response); abstract NextAction onFailure(Packet packet, HttpResponse<String> response); }### Answer:
@Test public void whenNoResponseProvided_skipProcessing() { NextAction nextAction = responseStep.apply(new Packet()); assertThat(responseStep.getSuccessResponse(), nullValue()); assertThat(responseStep.getFailureResponse(), nullValue()); assertThat(nextAction.getNext(), sameInstance(terminalStep)); }
|
### Question:
BinaryTreesCount { public static BigInteger findBinaryTreesCount(int n) { if (n <= 0) { throw new IllegalArgumentException("Input number of vertices is not positive"); } return findBinaryTreesCount(n, new BigInteger[n + 1]); } static BigInteger findBinaryTreesCount(int n); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testFindBinaryTreesCountNegativeN() { findBinaryTreesCount(-1); }
@Test public void testFindBinaryTrees1() { assertThat(findBinaryTreesCount(1), is(BigInteger.valueOf(1))); }
@Test public void testFindBinaryTrees2() { assertThat(findBinaryTreesCount(2), is(BigInteger.valueOf(2))); }
@Test public void testFindBinaryTrees3() { assertThat(findBinaryTreesCount(3), is(BigInteger.valueOf(5))); }
@Test public void testFindBinaryTrees4() { assertThat(findBinaryTreesCount(4), is(BigInteger.valueOf(14))); }
@Test public void testFindBinaryTrees5() { assertThat(findBinaryTreesCount(14), is(BigInteger.valueOf(2674440))); }
@Test public void testFindBinaryTrees6() { assertThat(findBinaryTreesCount(20), is(BigInteger.valueOf(6564120420L))); }
@Test public void testFindBinaryTrees7() { assertThat(findBinaryTreesCount(30), is(BigInteger.valueOf(3814986502092304L))); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.