method2testcases stringlengths 118 3.08k |
|---|
### Question:
TypedMap implements Map<String, Object> { public void clear() { inner.clear(); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testClear() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); values.put("stringArray", new String[] { "a", "b", "c" }); TypedMap map = new TypedMap(recordType, values); map.clear(); assertEquals(0, map.size()); } |
### Question:
TypedMap implements Map<String, Object> { public boolean containsKey(Object arg0) { return inner.containsKey(arg0); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testContainsKey() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); values.put("stringArray", new String[] { "a", "b", "c" }); TypedMap map = new TypedMap(recordType, values); assertTrue(map.containsKey("intValue")); assertTrue(map.containsKey("booleanValue")); assertFalse(map.containsKey("longValue")); assertFalse(map.containsKey(null)); } |
### Question:
TypedMap implements Map<String, Object> { public boolean containsValue(Object arg0) { return inner.containsValue(arg0); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testContainsValue() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); assertTrue(map.containsValue(1)); assertTrue(map.containsValue(true)); assertTrue(map.containsValue( new TypedList(stringListType, stringArray))); assertFalse(map.containsValue(1L)); assertFalse(map.containsValue(null)); } |
### Question:
TypedMap implements Map<String, Object> { public Set<Entry<String, Object>> entrySet() { return inner.entrySet(); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testEntrySet() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); Set<Entry<String, Object>> entrySet = map.entrySet(); assertEquals(3, entrySet.size()); for (Entry<String, Object> entry : entrySet) { if (entry.getKey().equals("intValue")) { assertEquals(1, entry.getValue()); } } for (Entry<String, Object> entry : entrySet) { if (entry.getKey().equals("booleanValue")) { assertEquals(true, entry.getValue()); } } for (Entry<String, Object> entry : entrySet) { if (entry.getKey().equals("stringArray")) { assertEquals(new TypedList(stringListType, stringArray), entry.getValue()); } } } |
### Question:
TypedMap implements Map<String, Object> { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; TypedMap other = (TypedMap) obj; if (inner == null) { if (other.inner != null) return false; } else if (!inner.equals(other.inner)) return false; if (type == null) { if (other.type != null) return false; } else if (!type.equals(other.type)) return false; return true; } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testEquals() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); TypedMap map2 = new TypedMap(recordType); map2.put("intValue", 1); map2.put("booleanValue", true); map2.put("stringArray", stringArray); assertTrue(map.equals(map2)); assertTrue(map2.equals(map)); } |
### Question:
TypedMap implements Map<String, Object> { public Object get(Object arg0) { getFieldType((String) arg0); return inner.get(arg0); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testGet() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); assertEquals(1, map.get("intValue")); assertEquals(true, map.get("booleanValue")); try { map.get("longValue"); fail(); } catch (NoSuchRecordFieldException e) { } } |
### Question:
TypedMap implements Map<String, Object> { public boolean isEmpty() { return inner.isEmpty(); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testIsEmpty() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); assertFalse(map.isEmpty()); assertTrue(new TypedMap(recordType).isEmpty()); } |
### Question:
TypedMap implements Map<String, Object> { public Set<String> keySet() { return inner.keySet(); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testKeySet() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); Set<String> keySet = map.keySet(); assertEquals(3, keySet.size()); assertTrue(keySet.contains("intValue")); assertTrue(keySet.contains("booleanValue")); assertTrue(keySet.contains("stringArray")); } |
### Question:
TypedMap implements Map<String, Object> { public void putAll(Map<? extends String, ? extends Object> arg0) { inner.putAll(convertToTypedObjects(arg0)); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@SuppressWarnings("serial") @Test public void testPutAll() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); map.putAll(new HashMap<String, Object>() {{ put("intValue", 2); put("booleanValue", false); }}); assertEquals(3, map.size()); assertEquals(2, map.get("intValue")); assertEquals(false, map.get("booleanValue")); try { map.putAll(new HashMap<String, Object>() {{ put("intValue", 3); put("longValue", 5L); }}); fail(); } catch (NoSuchRecordFieldException e) { } try { map.putAll(new HashMap<String, Object>() {{ put("intValue", 6L); }}); fail(); } catch (UnassignableValueException e) { } } |
### Question:
TypedMap implements Map<String, Object> { public Object remove(Object arg0) { getFieldType((String) arg0); return inner.remove(arg0); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testRemove() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); assertEquals(1, map.remove("intValue")); assertEquals(2, map.size()); try { map.remove("longValue"); fail(); } catch (NoSuchRecordFieldException e) { } } |
### Question:
TypedMap implements Map<String, Object> { public int size() { return inner.size(); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testSize() throws Exception { Map<String, Object> values = new HashMap<String, Object>(); values.put("intValue", 1); values.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; values.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, values); assertEquals(3, map.size()); } |
### Question:
TypedMap implements Map<String, Object> { public Collection<Object> values() { return inner.values(); } TypedMap(final RecordType type); TypedMap(final RecordType type,
final Map<? extends String, ? extends Object> map); RecordType getType(); Type getFieldType(final String fieldName); void clear(); boolean containsKey(Object arg0); boolean containsValue(Object arg0); Set<Entry<String, Object>> entrySet(); Object get(Object arg0); boolean isEmpty(); Set<String> keySet(); Object put(String arg0, Object arg1); void putAll(Map<? extends String, ? extends Object> arg0); Object remove(Object arg0); int size(); Collection<Object> values(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testValues() throws Exception { Map<String, Object> initialValues = new HashMap<String, Object>(); initialValues.put("intValue", 1); initialValues.put("booleanValue", true); String[] stringArray = new String[] { "a", "b", "c" }; initialValues.put("stringArray", stringArray); TypedMap map = new TypedMap(recordType, initialValues); Collection<Object> values = map.values(); assertEquals(3, values.size()); assertTrue(values.contains(1)); assertTrue(values.contains(true)); assertTrue(values.contains(new TypedList(stringListType, stringArray))); } |
### Question:
TypedList implements List<Object> { public void clear() { inner.clear(); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testClear() throws Exception { String[] strings = new String[] { "a", "b", "c" }; List<Object> list = new TypedList(stringListType, strings); list.clear(); assertEquals(0, list.size()); } |
### Question:
TypedList implements List<Object> { public boolean contains(Object o) { return inner.contains(o); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testContains() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "d" }; List<Object> list = new TypedList(stringListType, strings); for (String s : strings) { assertTrue(list.contains(s)); } assertTrue(list.contains(null)); assertFalse(list.contains("e")); } |
### Question:
TypedList implements List<Object> { public boolean containsAll(Collection<?> c) { return inner.containsAll(c); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testContainsAll() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "d" }; List<Object> list = new TypedList(stringListType, strings); assertTrue(list.containsAll(Arrays.asList(strings))); assertTrue(list.containsAll(Arrays.asList(new String[] { "a", "b", null }))); assertFalse(list.containsAll(Arrays.asList(new String[] { "a", "e" }))); assertFalse(list.containsAll(Arrays.asList(new Object[] { "a", 1 }))); try { list.containsAll(null); fail(); } catch (NullPointerException e) { } } |
### Question:
TypedList implements List<Object> { public Object get(int index) { return inner.get(index); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testGet() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "a", "b", "c", "d" }; List<Object> list = new TypedList(stringListType, strings); for (int i = 0; i < strings.length; i++) { assertEquals(strings[i], list.get(i)); } try { list.get(-1); fail(); } catch (IndexOutOfBoundsException e) { } try { list.get(list.size()); fail(); } catch (IndexOutOfBoundsException e) { } } |
### Question:
TypedList implements List<Object> { public int indexOf(Object o) { return inner.indexOf(o); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testIndexOf() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "a", "b", "c", "d" }; List<Object> list = new TypedList(stringListType, strings); assertEquals(0, list.indexOf("a")); assertEquals(1, list.indexOf("b")); assertEquals(2, list.indexOf("c")); assertEquals(3, list.indexOf(null)); assertEquals(7, list.indexOf("d")); assertEquals(-1, list.indexOf("e")); } |
### Question:
TypedList implements List<Object> { public boolean isEmpty() { return inner.isEmpty(); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testIsEmpty() throws Exception { assertTrue(new TypedList(stringListType).isEmpty()); assertFalse(new TypedList(stringListType, new String[] { "a" }).isEmpty()); } |
### Question:
TypedList implements List<Object> { public Iterator<Object> iterator() { return inner.iterator(); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testIterator() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "a", "b", "c", "d" }; List<Object> list = new TypedList(stringListType, strings); Iterator<Object> i = list.iterator(); assertTrue(i.hasNext()); assertEquals("a", i.next()); assertEquals("b", i.next()); i.remove(); assertEquals("c", i.next()); assertEquals(null, i.next()); assertEquals("a", i.next()); assertEquals("b", i.next()); i.remove(); assertEquals("c", i.next()); assertEquals("d", i.next()); assertFalse(i.hasNext()); try { i.next(); fail(); } catch (NoSuchElementException e) { } } |
### Question:
TypedList implements List<Object> { public int lastIndexOf(Object o) { return inner.lastIndexOf(o); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testLastIndexOf() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "a", "b", "c", "d" }; List<Object> list = new TypedList(stringListType, strings); assertEquals(4, list.lastIndexOf("a")); assertEquals(5, list.lastIndexOf("b")); assertEquals(6, list.lastIndexOf("c")); assertEquals(3, list.lastIndexOf(null)); assertEquals(7, list.lastIndexOf("d")); assertEquals(-1, list.lastIndexOf("e")); } |
### Question:
TypedList implements List<Object> { public ListIterator<Object> listIterator() { return new TypedListIterator(type, inner.listIterator()); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testListIterator() throws Exception { } |
### Question:
TypedList implements List<Object> { public boolean removeAll(Collection<?> c) { return inner.removeAll(c); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testRemoveAll() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "a", "b", "c", "d" }; List<Object> list = new TypedList(stringListType, strings); Collection<String> c = Arrays.asList(new String[] { "a", "b" }); assertTrue(list.removeAll(c)); assertEquals("c", list.get(0)); assertEquals(null, list.get(1)); assertEquals("c", list.get(2)); assertEquals("d", list.get(3)); assertFalse(list.removeAll(c)); try { list.removeAll(null); fail(); } catch (NullPointerException e) { } } |
### Question:
TypedList implements List<Object> { public boolean retainAll(Collection<?> c) { return inner.retainAll(c); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testRetainAll() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "a", "b", "c", "d" }; List<Object> list = new TypedList(stringListType, strings); Collection<String> c = Arrays.asList(new String[] { "a", "b" }); assertTrue(list.retainAll(c)); assertEquals("a", list.get(0)); assertEquals("b", list.get(1)); assertEquals("a", list.get(2)); assertEquals("b", list.get(3)); assertFalse(list.retainAll(c)); try { list.retainAll(null); fail(); } catch (NullPointerException e) { } } |
### Question:
TypedList implements List<Object> { public int size() { return inner.size(); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testSize() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "a", "b", "c", "d" }; List<Object> list = new TypedList(stringListType, strings); assertEquals(strings.length, list.size()); } |
### Question:
TypedList implements List<Object> { public Object[] toArray() { return inner.toArray(); } TypedList(final ListType type); TypedList(final ListType type,
final Collection<? extends Object> collection); @SuppressWarnings("unchecked") TypedList(final ListType type, final Object array); ListType getType(); Type getElementType(); void add(int index, Object element); boolean add(Object o); boolean addAll(Collection<? extends Object> c); boolean addAll(int index, Collection<? extends Object> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); Object get(int index); int indexOf(Object o); boolean isEmpty(); Iterator<Object> iterator(); int lastIndexOf(Object o); ListIterator<Object> listIterator(); ListIterator<Object> listIterator(int index); Object remove(int index); boolean remove(Object o); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); Object set(int index, Object element); int size(); List<Object> subList(int fromIndex, int toIndex); Object[] toArray(); T[] toArray(T[] a); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testToArray() throws Exception { String[] strings = new String[] { "a", "b", "c", null, "a", "b", "c", "d" }; List<Object> list = new TypedList(stringListType, strings); Object[] array = list.toArray(); assertNotNull(array); assertEquals(strings.length, array.length); for (int i = 0; i < strings.length; i++) { assertEquals(strings[i], array[i]); } String[] stringArray = list.toArray(new String[] {}); assertNotNull(stringArray); assertEquals(strings.length, stringArray.length); for (int i = 0; i < strings.length; i++) { assertEquals(strings[i], stringArray[i]); } try { list.toArray(new Integer[] {}); fail(); } catch (ArrayStoreException e) { } try { list.toArray(null); fail(); } catch (NullPointerException e) { } } |
### Question:
ListType extends AbstractType { @Override public boolean isAssignableFrom(Class<?> clazz) { if (super.isAssignableFrom(clazz)) { return true; } if (clazz.isArray()) { return elementType.isAssignableFrom(clazz.getComponentType()); } return false; } ListType(); ListType(final String id, final String name, final Type elementType); Type getElementType(); void setElementType(Type elementType); @Override boolean isAssignableFrom(Class<?> clazz); Object convertToTypedObject(final Object source); boolean isAssignableValue(Object source); @Override boolean isValid(); }### Answer:
@Test public void testIsAssignableFrom() throws Exception { ListType stringListType = new ListType("string[]", "string[]", PrimitiveType.STRING); assertTrue(stringListType.isAssignableFrom(TypedList.class)); assertTrue(stringListType.isAssignableFrom(List.class)); assertTrue(stringListType.isAssignableFrom(String[].class)); assertFalse(stringListType.isAssignableFrom(Map.class)); ListType stringListType2 = new ListType("string[][]", "string[][]", stringListType); assertTrue(stringListType2.isAssignableFrom(TypedList.class)); assertTrue(stringListType2.isAssignableFrom(List.class)); assertTrue(stringListType2.isAssignableFrom(String[][].class)); assertFalse(stringListType2.isAssignableFrom(Map.class)); assertFalse(stringListType2.isAssignableFrom(String[].class)); ListType integerListType = new ListType("integer[]", "integer[]", PrimitiveType.INTEGER); assertTrue(integerListType.isAssignableFrom(int[].class)); assertTrue(integerListType.isAssignableFrom(Integer[].class)); assertTrue(integerListType.isAssignableFrom(byte[].class)); assertTrue(integerListType.isAssignableFrom(short[].class)); assertFalse(integerListType.isAssignableFrom(long[].class)); assertFalse(integerListType.isAssignableFrom(float[].class)); } |
### Question:
ListType extends AbstractType { public boolean isAssignableValue(Object source) { if (source == null) { return true; } if (source instanceof TypedList) { return this.equals(((TypedList) source).getType()); } if (source instanceof Collection) { for (Object sourceElement : (Iterable<?>) source) { if (elementType.isAssignableValue(sourceElement) == false) { return false; } } return true; } if (source.getClass().isArray()) { return elementType.isAssignableFrom(source.getClass() .getComponentType()); } return false; } ListType(); ListType(final String id, final String name, final Type elementType); Type getElementType(); void setElementType(Type elementType); @Override boolean isAssignableFrom(Class<?> clazz); Object convertToTypedObject(final Object source); boolean isAssignableValue(Object source); @Override boolean isValid(); }### Answer:
@SuppressWarnings("serial") @Test public void testIsAssigableValue() throws Exception { ListType stringListType = new ListType("string[]", "string[]", PrimitiveType.STRING); List<String> stringList = new ArrayList<String>() {{ add("a"); add("b"); add("c"); }}; assertTrue(stringListType.isAssignableValue(stringList)); assertTrue(stringListType.isAssignableValue(new String[] { "a", "b", "c" })); ListType integerListType = new ListType("integer[]", "integer[]", PrimitiveType.INTEGER); assertTrue(integerListType.isAssignableValue(new int[] { 1, 2, 3 })); assertTrue(integerListType.isAssignableValue(new byte[] { 1, 2, 3 })); assertFalse(integerListType.isAssignableValue(new long[] { 1L, 2L, 3L })); } |
### Question:
ListType extends AbstractType { public Object convertToTypedObject(final Object source) { if (source == null) { return null; } if (source instanceof TypedList) { if (this.equals(((TypedList) source).getType()) == false) { throw new UnassignableValueException(); } return source; } if (source instanceof Collection) { return new TypedList(this, (Collection<?>) source); } if (source.getClass().isArray()) { return new TypedList(this, source); } throw new UnassignableValueException(); } ListType(); ListType(final String id, final String name, final Type elementType); Type getElementType(); void setElementType(Type elementType); @Override boolean isAssignableFrom(Class<?> clazz); Object convertToTypedObject(final Object source); boolean isAssignableValue(Object source); @Override boolean isValid(); }### Answer:
@Test public void testConvertToTypedObject() throws Exception { ListType stringListType = new ListType("string[]", "string[]", PrimitiveType.STRING); String[] stringArray = new String[] { "a", "b", "c" }; Object object = stringListType.convertToTypedObject(stringArray); assertNotNull(object); assertTrue(object instanceof TypedList); TypedList typedStringList = (TypedList)object; assertEquals(stringArray.length, typedStringList.size()); for (int i = 0; i < stringArray.length; i++) { assertEquals(stringArray[i], typedStringList.get(i)); } int[] intArray = new int[] { 1, 2, 3 }; assertTrue(isUnassignableValue(stringListType, intArray)); ListType integerListType = new ListType("integer[]", "integer[]", PrimitiveType.INTEGER); object = integerListType.convertToTypedObject(intArray); assertNotNull(object); assertTrue(object instanceof TypedList); TypedList typedIntegerList = (TypedList)object; assertEquals(intArray.length, typedIntegerList.size()); for (int i = 0; i < intArray.length; i++) { assertEquals(intArray[i], typedIntegerList.get(i)); } } |
### Question:
HibernateIntegrationDefinitionDao extends HibernateDaoSupport implements IntegrationDefinitionDao { @SuppressWarnings("unchecked") public List<IntegrationDefinition> getIntegrationDefinitionOfConsumer( String consumerOrganizationId, String consumerSystemId) { LOG.debug("get IntegrationDefinition of Consumer(organizationId = \"" + consumerOrganizationId + "\", systemId = \"" + consumerSystemId + "\")"); List<IntegrationDefinition> list = getHibernateTemplate() .find( "from IntegrationDefinition as integrationDefinition " + "where integrationDefinition.consumer.organization.id = ? " + "and integrationDefinition.consumer.id = ?", new Object[] {consumerOrganizationId, consumerSystemId }); if (LOG.isDebugEnabled()) { LOG .debug("get IntegrationDefinition of Consumer(organizationId = \"" + consumerOrganizationId + "\", systemId = \"" + consumerSystemId + "\")'s size = " + list.size()); int i = 0; for (IntegrationDefinition integrationDefinition : list) { LOG.debug("[" + i + "] : " + integrationDefinition); i++; } } return list; } IntegrationDefinition getIntegrationDefinition(String id); @SuppressWarnings("unchecked") List<IntegrationDefinition> getIntegrationDefinitionOfConsumer(
String consumerOrganizationId, String consumerSystemId); @SuppressWarnings("unchecked") List<IntegrationDefinition> getIntegrationDefinitionOfProvider(
String providerOrganizationId, String providerSystemId); }### Answer:
@Test public void testReadOfConsumerSucceeds() throws Exception { List<IntegrationDefinition> list = dao.getIntegrationDefinitionOfConsumer("00000000", "00000000"); assertEquals(2, list.size()); assertEquals("1", list.get(0).getId()); assertTrue(list.get(0).isValid()); assertEquals("2", list.get(1).getId()); assertTrue(list.get(1).isValid()); } |
### Question:
HibernateIntegrationDefinitionDao extends HibernateDaoSupport implements IntegrationDefinitionDao { @SuppressWarnings("unchecked") public List<IntegrationDefinition> getIntegrationDefinitionOfProvider( String providerOrganizationId, String providerSystemId) { LOG.debug("get IntegrationDefinition of Provider(organizationId = \"" + providerOrganizationId + "\", systemId = \"" + providerSystemId + "\")"); List<IntegrationDefinition> list = getHibernateTemplate() .find( "from IntegrationDefinition as integrationDefinition " + "where integrationDefinition.provider.system.organization.id = ? " + "and integrationDefinition.provider.system.id = ?", new Object[] {providerOrganizationId, providerSystemId }); if (LOG.isDebugEnabled()) { LOG .debug("get IntegrationDefinition of Provider(organizationId = \"" + providerOrganizationId + "\", systemId = \"" + providerSystemId + "\")'s size = " + list.size()); int i = 0; for (IntegrationDefinition integrationDefinition : list) { LOG.debug("[" + i + "] : " + integrationDefinition); i++; } } return list; } IntegrationDefinition getIntegrationDefinition(String id); @SuppressWarnings("unchecked") List<IntegrationDefinition> getIntegrationDefinitionOfConsumer(
String consumerOrganizationId, String consumerSystemId); @SuppressWarnings("unchecked") List<IntegrationDefinition> getIntegrationDefinitionOfProvider(
String providerOrganizationId, String providerSystemId); }### Answer:
@Test public void testReadOfProviderSucceeds() throws Exception { List<IntegrationDefinition> list = dao.getIntegrationDefinitionOfProvider("00000000", "00000000"); assertEquals(1, list.size()); assertEquals("1", list.get(0).getId()); assertTrue(list.get(0).isValid()); } |
### Question:
HibernateSystemDefinitionDao extends HibernateDaoSupport implements
SystemDefinitionDao { public SystemDefinition getSystemDefinition(String key) { LOG.debug("get SystemDefinition(key = \"" + key + "\")"); SystemDefinition systemDefinition = (SystemDefinition) getHibernateTemplate().get( SystemDefinition.class, key); LOG.debug("get SystemDefinition(key = \"" + key + "\") = " + systemDefinition); return systemDefinition; } SystemDefinition getSystemDefinition(String key); @SuppressWarnings("unchecked") SystemDefinition getSystemDefinition(String organizationId,
String systemId); }### Answer:
@Test public void testReadSucceeds() throws Exception { SystemDefinition systemA0 = dao.getSystemDefinition("00000000", "00000000"); assertNotNull(systemA0); assertTrue(systemA0.isValid()); assertEquals("00000000", systemA0.getId()); assertEquals("System A0", systemA0.getName()); assertEquals(true, systemA0.isStandard()); assertEquals(1, systemA0.getServices().size()); assertEquals("00000000", systemA0.getOrganization().getId()); ServiceDefinition serviceA0_0 = systemA0.getServiceDefinition("00000000"); assertNotNull(serviceA0_0); assertTrue(serviceA0_0.isValid()); assertEquals("00000000", serviceA0_0.getId()); assertEquals("Service A0-0", serviceA0_0.getName()); assertEquals("M1", serviceA0_0.getRequestMessageTypeId()); assertEquals("M2", serviceA0_0.getResponseMessageTypeId()); assertNull(serviceA0_0.getServiceProviderBeanId()); assertEquals(systemA0, serviceA0_0.getSystem()); }
@Test public void testReadFails() throws Exception { SystemDefinition system = dao.getSystemDefinition("00000000", "00000003"); assertNull(system); } |
### Question:
HibernateServiceDefinitionDao extends HibernateDaoSupport implements ServiceDefinitionDao { public ServiceDefinition getServiceDefinition(String key) { LOG.debug("get ServiceDefinition(key = \"" + key + "\")"); ServiceDefinition serviceDefinition = (ServiceDefinition) getHibernateTemplate().get( ServiceDefinition.class, key); LOG.debug("get ServiceDefinition(key = \"" + key + "\") = " + serviceDefinition); return serviceDefinition; } ServiceDefinition getServiceDefinition(String key); @SuppressWarnings("unchecked") ServiceDefinition getServiceDefinition(String systemKey,
String serviceId); @SuppressWarnings("unchecked") ServiceDefinition getServiceDefinition(String organizationId,
String systemId, String serviceId); }### Answer:
@Test public void testReadSucceeds() throws Exception { ServiceDefinition serviceA0_0 = dao.getServiceDefinition("00000000", "00000000", "00000000"); assertNotNull(serviceA0_0); assertTrue(serviceA0_0.isValid()); assertEquals("00000000", serviceA0_0.getId()); assertEquals("Service A0-0", serviceA0_0.getName()); assertEquals("M1", serviceA0_0.getRequestMessageTypeId()); assertEquals("M2", serviceA0_0.getResponseMessageTypeId()); assertNull(serviceA0_0.getServiceProviderBeanId()); assertEquals("00000000", serviceA0_0.getSystem().getId()); }
@Test public void testReadFails() throws Exception { ServiceDefinition service = dao.getServiceDefinition("00000000", "00000000", "00000003"); assertNull(service); } |
### Question:
AbstractService implements EgovIntegrationService { public EgovIntegrationMessage sendSync(EgovIntegrationMessage requestMessage) { LOG.debug("sendSync called without timeout"); if (requestMessage == null) { LOG.error("requestMessage is null"); throw new IllegalArgumentException(); } LOG.debug("call sendSync with defauleTimeout"); return sendSync(requestMessage, defaultTimeout); } AbstractService(String id, long defaultTimeout); long getDefaultTimeout(); String getId(); EgovIntegrationServiceResponse sendAsync(
final EgovIntegrationMessage requestMessage); void sendAsync(final EgovIntegrationMessage requestMessage,
EgovIntegrationServiceCallback callback); EgovIntegrationMessage sendSync(EgovIntegrationMessage requestMessage); EgovIntegrationMessage sendSync(
EgovIntegrationMessage requestMessage, long timeout); }### Answer:
@Test public void testSendSyncSucceeds() throws Exception { EgovIntegrationMessage responseMessage = echoService.sendSync(requestMessage); assertEquals(requestMessage, responseMessage); }
@Test public void testSendSyncWithTimeoutSucceeds() throws Exception { EgovIntegrationMessage responseMessage = echoService.sendSync(requestMessage, TIMEOUT_WILL_SUCCEED); assertEquals(requestMessage, responseMessage); }
@Test public void testSendSyncTimedOut() throws Exception { EgovIntegrationMessage responseMessage = echoService.sendSync(requestMessage, TIMEOUT_WILL_BE_TIMED_OUT); assertEquals(ResultCode.TIME_OUT, responseMessage.getHeader().getResultCode()); } |
### Question:
TimeGenerator implements Runnable { public void reset() { count = 0; startTime = System.currentTimeMillis(); if (owner.propMode != MEASURE_TIME) { owner.opTime.sendData(ConversionUtils.intToBytes(0)); } } TimeGenerator(final TimerInstance owner); void reset(); @Override void run(); void start(); void stop(); }### Answer:
@Test public void testReset() { } |
### Question:
TimeGenerator implements Runnable { public void start() { if (runningTaskFuture == null || (runningTaskFuture != null && runningTaskFuture.isDone())) { runningTaskFuture = AstericsThreadPool.instance.execute(this); } else { reset(); } } TimeGenerator(final TimerInstance owner); void reset(); @Override void run(); void start(); void stop(); }### Answer:
@Test public void testStart() { } |
### Question:
TimeGenerator implements Runnable { public void stop() { if (runningTaskFuture != null && !runningTaskFuture.isDone()) { runningTaskFuture.cancel(true); } active = false; count = 0; runningTaskFuture = null; } TimeGenerator(final TimerInstance owner); void reset(); @Override void run(); void start(); void stop(); }### Answer:
@Test public void testStop() { } |
### Question:
TimeGenerator implements Runnable { void stopAndSendData() { stop(); if (owner.propMode == MEASURE_TIME) { owner.opTime.sendData(ConversionUtils.intToBytes((int) (currentTime - owner.propWaitPeriod))); } } TimeGenerator(final TimerInstance owner); void reset(); @Override void run(); void start(); void stop(); }### Answer:
@Test public void testStopAndSendData() { } |
### Question:
Position extends Point { public static double normalizeAngle(double angle) { angle %= (2 * Math.PI); if (angle > Math.PI) angle -= 2 * Math.PI; if (angle <= -Math.PI) angle += 2 * Math.PI; return angle; } Position(double x, double y, double angle); Position(double x, double y); Position(Point point, double angle); Position(Point point); Position weightedAvg(Position b, double bWeight); static double normalizeAngle(double angle); @Override double[] get(); void set(double x, double y, double angle); Position changeAngleBy(double angle); Position rotateWithAngle(double angle); @Override Position clone(); double getAngle(); void setAngle(double angle); Position translate(Position p); Position moveBy(double linearV, double angularV, double t); @Override Position localizerToMathCoords(); @Override Position weaverToLocalizerCoords(); @Override Point mathToWeaverCoords(); @Override Position mathToFrcCoords(); @Override String toString(); }### Answer:
@Test void normalizeTest() { double delta = Math.pow(10, -8); assertAll("angles", () -> assertEquals(Position.normalizeAngle(Math.PI), Math.PI, delta), () -> assertEquals(Position.normalizeAngle(Math.PI * 2), 0, delta), () -> assertEquals(Position.normalizeAngle(-Math.PI), Math.PI, delta), () -> assertEquals(Position.normalizeAngle(-2 * Math.PI), 0, delta), () -> assertEquals(Position.normalizeAngle(-0.5 * Math.PI - 8 * Math.PI), -0.5 * Math.PI, delta), () -> assertEquals(Position.normalizeAngle(1.3 + Math.PI * 16), 1.3, delta)); } |
### Question:
Position extends Point { @Override public Position clone() { return new Position(x, y, angle); } Position(double x, double y, double angle); Position(double x, double y); Position(Point point, double angle); Position(Point point); Position weightedAvg(Position b, double bWeight); static double normalizeAngle(double angle); @Override double[] get(); void set(double x, double y, double angle); Position changeAngleBy(double angle); Position rotateWithAngle(double angle); @Override Position clone(); double getAngle(); void setAngle(double angle); Position translate(Position p); Position moveBy(double linearV, double angularV, double t); @Override Position localizerToMathCoords(); @Override Position weaverToLocalizerCoords(); @Override Point mathToWeaverCoords(); @Override Position mathToFrcCoords(); @Override String toString(); }### Answer:
@Test void cloneTest() { Position p1 = new Position(Math.random(), Math.random(), Math.random()); assertNotSame(p1, p1.clone()); assertEquals(p1, p1.clone()); } |
### Question:
Point { public Point clone() { return new Point(x, y); } Point(double x, double y); static Point cis(double ang, double len); Point clone(); double[] get(); void set(double x, double y); Point translate(double x, double y); static Point add(Point first, Point other); Point negate(); Point scale(double scale); Point rotate(double radians); Point translate(Point p); double getY(); void setY(double y); double getX(); void setX(double x); static Point subtract(Point subtractee, Point subtractor); static double dotProduct(Point a, Point b); static double normSquared(Point point); static double norm(Point point); double norm(); static double distSqared(Point a, Point b); static double dist(Point a, Point b); static boolean isFuzzyEqual(double first, double second, double epsilon); static boolean isFuzzyEqual(double first, double second); static boolean fuzzyEquals(Point fir, Point sec, double epsilon); Point weightedAvg(Point b, double bWeight); Point avg(Point b); static Point bezierSample(double locInCurve, Point... corners); static Point recursiveBezierSample(double locInCurve, Point... corners); @Override String toString(); @Override boolean equals(Object o); Point localizerToMathCoords(); Point mathToWeaverCoords(); Point weaverToLocalizerCoords(); Point changeCoords(CoordinateSystems src, CoordinateSystems dest); @Deprecated Point mathToFrcCoords(); double[] toPolarCoords(); @Override int hashCode(); static final Point ORIGIN; }### Answer:
@Test void cloneTest() { Point p1 = new Point(Math.random(), Math.random()); assertNotSame(p1, p1.clone()); assertEquals(p1, p1.clone()); } |
### Question:
GithubDataManager implements DataManager { @Override public Single<Response<List<Repo>>> getRepos(@NonNull String username) { return githubService.getRepos(username); } @Inject GithubDataManager(@NonNull GithubService githubService, @NonNull SharedPreferencesHelper sharedPreferencesHelper); @Override Single<Response<List<Repo>>> getRepos(@NonNull String username); @Override Single<Response<Repo>> getRepo(@NonNull String owner, @NonNull String repo); @Override void setFirstRun(boolean value); @Override boolean getFirstRun(); @Override void setLastUsername(@NonNull String username); @Override String getLastUsername(); @Override APIError convertToError(@NonNull ResponseBody errorBody); }### Answer:
@Test public void getReposCompletesAndEmits() throws Exception { String username = TestDataFactory.repoDataFactory.createUsername(); List<Repo> repos = TestDataFactory.repoDataFactory.createRepoList(3); Response<List<Repo>> response = Response.success(repos); stubGithubServiceGetRepos(username, Single.just(response)); TestObserver<Response<List<Repo>>> testSubscriber = dataManager.getRepos(username).test(); testSubscriber.assertComplete(); testSubscriber.assertValue(response); } |
### Question:
GithubDataManager implements DataManager { @Override public Single<Response<Repo>> getRepo(@NonNull String owner, @NonNull String repo) { return githubService.getRepo(owner, repo); } @Inject GithubDataManager(@NonNull GithubService githubService, @NonNull SharedPreferencesHelper sharedPreferencesHelper); @Override Single<Response<List<Repo>>> getRepos(@NonNull String username); @Override Single<Response<Repo>> getRepo(@NonNull String owner, @NonNull String repo); @Override void setFirstRun(boolean value); @Override boolean getFirstRun(); @Override void setLastUsername(@NonNull String username); @Override String getLastUsername(); @Override APIError convertToError(@NonNull ResponseBody errorBody); }### Answer:
@Test public void getRepoCompletesAndEmits() throws Exception { String owner = TestDataFactory.repoDataFactory.createOwner().login; String repoName = TestDataFactory.repoDataFactory.createRepoName(); Repo repo = TestDataFactory.repoDataFactory.createRepo(); Response<Repo> response = Response.success(repo); stubGithubServiceGetRepo(owner, repoName, Single.just(response)); TestObserver<Response<Repo>> testSubscriber = dataManager.getRepo(owner, repoName).test(); testSubscriber.assertComplete(); testSubscriber.assertValue(response); } |
### Question:
GithubDataManager implements DataManager { @Override public APIError convertToError(@NonNull ResponseBody errorBody) { APIError error; try { error = converter.get().convert(errorBody); } catch (IOException e) { return new APIError(); } return error; } @Inject GithubDataManager(@NonNull GithubService githubService, @NonNull SharedPreferencesHelper sharedPreferencesHelper); @Override Single<Response<List<Repo>>> getRepos(@NonNull String username); @Override Single<Response<Repo>> getRepo(@NonNull String owner, @NonNull String repo); @Override void setFirstRun(boolean value); @Override boolean getFirstRun(); @Override void setLastUsername(@NonNull String username); @Override String getLastUsername(); @Override APIError convertToError(@NonNull ResponseBody errorBody); }### Answer:
@Test public void convertToError() throws Exception { } |
### Question:
DefaultWhenVertx implements WhenVertx { @Override public <T> Promise<T> executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered) { return adapter.toPromise(handler -> vertx.executeBlocking(blockingCodeHandler, ordered, handler)); } @Inject DefaultWhenVertx(Vertx vertx, PromiseAdapter adapter); DefaultWhenVertx(Vertx vertx, When when); @Override Promise<String> deployVerticle(Verticle verticle); @Override Promise<String> deployVerticle(Verticle verticle, DeploymentOptions options); @Override Promise<String> deployVerticle(String name); @Override Promise<String> deployVerticle(String name, DeploymentOptions options); @Override Promise<Void> undeploy(String deploymentID); @Override Promise<T> executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered); }### Answer:
@Test public void testExecuteBlocking() throws Exception { whenVertx.executeBlocking(futureHandler).then(done.onFulfilled, done.onRejected); verify(vertx).<String>executeBlocking(any(), anyBoolean(), stringHandlerCaptor.capture()); assertFalse(done.fulfilled()); stringHandlerCaptor.getValue().handle(Future.succeededFuture()); done.assertFulfilled(); }
@Test public void testExecuteBlocking_Fail() throws Exception { whenVertx.executeBlocking(futureHandler).then(done.onFulfilled, done.onRejected); verify(vertx).<String>executeBlocking(any(), anyBoolean(), stringHandlerCaptor.capture()); assertFalse(done.fulfilled()); stringHandlerCaptor.getValue().handle(Future.failedFuture("")); done.assertRejected(); } |
### Question:
DefaultPromiseAdapter implements PromiseAdapter { @Override public <T> Handler<AsyncResult<T>> toHandler(Resolver<T> resolver) { return result -> { if (result.succeeded()) { resolver.resolve(result.result()); } else { resolver.reject(result.cause()); } }; } @Inject DefaultPromiseAdapter(When when); @Override Promise<T> toPromise(Consumer<Handler<AsyncResult<T>>> consumer); @Override Handler<AsyncResult<T>> toHandler(Resolver<T> resolver); }### Answer:
@Test public void testToHandler() throws Exception { Handler<AsyncResult<String>> handler = adapter.toHandler(resolver); handler.handle(result); verify(resolver).resolve(eq(success)); handler.handle(result); verify(resolver).reject(eq(cause)); } |
### Question:
DefaultPromiseAdapter implements PromiseAdapter { @Override public <T> Promise<T> toPromise(Consumer<Handler<AsyncResult<T>>> consumer) { Deferred<T> d = when.defer(); consumer.accept(toHandler(d)); return d.getPromise(); } @Inject DefaultPromiseAdapter(When when); @Override Promise<T> toPromise(Consumer<Handler<AsyncResult<T>>> consumer); @Override Handler<AsyncResult<T>> toHandler(Resolver<T> resolver); }### Answer:
@Test public void testToPromise() throws Exception { adapter.toPromise(consumer); verify(when).defer(); verify(consumer).accept(any()); }
@Test public void testToPromise1() throws Exception { adapter.toPromise(future); future.complete(); verify(when).defer(); verify(future).setHandler(any()); } |
### Question:
DefaultWhenEventBus implements WhenEventBus { @Override public EventBus getEventBus() { return eventBus; } @Inject DefaultWhenEventBus(Vertx vertx, PromiseAdapter adapter); DefaultWhenEventBus(Vertx vertx, When when); DefaultWhenEventBus(EventBus eventBus, PromiseAdapter adapter); DefaultWhenEventBus(EventBus eventBus, When when); @Override EventBus getEventBus(); @Override Promise<Void> close(); @Override Promise<Message<T>> send(String address, Object message); @Override Promise<Message<T>> send(String address, Object message, DeliveryOptions options); }### Answer:
@Test public void testGetEventBus() throws Exception { assertEquals(eventBus, whenEventBus.getEventBus()); EventBus mock = mock(EventBus.class); whenEventBus = new DefaultWhenEventBus(mock, mock(When.class)); assertEquals(mock, whenEventBus.getEventBus()); } |
### Question:
DefaultWhenEventBus implements WhenEventBus { @Override public Promise<Void> close() { return adapter.toPromise(eventBus::close); } @Inject DefaultWhenEventBus(Vertx vertx, PromiseAdapter adapter); DefaultWhenEventBus(Vertx vertx, When when); DefaultWhenEventBus(EventBus eventBus, PromiseAdapter adapter); DefaultWhenEventBus(EventBus eventBus, When when); @Override EventBus getEventBus(); @Override Promise<Void> close(); @Override Promise<Message<T>> send(String address, Object message); @Override Promise<Message<T>> send(String address, Object message, DeliveryOptions options); }### Answer:
@Test public void testClose_Success() throws Exception { Done<Void> done = new Done<>(); whenEventBus.close().then(done.onFulfilled, done.onRejected); verify(eventBus).close(voidHandlerCaptor.capture()); when(voidResult.succeeded()).thenReturn(true); voidHandlerCaptor.getValue().handle(voidResult); done.assertFulfilled(); }
@Test public void testClose_Failed() throws Exception { Done<Void> done = new Done<>(); whenEventBus.close().then(done.onFulfilled, done.onRejected); verify(eventBus).close(voidHandlerCaptor.capture()); Throwable t = new Throwable(); when(voidResult.cause()).thenReturn(t); voidHandlerCaptor.getValue().handle(voidResult); done.assertRejected(); assertEquals(t, done.getCause()); } |
### Question:
VertxExecutor implements Executor { @Override public void execute(Runnable command) { vertx.runOnContext(aVoid -> command.run()); } @Inject VertxExecutor(Vertx vertx); @Override void execute(Runnable command); }### Answer:
@Test public void testExecute() throws Exception { executor.execute(command); verify(vertx).runOnContext(handlerCaptor.capture()); handlerCaptor.getValue().handle(null); verify(command).run(); } |
### Question:
DefaultWhenVertx implements WhenVertx { @Override public Promise<Void> undeploy(String deploymentID) { return adapter.toPromise(handler -> vertx.undeploy(deploymentID, handler)); } @Inject DefaultWhenVertx(Vertx vertx, PromiseAdapter adapter); DefaultWhenVertx(Vertx vertx, When when); @Override Promise<String> deployVerticle(Verticle verticle); @Override Promise<String> deployVerticle(Verticle verticle, DeploymentOptions options); @Override Promise<String> deployVerticle(String name); @Override Promise<String> deployVerticle(String name, DeploymentOptions options); @Override Promise<Void> undeploy(String deploymentID); @Override Promise<T> executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered); }### Answer:
@Test public void testUndeploy() throws Exception { String deploymentID = "id"; Done<Void> done = new Done<>(); when(voidResult.succeeded()).thenReturn(true); whenVertx.undeploy(deploymentID).then(done.onFulfilled, done.onRejected); verify(vertx).undeploy(eq(deploymentID), voidHandlerCaptor.capture()); voidHandlerCaptor.getValue().handle(voidResult); done.assertFulfilled(); }
@Test public void testUndeploy_Fail() throws Exception { String deploymentID = "id"; Done<Void> done = new Done<>(); whenVertx.undeploy(deploymentID).then(done.onFulfilled, done.onRejected); verify(vertx).undeploy(eq(deploymentID), voidHandlerCaptor.capture()); voidHandlerCaptor.getValue().handle(voidResult); done.assertRejected(); } |
### Question:
KinClient { public @NonNull KinAccount addAccount() throws CreateAccountException { KeyPair account = keyStore.newAccount(); return addKeyPair(account); } KinClient(@NonNull Context context, @NonNull ServiceProvider provider, @NonNull String storeKey); KinClient(@NonNull Context context, @NonNull ServiceProvider provider); @VisibleForTesting KinClient(ServiceProvider serviceProvider, KeyStore keyStore, TransactionSender transactionSender,
AccountActivator accountActivator, AccountInfoRetriever accountInfoRetriever,
BlockchainEventsCreator blockchainEventsCreator, BackupRestore backupRestore); @NonNull KinAccount addAccount(); @NonNull KinAccount importAccount(@NonNull String exportedJson, @NonNull String passphrase); KinAccount getAccount(int index); boolean hasAccount(); @SuppressWarnings("WeakerAccess") int getAccountCount(); void deleteAccount(int index); @SuppressWarnings("WeakerAccess") void clearAllAccounts(); ServiceProvider getServiceProvider(); }### Answer:
@Test public void addAccount_NewAccount() throws Exception { KinAccount kinAccount = kinClient.addAccount(); assertNotNull(kinAccount); assertThat(kinAccount.getPublicAddress(), not(isEmptyOrNullString())); }
@Test public void createAccount_AddAccount() throws Exception { KinAccount kinAccount = kinClient.addAccount(); assertNotNull(kinAccount); assertThat(kinAccount.getPublicAddress(), not(isEmptyOrNullString())); }
@Test public void createAccount_AddMultipleAccount() throws Exception { KinAccount kinAccount = kinClient.addAccount(); KinAccount kinAccount2 = kinClient.addAccount(); assertNotNull(kinAccount); assertNotNull(kinAccount2); assertThat(kinAccount.getPublicAddress(), not(isEmptyOrNullString())); assertThat(kinAccount2.getPublicAddress(), not(isEmptyOrNullString())); assertThat(kinAccount, not(equalTo(kinAccount2))); } |
### Question:
KinClient { public KinAccount getAccount(int index) { if (index >= 0 && kinAccounts.size() > index) { return kinAccounts.get(index); } return null; } KinClient(@NonNull Context context, @NonNull ServiceProvider provider, @NonNull String storeKey); KinClient(@NonNull Context context, @NonNull ServiceProvider provider); @VisibleForTesting KinClient(ServiceProvider serviceProvider, KeyStore keyStore, TransactionSender transactionSender,
AccountActivator accountActivator, AccountInfoRetriever accountInfoRetriever,
BlockchainEventsCreator blockchainEventsCreator, BackupRestore backupRestore); @NonNull KinAccount addAccount(); @NonNull KinAccount importAccount(@NonNull String exportedJson, @NonNull String passphrase); KinAccount getAccount(int index); boolean hasAccount(); @SuppressWarnings("WeakerAccess") int getAccountCount(); void deleteAccount(int index); @SuppressWarnings("WeakerAccess") void clearAllAccounts(); ServiceProvider getServiceProvider(); }### Answer:
@Test public void getAccount_ExistingMultipleAccount() throws Exception { KeyPair account1 = createRandomAccount(); KeyPair account2 = createRandomAccount(); fakeKeyStore = new FakeKeyStore(Arrays.asList(account1, account2)); kinClient = createNewKinClient(); KinAccount expectedAccount2 = kinClient.getAccount(1); KinAccount expectedAccount1 = kinClient.getAccount(0); assertNotNull(expectedAccount1); assertNotNull(expectedAccount2); assertThat(account1.getAccountId(), equalTo(expectedAccount1.getPublicAddress())); assertThat(account2.getAccountId(), equalTo(expectedAccount2.getPublicAddress())); }
@Test public void getAccount_NegativeIndex() throws Exception { createKeyStoreWithRandomAccount(); assertNull(kinClient.getAccount(-1)); }
@Test public void getAccount_EmptyKeyStore_Null() throws Exception { KinAccount kinAccount = kinClient.getAccount(0); assertNull(kinAccount); }
@Test public void getAccount_ExistingAccount_SameAccount() throws Exception { KeyPair account = createKeyStoreWithRandomAccount(); KinAccount kinAccount = kinClient.getAccount(0); assertEquals(account.getAccountId(), kinAccount.getPublicAddress()); } |
### Question:
KinClient { public boolean hasAccount() { return getAccountCount() != 0; } KinClient(@NonNull Context context, @NonNull ServiceProvider provider, @NonNull String storeKey); KinClient(@NonNull Context context, @NonNull ServiceProvider provider); @VisibleForTesting KinClient(ServiceProvider serviceProvider, KeyStore keyStore, TransactionSender transactionSender,
AccountActivator accountActivator, AccountInfoRetriever accountInfoRetriever,
BlockchainEventsCreator blockchainEventsCreator, BackupRestore backupRestore); @NonNull KinAccount addAccount(); @NonNull KinAccount importAccount(@NonNull String exportedJson, @NonNull String passphrase); KinAccount getAccount(int index); boolean hasAccount(); @SuppressWarnings("WeakerAccess") int getAccountCount(); void deleteAccount(int index); @SuppressWarnings("WeakerAccess") void clearAllAccounts(); ServiceProvider getServiceProvider(); }### Answer:
@Test public void hasAccount_EmptyKeyStore_False() throws Exception { assertFalse(kinClient.hasAccount()); }
@Test public void hasAccount_ExistingAccount_True() throws Exception { createKeyStoreWithRandomAccount(); assertTrue(kinClient.hasAccount()); }
@Test public void hasAccount_ExistingMultipleAccounts_True() throws Exception { KeyPair account1 = createRandomAccount(); KeyPair account2 = createRandomAccount(); fakeKeyStore = new FakeKeyStore(Arrays.asList(account1, account2)); kinClient = createNewKinClient(); assertTrue(kinClient.hasAccount()); } |
### Question:
KinClient { public void deleteAccount(int index) throws DeleteAccountException { if (index >= 0 && getAccountCount() > index) { keyStore.deleteAccount(index); KinAccountImpl removedAccount = kinAccounts.remove(index); removedAccount.markAsDeleted(); } } KinClient(@NonNull Context context, @NonNull ServiceProvider provider, @NonNull String storeKey); KinClient(@NonNull Context context, @NonNull ServiceProvider provider); @VisibleForTesting KinClient(ServiceProvider serviceProvider, KeyStore keyStore, TransactionSender transactionSender,
AccountActivator accountActivator, AccountInfoRetriever accountInfoRetriever,
BlockchainEventsCreator blockchainEventsCreator, BackupRestore backupRestore); @NonNull KinAccount addAccount(); @NonNull KinAccount importAccount(@NonNull String exportedJson, @NonNull String passphrase); KinAccount getAccount(int index); boolean hasAccount(); @SuppressWarnings("WeakerAccess") int getAccountCount(); void deleteAccount(int index); @SuppressWarnings("WeakerAccess") void clearAllAccounts(); ServiceProvider getServiceProvider(); }### Answer:
@Test public void deleteAccount() throws Exception { createKeyStoreWithRandomAccount(); assertTrue(kinClient.hasAccount()); kinClient.deleteAccount(0); assertFalse(kinClient.hasAccount()); } |
### Question:
KinClient { @SuppressWarnings("WeakerAccess") public int getAccountCount() { return kinAccounts.size(); } KinClient(@NonNull Context context, @NonNull ServiceProvider provider, @NonNull String storeKey); KinClient(@NonNull Context context, @NonNull ServiceProvider provider); @VisibleForTesting KinClient(ServiceProvider serviceProvider, KeyStore keyStore, TransactionSender transactionSender,
AccountActivator accountActivator, AccountInfoRetriever accountInfoRetriever,
BlockchainEventsCreator blockchainEventsCreator, BackupRestore backupRestore); @NonNull KinAccount addAccount(); @NonNull KinAccount importAccount(@NonNull String exportedJson, @NonNull String passphrase); KinAccount getAccount(int index); boolean hasAccount(); @SuppressWarnings("WeakerAccess") int getAccountCount(); void deleteAccount(int index); @SuppressWarnings("WeakerAccess") void clearAllAccounts(); ServiceProvider getServiceProvider(); }### Answer:
@Test public void getAccountCount() throws Exception { KeyPair account1 = createRandomAccount(); KeyPair account2 = createRandomAccount(); KeyPair account3 = createRandomAccount(); fakeKeyStore = new FakeKeyStore(Arrays.asList(account1, account2, account3)); kinClient = createNewKinClient(); assertThat(kinClient.getAccountCount(), equalTo(3)); kinClient.deleteAccount(2); kinClient.deleteAccount(1); assertThat(kinClient.getAccountCount(), equalTo(1)); kinClient.addAccount(); assertThat(kinClient.getAccountCount(), equalTo(2)); kinClient.deleteAccount(1); kinClient.deleteAccount(0); assertThat(kinClient.getAccountCount(), equalTo(0)); } |
### Question:
KinClient { @SuppressWarnings("WeakerAccess") public void clearAllAccounts() { keyStore.clearAllAccounts(); for (KinAccountImpl kinAccount : kinAccounts) { kinAccount.markAsDeleted(); } kinAccounts.clear(); } KinClient(@NonNull Context context, @NonNull ServiceProvider provider, @NonNull String storeKey); KinClient(@NonNull Context context, @NonNull ServiceProvider provider); @VisibleForTesting KinClient(ServiceProvider serviceProvider, KeyStore keyStore, TransactionSender transactionSender,
AccountActivator accountActivator, AccountInfoRetriever accountInfoRetriever,
BlockchainEventsCreator blockchainEventsCreator, BackupRestore backupRestore); @NonNull KinAccount addAccount(); @NonNull KinAccount importAccount(@NonNull String exportedJson, @NonNull String passphrase); KinAccount getAccount(int index); boolean hasAccount(); @SuppressWarnings("WeakerAccess") int getAccountCount(); void deleteAccount(int index); @SuppressWarnings("WeakerAccess") void clearAllAccounts(); ServiceProvider getServiceProvider(); }### Answer:
@Test public void clearAllAccounts() { KeyPair account1 = createRandomAccount(); KeyPair account2 = createRandomAccount(); KeyPair account3 = createRandomAccount(); fakeKeyStore = new FakeKeyStore(Arrays.asList(account1, account2, account3)); kinClient = createNewKinClient(); kinClient.clearAllAccounts(); assertThat(kinClient.getAccountCount(), equalTo(0)); } |
### Question:
KinClient { public ServiceProvider getServiceProvider() { return serviceProvider; } KinClient(@NonNull Context context, @NonNull ServiceProvider provider, @NonNull String storeKey); KinClient(@NonNull Context context, @NonNull ServiceProvider provider); @VisibleForTesting KinClient(ServiceProvider serviceProvider, KeyStore keyStore, TransactionSender transactionSender,
AccountActivator accountActivator, AccountInfoRetriever accountInfoRetriever,
BlockchainEventsCreator blockchainEventsCreator, BackupRestore backupRestore); @NonNull KinAccount addAccount(); @NonNull KinAccount importAccount(@NonNull String exportedJson, @NonNull String passphrase); KinAccount getAccount(int index); boolean hasAccount(); @SuppressWarnings("WeakerAccess") int getAccountCount(); void deleteAccount(int index); @SuppressWarnings("WeakerAccess") void clearAllAccounts(); ServiceProvider getServiceProvider(); }### Answer:
@Test public void getServiceProvider() throws Exception { String url = "My awesome Horizon server"; ServiceProvider serviceProvider = new ServiceProvider(url, ServiceProvider.NETWORK_ID_TEST); kinClient = new KinClient(serviceProvider, fakeKeyStore, mockTransactionSender, mockAccountActivator, mockAccountInfoRetriever, mockBlockchainEventsCreator, new FakeBackupRestore()); ServiceProvider actualServiceProvider = kinClient.getServiceProvider(); assertNotNull(actualServiceProvider); assertFalse(actualServiceProvider.isMainNet()); assertEquals(url, actualServiceProvider.getProviderUrl()); assertEquals(ServiceProvider.NETWORK_ID_TEST, actualServiceProvider.getNetworkId()); } |
### Question:
KinAccountImpl extends AbstractKinAccount { @Override public String getPublicAddress() { if (!isDeleted) { return account.getAccountId(); } return null; } KinAccountImpl(KeyPair account, BackupRestore backupRestore, TransactionSender transactionSender,
AccountActivator accountActivator,
AccountInfoRetriever accountInfoRetriever, BlockchainEventsCreator blockchainEventsCreator); @Override String getPublicAddress(); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount,
@Nullable String memo); @NonNull @Override TransactionId sendBurnAccountTransactionSync(@NonNull String publicAddress); @Override boolean isAccountBurnedSync(); @NonNull @Override Balance getBalanceSync(); @Override void activateSync(); @Override int getStatusSync(); @Override BlockchainEvents blockchainEvents(); @Override String export(@NonNull String passphrase); }### Answer:
@Test public void getPublicAddress_ExistingAccount() throws Exception { initWithRandomAccount(); assertEquals(expectedRandomAccount.getAccountId(), kinAccount.getPublicAddress()); } |
### Question:
KinAccountImpl extends AbstractKinAccount { @NonNull @Override public Balance getBalanceSync() throws OperationFailedException { checkValidAccount(); return accountInfoRetriever.getBalance(account.getAccountId()); } KinAccountImpl(KeyPair account, BackupRestore backupRestore, TransactionSender transactionSender,
AccountActivator accountActivator,
AccountInfoRetriever accountInfoRetriever, BlockchainEventsCreator blockchainEventsCreator); @Override String getPublicAddress(); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount,
@Nullable String memo); @NonNull @Override TransactionId sendBurnAccountTransactionSync(@NonNull String publicAddress); @Override boolean isAccountBurnedSync(); @NonNull @Override Balance getBalanceSync(); @Override void activateSync(); @Override int getStatusSync(); @Override BlockchainEvents blockchainEvents(); @Override String export(@NonNull String passphrase); }### Answer:
@Test public void getBalanceSync() throws Exception { initWithRandomAccount(); Balance expectedBalance = new BalanceImpl(new BigDecimal("11.0")); when(mockAccountInfoRetriever.getBalance(anyString())).thenReturn(expectedBalance); Balance balance = kinAccount.getBalanceSync(); assertEquals(expectedBalance, balance); verify(mockAccountInfoRetriever).getBalance(expectedRandomAccount.getAccountId()); } |
### Question:
KinAccountImpl extends AbstractKinAccount { @Override public int getStatusSync() throws OperationFailedException { checkValidAccount(); return accountInfoRetriever.getStatus(account.getAccountId()); } KinAccountImpl(KeyPair account, BackupRestore backupRestore, TransactionSender transactionSender,
AccountActivator accountActivator,
AccountInfoRetriever accountInfoRetriever, BlockchainEventsCreator blockchainEventsCreator); @Override String getPublicAddress(); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount,
@Nullable String memo); @NonNull @Override TransactionId sendBurnAccountTransactionSync(@NonNull String publicAddress); @Override boolean isAccountBurnedSync(); @NonNull @Override Balance getBalanceSync(); @Override void activateSync(); @Override int getStatusSync(); @Override BlockchainEvents blockchainEvents(); @Override String export(@NonNull String passphrase); }### Answer:
@Test public void getStatusSync() throws Exception { initWithRandomAccount(); when(mockAccountInfoRetriever.getStatus(anyString())).thenReturn(AccountStatus.ACTIVATED); int status = kinAccount.getStatusSync(); assertEquals(AccountStatus.ACTIVATED, status); verify(mockAccountInfoRetriever).getStatus(expectedRandomAccount.getAccountId()); } |
### Question:
KinAccountImpl extends AbstractKinAccount { @Override public void activateSync() throws OperationFailedException { checkValidAccount(); accountActivator.activate(account); } KinAccountImpl(KeyPair account, BackupRestore backupRestore, TransactionSender transactionSender,
AccountActivator accountActivator,
AccountInfoRetriever accountInfoRetriever, BlockchainEventsCreator blockchainEventsCreator); @Override String getPublicAddress(); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount,
@Nullable String memo); @NonNull @Override TransactionId sendBurnAccountTransactionSync(@NonNull String publicAddress); @Override boolean isAccountBurnedSync(); @NonNull @Override Balance getBalanceSync(); @Override void activateSync(); @Override int getStatusSync(); @Override BlockchainEvents blockchainEvents(); @Override String export(@NonNull String passphrase); }### Answer:
@Test public void activateSync() throws Exception { initWithRandomAccount(); kinAccount.activateSync(); verify(mockAccountActivator).activate(expectedRandomAccount); } |
### Question:
KinAccountImpl extends AbstractKinAccount { @Override public BlockchainEvents blockchainEvents() { return blockchainEvents; } KinAccountImpl(KeyPair account, BackupRestore backupRestore, TransactionSender transactionSender,
AccountActivator accountActivator,
AccountInfoRetriever accountInfoRetriever, BlockchainEventsCreator blockchainEventsCreator); @Override String getPublicAddress(); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount); @NonNull @Override TransactionId sendTransactionSync(@NonNull String publicAddress, @NonNull BigDecimal amount,
@Nullable String memo); @NonNull @Override TransactionId sendBurnAccountTransactionSync(@NonNull String publicAddress); @Override boolean isAccountBurnedSync(); @NonNull @Override Balance getBalanceSync(); @Override void activateSync(); @Override int getStatusSync(); @Override BlockchainEvents blockchainEvents(); @Override String export(@NonNull String passphrase); }### Answer:
@Test public void createBlockchainEvents() throws Exception { initWithRandomAccount(); kinAccount.blockchainEvents(); verify(mockBlockchainEventsCreator).create(expectedRandomAccount.getAccountId()); } |
### Question:
KeyStoreImpl implements KeyStore { @Override public KeyPair newAccount() throws CreateAccountException { return addKeyPairToStorage(KeyPair.random()); } KeyStoreImpl(@NonNull Store store, @NonNull BackupRestore backupRestore); @NonNull @Override List<KeyPair> loadAccounts(); @Override void deleteAccount(int index); @Override KeyPair newAccount(); @Override KeyPair importAccount(@NonNull String json, @NonNull String passphrase); @Override void clearAllAccounts(); }### Answer:
@Test public void newAccount() throws Exception { KeyStoreImpl keyStore = new KeyStoreImpl(new FakeStore(), new FakeBackupRestore()); KeyPair account = keyStore.newAccount(); assertNotNull(account); assertNotNull(account.getPublicKey()); assertNotNull(account.getSecretSeed()); }
@Test public void newAccount_JsonException_CreateAccountException() throws Exception { Store mockStore = mock(Store.class); when(mockStore.getString(anyString())) .thenReturn(KeyStoreImpl.ENCRYPTION_VERSION_NAME) .thenReturn("not a real json"); KeyStoreImpl keyStore = new KeyStoreImpl(mockStore, new FakeBackupRestore()); expectedEx.expect(CreateAccountException.class); expectedEx.expectCause(isA(JSONException.class)); keyStore.newAccount(); } |
### Question:
KeyStoreImpl implements KeyStore { @Override public void deleteAccount(int index) throws DeleteAccountException { JSONObject json = new JSONObject(); try { JSONArray jsonArray = loadJsonArray(); if (jsonArray != null) { JSONArray newJsonArray = new JSONArray(); for (int i = 0; i < jsonArray.length(); i++) { if (i != index) { newJsonArray.put(jsonArray.get(i)); } } json.put(JSON_KEY_ACCOUNTS_ARRAY, newJsonArray); } } catch (JSONException e) { throw new DeleteAccountException(e); } store.saveString(STORE_KEY_ACCOUNTS, json.toString()); } KeyStoreImpl(@NonNull Store store, @NonNull BackupRestore backupRestore); @NonNull @Override List<KeyPair> loadAccounts(); @Override void deleteAccount(int index); @Override KeyPair newAccount(); @Override KeyPair importAccount(@NonNull String json, @NonNull String passphrase); @Override void clearAllAccounts(); }### Answer:
@Test public void deleteAccount() throws Exception { KeyStoreImpl keyStore = new KeyStoreImpl(new FakeStore(), new FakeBackupRestore()); KeyPair account1 = keyStore.newAccount(); keyStore.newAccount(); keyStore.deleteAccount(1); List<KeyPair> accounts = keyStore.loadAccounts(); assertEquals(1, accounts.size()); assertEquals(String.valueOf(account1.getSecretSeed()), String.valueOf(accounts.get(0).getSecretSeed())); } |
### Question:
KeyStoreImpl implements KeyStore { @Override public void clearAllAccounts() { store.clear(STORE_KEY_ACCOUNTS); } KeyStoreImpl(@NonNull Store store, @NonNull BackupRestore backupRestore); @NonNull @Override List<KeyPair> loadAccounts(); @Override void deleteAccount(int index); @Override KeyPair newAccount(); @Override KeyPair importAccount(@NonNull String json, @NonNull String passphrase); @Override void clearAllAccounts(); }### Answer:
@Test public void clearAllAccounts() throws Exception { KeyStoreImpl keyStore = new KeyStoreImpl(new FakeStore(), new FakeBackupRestore()); keyStore.newAccount(); keyStore.newAccount(); keyStore.clearAllAccounts(); assertTrue(keyStore.loadAccounts().isEmpty()); } |
### Question:
PulsarClientLRUCache extends LRUMap<K, V> { @Override public void clear() { this.values().parallelStream().forEach(closable -> { releaseResources(closable); }); super.clear(); } PulsarClientLRUCache(int maxSize); PulsarClientLRUCache(int maxSize, float loadFactor, boolean scanUntilRemovable); @Override void clear(); }### Answer:
@Test public void clearTest() throws PulsarClientException { PulsarClientLRUCache<String, Producer> cache = new PulsarClientLRUCache<String, Producer>(26); for (Character i='A'; i<='Z'; i++) { cache.put(i.toString(), mockedPulsarProducer); } assertEquals(26, cache.size()); cache.clear(); verify(mockedPulsarProducer, times(26)).close(); assertEquals(0, cache.size()); } |
### Question:
TeleportPlayerJob extends BukkitRunnable { boolean hasPlayerMoved() { final double MAX_MOVE_TOLERANCE = 1.5; return distance3D(player.getLocation(), originalLocation) > MAX_MOVE_TOLERANCE; } TeleportPlayerJob(Player player, Location location); @Override void run(); }### Answer:
@Test public void testPlayerMove_noMovement_false() { when(player.getLocation()).thenReturn(new Location(world, 0, 0, 0)); assertFalse(job.hasPlayerMoved()); }
@Test public void testPlayerMove_smallMovement_false() { when(player.getLocation()).thenReturn(new Location(world, 0.5, 0.5, 0.5)); assertFalse(job.hasPlayerMoved()); }
@Test public void testPlayerMove_largeMovement_true() { when(player.getLocation()).thenReturn(new Location(world, 5, 1, 3)); assertTrue(job.hasPlayerMoved()); } |
### Question:
TeleportPlayerJob extends BukkitRunnable { boolean hasPlayerTakenDamage() { final double MAX_DAMAGE_TOLERANCE = 2; return Math.abs(originalHealth - player.getHealth()) > MAX_DAMAGE_TOLERANCE; } TeleportPlayerJob(Player player, Location location); @Override void run(); }### Answer:
@Test public void testPlayerDamage_noDamage_false() { when(player.getHealth()).thenReturn(20.0); assertFalse(job.hasPlayerTakenDamage()); }
@Test public void testPlayerDamage_slightDamage_false() { when(player.getHealth()).thenReturn(19.5); assertFalse(job.hasPlayerTakenDamage()); }
@Test public void testPlayerDamage_largeDamage_true() { when(player.getHealth()).thenReturn(14.0); assertTrue(job.hasPlayerTakenDamage()); } |
### Question:
PullRequestChainParser { public void parsePullRequestChains(PullRequests<? extends PullRequest> pullRequests) { Map<String, PullRequest> pullRequestsMap = Maps.newHashMap(); for (PullRequest pullRequest : pullRequests.getPullRequests()) { pullRequestsMap.put(pullRequest.getSource().getBranch().getName(), pullRequest); } for (PullRequest pullRequest : pullRequestsMap.values()) { List<String> chain = Lists.newArrayList(); PullRequestTarget destination = pullRequest.getDestination(); String branchName = destination.getBranch().getName(); chain.add(branchName); do { PullRequest destinationPullRequest = pullRequestsMap.get(branchName); if (destinationPullRequest != null) { branchName = destinationPullRequest.getDestination().getBranch().getName(); chain.add(branchName); } else { break; } } while (pullRequestsMap.containsKey(branchName)); pullRequest.setBranchChain(chain); } } void parsePullRequestChains(PullRequests<? extends PullRequest> pullRequests); }### Answer:
@Test public void parseChain_parseCorrectly() throws Exception { BitbucketPullRequest firstPr = createPr("a", "master"); BitbucketPullRequest secondPr = createPr("b", "a"); BitbucketPullRequests pullRequests = new BitbucketPullRequests(); pullRequests.setPullRequests(asList(secondPr, firstPr)); parser.parsePullRequestChains(pullRequests); assertEquals(1, firstPr.getBranchChain().size()); assertEquals(2, secondPr.getBranchChain().size()); assertTrue(firstPr.getBranchChain().contains("master")); assertTrue(secondPr.getBranchChain().containsAll(asList("a", "master"))); } |
### Question:
SecretEncoder { @Nonnull public Single<byte[]> decodeSecret(@Nonnull final BigInteger encodedSecret) { checkNotNull(encodedSecret, "\'encodedSecret\' must not be null."); return Single.fromCallable(() -> { final byte[] secretWithLeading1 = encodedSecret.toByteArray(); final byte[] secretWithoutLeading1 = new byte[secretWithLeading1.length - 1]; System.arraycopy(secretWithLeading1, 1, secretWithoutLeading1, 0, secretWithoutLeading1.length); return secretWithoutLeading1; }); } @Nonnull Single<BigInteger> encodeSecret(@Nonnull final byte[] secret); @Nonnull Single<byte[]> decodeSecret(@Nonnull final BigInteger encodedSecret); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testDecodeSecret_nullEncodedSecret() { secretEncoder.decodeSecret(null); } |
### Question:
PersistenceOperations { @Nonnull public Single<File> defineNewRecoveredSecretFile(@Nonnull final File directory) { return Single.just(new File(directory, "recovered-secret")); } PersistenceOperations(
@Nonnull final ShareSerialiser shareSerialiser,
@Nonnull final RecoverySchemeSerialiser recoverySchemeSerialiser,
@Nonnull final RxFiles rxFiles); @Nonnull Single<Share> loadShareFromFile(@Nonnull final File file); @Nonnull Single<Boolean> fileContainsShare(@Nonnull final File file); @Nonnull Single<RecoveryScheme> loadRecoverySchemeFromFile(@Nonnull final File file); @Nonnull Single<Boolean> fileContainsRecoveryScheme(@Nonnull final File file); @Nonnull Single<File> defineNewRecoveredSecretFile(@Nonnull final File directory); @Nonnull Single<Boolean> directoryContainsRecoveredSecretFile(@Nonnull final File directory); }### Answer:
@Test public void testDefineNewRecoveredShareFile_nullDirectory() { persistenceOperations.defineNewRecoveredSecretFile(null); }
@Test public void testDefineNewRecoveredShareFile_nonNullDirectory() { final File directory = new File("test"); persistenceOperations .defineNewRecoveredSecretFile(directory) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue( file -> file.getParentFile().equals(directory) && file.getName().equals("recovered-secret")); } |
### Question:
RxFiles { @Nonnull public Completable createDirectory(@Nonnull final File directory) { checkNotNull(directory, "\'directory\' must not be null."); return Completable.fromAction(() -> FileUtils.forceMkdir(directory)); } @Nonnull Completable createDirectory(@Nonnull final File directory); @Nonnull Completable createNewFile(@Nonnull final File file); @Nonnull Completable delete(@Nonnull final File file); @Nonnull Observable<File> getFilesInDirectory(@Nonnull final File directory); @Nonnull Single<String> readStringFromFile(@Nonnull final File file, @Nonnull final Charset charset); @Nonnull Completable writeStringToFile(
@Nonnull final String data,
@Nonnull final File file,
@Nonnull final Charset charset); @Nonnull Single<byte[]> readBytesFromFile(@Nonnull final File file); @Nonnull Completable writeBytesToFile(@Nonnull final byte[] data, @Nonnull final File file); @Nonnull Single<Boolean> exists(@Nonnull final File file); @Nonnull Single<Long> sizeInBytes(@Nonnull final File file); @Nonnull Single<Boolean> isFile(@Nonnull final File file); @Nonnull Single<Boolean> isDirectory(@Nonnull final File directory); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testCreateDirectory_nullDirectory() { rxFiles.createDirectory(null); }
@Test public void testCreateDirectory_directoryAlreadyExistsAsADirectory() throws IOException { final File directory = new File(testDirectory, "test"); FileUtils.forceMkdir(directory); rxFiles .createDirectory(directory) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertComplete(); } |
### Question:
RxFiles { @Nonnull public Completable delete(@Nonnull final File file) { checkNotNull(file, "\'file\' must not be null."); return exists(file) .flatMapCompletable(exists -> exists ? Completable.fromAction(() -> FileUtils.forceDelete(file)) : Completable.complete()); } @Nonnull Completable createDirectory(@Nonnull final File directory); @Nonnull Completable createNewFile(@Nonnull final File file); @Nonnull Completable delete(@Nonnull final File file); @Nonnull Observable<File> getFilesInDirectory(@Nonnull final File directory); @Nonnull Single<String> readStringFromFile(@Nonnull final File file, @Nonnull final Charset charset); @Nonnull Completable writeStringToFile(
@Nonnull final String data,
@Nonnull final File file,
@Nonnull final Charset charset); @Nonnull Single<byte[]> readBytesFromFile(@Nonnull final File file); @Nonnull Completable writeBytesToFile(@Nonnull final byte[] data, @Nonnull final File file); @Nonnull Single<Boolean> exists(@Nonnull final File file); @Nonnull Single<Long> sizeInBytes(@Nonnull final File file); @Nonnull Single<Boolean> isFile(@Nonnull final File file); @Nonnull Single<Boolean> isDirectory(@Nonnull final File directory); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testDelete_nullFile() { rxFiles.delete(null); }
@Test public void testDelete_fileWhichDoesNotExist() { final File file = new File(testDirectory, "test.txt"); rxFiles .delete(file) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertComplete(); }
@Test public void testDelete_directoryWhichDoesNotExist() { final File directory = new File(testDirectory, "test"); rxFiles .delete(directory) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertComplete(); } |
### Question:
RxFiles { @Nonnull public Single<byte[]> readBytesFromFile(@Nonnull final File file) { checkNotNull(file, "\'file\' must not be null."); return Single.fromCallable(() -> FileUtils.readFileToByteArray(file)); } @Nonnull Completable createDirectory(@Nonnull final File directory); @Nonnull Completable createNewFile(@Nonnull final File file); @Nonnull Completable delete(@Nonnull final File file); @Nonnull Observable<File> getFilesInDirectory(@Nonnull final File directory); @Nonnull Single<String> readStringFromFile(@Nonnull final File file, @Nonnull final Charset charset); @Nonnull Completable writeStringToFile(
@Nonnull final String data,
@Nonnull final File file,
@Nonnull final Charset charset); @Nonnull Single<byte[]> readBytesFromFile(@Nonnull final File file); @Nonnull Completable writeBytesToFile(@Nonnull final byte[] data, @Nonnull final File file); @Nonnull Single<Boolean> exists(@Nonnull final File file); @Nonnull Single<Long> sizeInBytes(@Nonnull final File file); @Nonnull Single<Boolean> isFile(@Nonnull final File file); @Nonnull Single<Boolean> isDirectory(@Nonnull final File directory); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testReadBytesFromFile_nullFile() { rxFiles.readBytesFromFile(null); }
@Test public void testReadBytesFromFile_fileDoesNotExist() { final File file = new File(testDirectory, "test.txt"); rxFiles .readBytesFromFile(file) .test() .awaitDone(200, MILLISECONDS) .assertError(IOException.class) .assertNoValues(); }
@Test public void testReadBytesFromFile_fileIsActuallyADirectory() throws IOException { final File file = new File(testDirectory, "test"); FileUtils.forceMkdir(file); rxFiles .readBytesFromFile(file) .test() .awaitDone(200, MILLISECONDS) .assertError(IOException.class) .assertNoValues(); } |
### Question:
RxFiles { @Nonnull public Single<Long> sizeInBytes(@Nonnull final File file) { checkNotNull(file, "\'file\' must not be null."); return exists(file).flatMap(exists -> exists ? Single.fromCallable(file::length) : Single.error(new IOException(format("File \'%1$s\' does not exist.", file)))); } @Nonnull Completable createDirectory(@Nonnull final File directory); @Nonnull Completable createNewFile(@Nonnull final File file); @Nonnull Completable delete(@Nonnull final File file); @Nonnull Observable<File> getFilesInDirectory(@Nonnull final File directory); @Nonnull Single<String> readStringFromFile(@Nonnull final File file, @Nonnull final Charset charset); @Nonnull Completable writeStringToFile(
@Nonnull final String data,
@Nonnull final File file,
@Nonnull final Charset charset); @Nonnull Single<byte[]> readBytesFromFile(@Nonnull final File file); @Nonnull Completable writeBytesToFile(@Nonnull final byte[] data, @Nonnull final File file); @Nonnull Single<Boolean> exists(@Nonnull final File file); @Nonnull Single<Long> sizeInBytes(@Nonnull final File file); @Nonnull Single<Boolean> isFile(@Nonnull final File file); @Nonnull Single<Boolean> isDirectory(@Nonnull final File directory); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSizeInBytes_nullFile() { rxFiles.sizeInBytes(null); }
@Test public void testSizeInBytes_nullFileThatDoesNotExist() { final File file = new File(testDirectory, "test"); rxFiles .sizeInBytes(file) .test() .awaitDone(200, MILLISECONDS) .assertError(IOException.class) .assertNoValues(); } |
### Question:
Pair { @Nonnull public static <K, V> Pair<K, V> create(@Nonnull K key, @Nonnull V value) { return new AutoValue_Pair<>(key, value); } @Nonnull abstract K getKey(); @Nonnull abstract V getValue(); @Nonnull static Pair<K, V> create(@Nonnull K key, @Nonnull V value); }### Answer:
@Test(expected = NullPointerException.class) public void testInstantiate_nullKey() { Pair.create(null, 123456); }
@Test(expected = NullPointerException.class) public void testInstantiate_nullValue() { Pair.create("test", null); } |
### Question:
SecretEncoder { @Nonnull public Single<BigInteger> encodeSecret(@Nonnull final byte[] secret) { checkNotNull(secret, "\'secret\' must not be null."); return Single.fromCallable(() -> { final byte[] secretWithLeading1 = new byte[secret.length + 1]; secretWithLeading1[0] = 1; System.arraycopy(secret, 0, secretWithLeading1, 1, secret.length); return new BigInteger(secretWithLeading1); }); } @Nonnull Single<BigInteger> encodeSecret(@Nonnull final byte[] secret); @Nonnull Single<byte[]> decodeSecret(@Nonnull final BigInteger encodedSecret); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testEncodeSecret_nullSecret() { secretEncoder.encodeSecret(null); } |
### Question:
Share { @Nonnull public static Builder builder() { return new $AutoValue_Share.Builder(); } @SerializedName("index") abstract BigInteger getIndex(); @SerializedName("value") abstract BigInteger getValue(); @Nonnull static Builder builder(); @Nonnull static TypeAdapter<Share> typeAdapter(@Nonnull final Gson gson); }### Answer:
@Test(expected = IllegalStateException.class) public void testInstantiation_indexNeverSet() { Share .builder() .setValue(0) .build(); }
@Test(expected = IllegalStateException.class) public void testInstantiation_valueNeverSet() { Share .builder() .setIndex(1) .build(); }
@Test(expected = IllegalStateException.class) public void testInstantiation_indexLessThan1() { Share.builder() .setIndex(0) .setValue(0) .build(); }
@Test public void testInstantiation_indexEqualTo1() { Share .builder() .setIndex(1) .setValue(0) .build(); }
@Test public void testInstantiation_indexGreaterThan1() { Share .builder() .setIndex(2) .setValue(0) .build(); }
@Test(expected = NullPointerException.class) public void testInstantiation_nullIndex() { Share .builder() .setIndex(null) .setValue(0) .build(); }
@Test public void testInstantiation_negativeValue() { Share .builder() .setIndex(1) .setValue(-1) .build(); }
@Test public void testInstantiation_zeroValue() { Share .builder() .setIndex(1) .setValue(0) .build(); }
@Test public void testInstantiation_positiveValue() { Share .builder() .setIndex(1) .setValue(1) .build(); }
@Test(expected = NullPointerException.class) public void testInstantiation_nullValue() { Share .builder() .setIndex(1) .setValue(null) .build(); } |
### Question:
Shamir { @Nonnull public static Shamir create(@Nonnull final SecureRandom random) { return new Shamir(random); } Shamir(@Nonnull final SecureRandom random); @Nonnull static Shamir create(@Nonnull final SecureRandom random); @Nonnull Set<Share> createShares(@Nonnull final BigInteger secret, @Nonnull final CreationScheme creationScheme); @Nonnull BigInteger recoverSecret(@Nonnull final Set<Share> shares, @Nonnull final RecoveryScheme recoveryScheme); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInstantiateStatically_nullRandom() { Shamir.create(null); }
@Test public void testInstantiateStatically_nonNullRandom() { Shamir.create(new SecureRandom()); } |
### Question:
Shamir { @Nonnull public Set<Share> createShares(@Nonnull final BigInteger secret, @Nonnull final CreationScheme creationScheme) { return rxShamir .createShares(secret, creationScheme) .collectInto(new HashSet<Share>(), Set::add) .blockingGet(); } Shamir(@Nonnull final SecureRandom random); @Nonnull static Shamir create(@Nonnull final SecureRandom random); @Nonnull Set<Share> createShares(@Nonnull final BigInteger secret, @Nonnull final CreationScheme creationScheme); @Nonnull BigInteger recoverSecret(@Nonnull final Set<Share> shares, @Nonnull final RecoveryScheme recoveryScheme); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testCreateShares_nullSecret() { final CreationScheme creationScheme = CreationScheme .builder() .setRequiredShareCount(2) .setTotalShareCount(2) .setPrime(7) .build(); shamir.createShares(null, creationScheme); }
@Test(expected = IllegalArgumentException.class) public void testCreateShares_nullCreationScheme() { shamir.createShares(ONE, null); }
@Test public void testCreateShares_secretLessThanPrime() { final CreationScheme creationScheme = CreationScheme .builder() .setRequiredShareCount(2) .setTotalShareCount(3) .setPrime(7) .build(); shamir.createShares(FIVE, creationScheme); }
@Test(expected = IllegalStateException.class) public void testCreateShares_secretEqualToPrime() { final CreationScheme creationScheme = CreationScheme .builder() .setRequiredShareCount(2) .setTotalShareCount(3) .setPrime(5) .build(); shamir.createShares(FIVE, creationScheme); }
@Test(expected = IllegalStateException.class) public void testCreateShares_secretGreaterThanPrime() { final CreationScheme creationScheme = CreationScheme .builder() .setRequiredShareCount(2) .setTotalShareCount(3) .setPrime(5) .build(); shamir.createShares(SEVEN, creationScheme); } |
### Question:
RxShamir { @Nonnull public static RxShamir create(@Nonnull final SecureRandom random) { return new RxShamir(random); } RxShamir(@Nonnull final SecureRandom random); @Nonnull static RxShamir create(@Nonnull final SecureRandom random); @Nonnull Observable<Share> createShares(
@Nonnull final BigInteger secret,
@Nonnull final CreationScheme creationScheme); @Nonnull Single<BigInteger> recoverSecret(
@Nonnull final Set<Share> shares,
@Nonnull final RecoveryScheme recoveryScheme); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInstantiateStatically_nullRandom() { RxShamir.create(null); }
@Test public void testInstantiateStatically_nonNullRandom() { RxShamir.create(new SecureRandom()); } |
### Question:
CreationPresenter { @Nonnull public Completable stopPresenting() { return Completable .create(emitter -> { synchronized (startStopPresentingLock) { if (currentlyPresenting.compareAndSet(true, false)) { for (final Disposable disposable : disposables) { disposable.dispose(); } disposables.clear(); } emitter.onComplete(); } }); } CreationPresenter(
@Nonnull final CreationView view,
@Nonnull final Scheduler presentationScheduler,
@Nonnull final Scheduler viewScheduler,
@Nonnull final RxShamir rxShamir,
@Nonnull final CryptoConstants cryptoConstants,
@Nonnull final SecretEncoder secretEncoder,
@Nonnull final PersistenceOperations persistenceOperations,
@Nonnull final RxFiles rxFiles); @Nonnull Completable startPresenting(); @Nonnull Completable stopPresenting(); }### Answer:
@Test public void testStopPresenting_calledBeforeStarting() { presenter.stopPresenting().blockingGet(); verify(mockView, never()).disableCreateSharesRequests(); verifyNoFilesystemInteractions(); } |
### Question:
PersistenceOperations { @Nonnull public Single<File> defineNewShareFile(@Nonnull final Share share, @Nonnull final File directory) { checkNotNull(share, "\'share\' must not be null."); checkNotNull(directory, "\'directory\' must not be null."); return Single.just(new File(directory, format("share-%1$s", share.getIndex()))); } PersistenceOperations(
@Nonnull final ShareSerialiser shareSerialiser,
@Nonnull final RecoverySchemeSerialiser recoverySchemeSerialiser,
@Nonnull final RxFiles rxFiles); @Nonnull Completable saveShareToFile(@Nonnull final Share share, @Nonnull final File file); @Nonnull Completable saveRecoverySchemeToFile(@Nonnull final RecoveryScheme recoveryScheme, @Nonnull final File file); @Nonnull Single<File> defineNewShareFile(@Nonnull final Share share, @Nonnull final File directory); @Nonnull Single<File> defineNewRecoverySchemeFile(@Nonnull final File directory); @Nonnull Single<Boolean> directoryContainsShareFiles(@Nonnull final File directory); @Nonnull Single<Boolean> directoryContainsRecoverySchemeFiles(@Nonnull final File directory); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testDefineNewShareFile_nullShare() { persistenceOperations.defineNewShareFile(null, new File("")); }
@Test(expected = IllegalArgumentException.class) public void testDefineNewShareFile_nullDirectory() { persistenceOperations.defineNewShareFile(mock(Share.class), null); }
@Test public void testDefineNewShareFile_nonNullValues() { final Share share = Share .builder() .setIndex(20) .setValue(1) .build(); final File directory = new File("test"); persistenceOperations .defineNewShareFile(share, directory) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(file -> file.getParentFile().equals(directory) && file.getName().equals("share-20")); } |
### Question:
PersistenceOperations { @Nonnull public Single<File> defineNewRecoverySchemeFile(@Nonnull final File directory) { checkNotNull(directory, "\'directory\' must not be null."); return Single.just(new File(directory, "recovery-scheme")); } PersistenceOperations(
@Nonnull final ShareSerialiser shareSerialiser,
@Nonnull final RecoverySchemeSerialiser recoverySchemeSerialiser,
@Nonnull final RxFiles rxFiles); @Nonnull Completable saveShareToFile(@Nonnull final Share share, @Nonnull final File file); @Nonnull Completable saveRecoverySchemeToFile(@Nonnull final RecoveryScheme recoveryScheme, @Nonnull final File file); @Nonnull Single<File> defineNewShareFile(@Nonnull final Share share, @Nonnull final File directory); @Nonnull Single<File> defineNewRecoverySchemeFile(@Nonnull final File directory); @Nonnull Single<Boolean> directoryContainsShareFiles(@Nonnull final File directory); @Nonnull Single<Boolean> directoryContainsRecoverySchemeFiles(@Nonnull final File directory); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testDefineNewRecoverySchemeFile_nullDirectory() { persistenceOperations.defineNewRecoverySchemeFile(null); }
@Test public void testDefineNewRecoveryScheme_nonNullDirectory() { final File directory = new File("test"); persistenceOperations .defineNewRecoverySchemeFile(directory) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(file -> file.getParentFile().equals(directory) && file.getName().equals("recovery-scheme")); } |
### Question:
JsonRecoverySchemeSerialiser implements RecoverySchemeSerialiser { @Override @Nonnull public Single<String> serialise(@Nonnull final RecoveryScheme scheme) { checkNotNull(scheme, "\'scheme\' must not be null."); return Single.fromCallable(() -> { final String primeBase64Encoded = Base64.getEncoder().encodeToString(scheme.getPrime().toByteArray()); final JsonObject json = new JsonObject(); json.addProperty("requiredShareCount", scheme.getRequiredShareCount()); json.addProperty("prime", primeBase64Encoded); return json.toString(); }); } @Override @Nonnull Single<String> serialise(@Nonnull final RecoveryScheme scheme); @Override @Nonnull Single<RecoveryScheme> deserialise(@Nonnull final String serialisedScheme); @Override @Nonnull Single<Boolean> isValidSerialisation(@Nonnull final String serialisedScheme); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSerialise_nullRecoveryScheme() { serialiser.serialise(null); }
@Test public void testSerialiseAndDeserialise() { final RecoveryScheme recoveryScheme = RecoveryScheme .builder() .setRequiredShareCount(2) .setPrime(7) .build(); serialiser .serialise(recoveryScheme) .flatMap(serialiser::deserialise) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(recoveryScheme); }
@Test public void testIsValidSerialisation_wellFormedInput() { final RecoveryScheme recoveryScheme = RecoveryScheme .builder() .setRequiredShareCount(2) .setPrime(7) .build(); serialiser .serialise(recoveryScheme) .flatMap(serialiser::isValidSerialisation) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(true); } |
### Question:
JsonRecoverySchemeSerialiser implements RecoverySchemeSerialiser { @Override @Nonnull public Single<RecoveryScheme> deserialise(@Nonnull final String serialisedScheme) { checkNotNull(serialisedScheme, "\'serialisedScheme\' must not be null."); return Single .just(serialisedScheme) .map(scheme -> { final JsonObject jsonObject = new JsonParser().parse(serialisedScheme).getAsJsonObject(); final byte[] primeBase64Decoded = Base64.getDecoder().decode(jsonObject.get("prime").getAsString()); return RecoveryScheme .builder() .setRequiredShareCount(jsonObject.get("requiredShareCount").getAsInt()) .setPrime(new BigInteger(primeBase64Decoded)) .build(); }) .onErrorResumeNext(error -> Single.error( new DeserialisationException(format("Cannot deserialise \'%1$s.\'", serialisedScheme), error))); } @Override @Nonnull Single<String> serialise(@Nonnull final RecoveryScheme scheme); @Override @Nonnull Single<RecoveryScheme> deserialise(@Nonnull final String serialisedScheme); @Override @Nonnull Single<Boolean> isValidSerialisation(@Nonnull final String serialisedScheme); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testDeserialise_nullSerialisedRecoveryScheme() { serialiser.deserialise(null); } |
### Question:
JsonRecoverySchemeSerialiser implements RecoverySchemeSerialiser { @Override @Nonnull public Single<Boolean> isValidSerialisation(@Nonnull final String serialisedScheme) { checkNotNull(serialisedScheme, "\'serialisedScheme\' must not be null."); return deserialise(serialisedScheme) .flatMap(result -> Single.just(true)) .onErrorResumeNext(Single.just(false)); } @Override @Nonnull Single<String> serialise(@Nonnull final RecoveryScheme scheme); @Override @Nonnull Single<RecoveryScheme> deserialise(@Nonnull final String serialisedScheme); @Override @Nonnull Single<Boolean> isValidSerialisation(@Nonnull final String serialisedScheme); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testIsValidSerialisation_nullSerialisedScheme() { serialiser.isValidSerialisation(null); }
@Test public void testIsValidSerialisation_emptySerialisedScheme() { serialiser .isValidSerialisation("") .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(false); }
@Test public void testIsValidSerialisation_malformedInput() { serialiser .isValidSerialisation("Hello, World!") .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(false); } |
### Question:
JsonShareSerialiser implements ShareSerialiser { @Override @Nonnull public Single<String> serialise(@Nonnull final Share share) { checkNotNull(share, "\'share\' must not be null."); return Single.fromCallable(() -> { final String indexBase64Encoded = Base64.getEncoder().encodeToString(share.getIndex().toByteArray()); final String valueBase64Encoded = Base64.getEncoder().encodeToString(share.getValue().toByteArray()); final JsonObject json = new JsonObject(); json.addProperty("index", indexBase64Encoded); json.addProperty("value", valueBase64Encoded); return json.toString(); }); } @Override @Nonnull Single<String> serialise(@Nonnull final Share share); @Override @Nonnull Single<Share> deserialise(@Nonnull final String serialisedShare); @Override @Nonnull Single<Boolean> isValidSerialisation(@Nonnull final String serialisedShare); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSerialise_nullShare() { serialiser.serialise(null); }
@Test public void testSerialiseAndDeserialise() { final Share share = Share .builder() .setIndex(1) .setValue(2) .build(); serialiser .serialise(share) .flatMap(serialiser::deserialise) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(share); }
@Test public void testIsValidSerialisation_wellFormedInput() { final Share share = Share .builder() .setIndex(1) .setValue(2) .build(); serialiser .serialise(share) .flatMap(serialiser::isValidSerialisation) .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(true); } |
### Question:
JsonShareSerialiser implements ShareSerialiser { @Override @Nonnull public Single<Share> deserialise(@Nonnull final String serialisedShare) { checkNotNull(serialisedShare, "\'serialisedShare\' must not be null."); return Single .just(serialisedShare) .map(share -> { final JsonObject jsonObject = new JsonParser().parse(serialisedShare).getAsJsonObject(); final byte[] indexBase64Decoded = Base64.getDecoder().decode(jsonObject.get("index").getAsString()); final byte[] valueBase64Decoded = Base64.getDecoder().decode(jsonObject.get("value").getAsString()); return Share .builder() .setIndex(new BigInteger(indexBase64Decoded)) .setValue(new BigInteger(valueBase64Decoded)) .build(); }) .onErrorResumeNext(error -> Single.error( new DeserialisationException(format("Cannot deserialise \'%1$s\'.", serialisedShare), error))); } @Override @Nonnull Single<String> serialise(@Nonnull final Share share); @Override @Nonnull Single<Share> deserialise(@Nonnull final String serialisedShare); @Override @Nonnull Single<Boolean> isValidSerialisation(@Nonnull final String serialisedShare); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testDeserialise_nullSerialisedShare() { serialiser.deserialise(null); } |
### Question:
JsonShareSerialiser implements ShareSerialiser { @Override @Nonnull public Single<Boolean> isValidSerialisation(@Nonnull final String serialisedShare) { checkNotNull(serialisedShare, "\'serialisedShare\' must not be null."); return deserialise(serialisedShare) .flatMap(result -> Single.just(true)) .onErrorResumeNext(Single.just(false)); } @Override @Nonnull Single<String> serialise(@Nonnull final Share share); @Override @Nonnull Single<Share> deserialise(@Nonnull final String serialisedShare); @Override @Nonnull Single<Boolean> isValidSerialisation(@Nonnull final String serialisedShare); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testIsValidSerialisation_nullSerialisedShare() { serialiser.isValidSerialisation(null); }
@Test public void testIsValidSerialisation_emptySerialisedShare() { serialiser .isValidSerialisation("") .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(false); }
@Test public void testIsValidSerialisation_malformedInput() { serialiser .isValidSerialisation("Hello, World!") .test() .awaitDone(200, MILLISECONDS) .assertNoErrors() .assertValue(false); } |
### Question:
RecoveryPresenter { @Nonnull public Completable stopPresenting() { return Completable.create(emitter -> { synchronized (startStopPresentingLock) { if (currentlyPresenting.compareAndSet(true, false)) { for (final Disposable disposable : disposables) { disposable.dispose(); } disposables.clear(); } emitter.onComplete(); } }); } RecoveryPresenter(
@Nonnull final RecoveryView view,
@Nonnull final Scheduler presentationScheduler,
@Nonnull final Scheduler viewScheduler,
@Nonnull final RxShamir rxShamir,
@Nonnull final SecretEncoder secretEncoder,
@Nonnull final PersistenceOperations persistenceOperations,
@Nonnull final RxFiles rxFiles); @Nonnull Completable startPresenting(); @Nonnull Completable stopPresenting(); }### Answer:
@Test public void testStopPresenting_calledBeforeStarting() { presenter.stopPresenting().blockingGet(); } |
### Question:
Jive6ContributorProfileProvider implements ContributorProfileProvider { protected Map<String, Object> convertJSONMap(byte[] data) { ObjectMapper mapper = new ObjectMapper(); try { int startOffset = 0; for (byte b : data) { if (FIRST_RESPONSE_BYTE == b) { break; } startOffset++; } return mapper.readValue(data, startOffset, data.length, new TypeReference<Map<String, Object>>() { }); } catch (IOException e) { String msg = "Cannot parse Jive 6 profile json data: " + e.getMessage(); log.log(Level.WARNING, msg); throw new RuntimeException(msg); } } @PostConstruct void init(); @Override List<ContributorProfile> getAllProfiles(Integer start, Integer size); @Override ContributorProfile getProfile(String jbossorgUsername); @PreDestroy void destroy(); static final String JIVE_PROFILE_REST_API; static final String JIVE_ALL_PROFILES_REST_API; }### Answer:
@SuppressWarnings("deprecation") @Test(expected = RuntimeException.class) public void convertJSONMap_jiveDataError1() throws Exception { Jive6ContributorProfileProvider provider = getTested(); provider.convertJSONMap(IOUtils.toByteArray("")); } |
### Question:
RestServiceBase { public Map<String, Object> createResponse(final GetResponse response) { return response.getSource(); } Map<String, Object> createResponse(final GetResponse response); StreamingOutput createResponse(final SearchResponse response,
final Map<String, String> additionalResponseFields); StreamingOutput createResponse(final MultiSearchResponse response, final String responseUuid); }### Answer:
@Test public void createResponse_Map() { RestServiceBase tested = getTested(); GetResponse rMock = Mockito.mock(GetResponse.class); Map<String, Object> m = new HashMap<String, Object>(); Mockito.when(rMock.getSource()).thenReturn(m); Assert.assertEquals(m, tested.createResponse(rMock)); }
@Test public void createResponse_StreamingOutput() throws IOException, JSONException { RestServiceBase tested = getTested(); SearchResponse srMock = Mockito.mock(SearchResponse.class); Mockito.doAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { Object[] args = invocation.getArguments(); XContentBuilder resp = (XContentBuilder) args[0]; resp.field("testfield", "testvalue"); return null; } }).when(srMock).toXContent(Mockito.any(XContentBuilder.class), Mockito.eq(ToXContent.EMPTY_PARAMS)); Map<String, String> af = new LinkedHashMap<String, String>(); TestUtils.assetJsonStreamingOutputContent("{\"testfield\":\"testvalue\"}", tested.createResponse(srMock, af)); af.put("uuid", "myid"); af.put("ag", "qag"); af.put("oo", null); StreamingOutput so = tested.createResponse(srMock, af); TestUtils.assetJsonStreamingOutputContent("{\"uuid\":\"myid\",\"ag\":\"qag\",\"oo\":null,\"testfield\":\"testvalue\"}", so); TestUtils.assetJsonStreamingOutputContent("{\"testfield\":\"testvalue\"}", tested.createResponse(srMock, null)); } |
### Question:
ExceptionMapperBase { protected static CharSequence collectErrorMessages(Throwable exception) { StringBuilder messages = new StringBuilder(); collectErrorMessages(messages, exception); return messages; } }### Answer:
@Test public void collectErrorMessages() { Assert.assertEquals("", ExceptionMapperBase.collectErrorMessages(null).toString()); Assert.assertEquals("", ExceptionMapperBase.collectErrorMessages(new Exception()).toString()); Assert.assertEquals("", ExceptionMapperBase.collectErrorMessages(new Exception((String) null)).toString()); Assert.assertEquals("", ExceptionMapperBase.collectErrorMessages(new Exception(" ")).toString()); Assert.assertEquals("NullPointerException", ExceptionMapperBase.collectErrorMessages(new NullPointerException()) .toString()); Assert.assertEquals("test message", ExceptionMapperBase.collectErrorMessages(new Exception("test message")) .toString()); Assert.assertEquals("test message. Caused by: cause 1. Caused by: cause 2", ExceptionMapperBase .collectErrorMessages(new Exception("test message", new Exception("cause 1", new Exception("cause 2")))) .toString()); Assert.assertEquals("test message. Caused by: NullPointerException", ExceptionMapperBase.collectErrorMessages(new Exception("test message", new NullPointerException())).toString()); } |
### Question:
SearchUtils { public static String trimToNull(String value) { if (value != null) { value = value.trim(); if (value.isEmpty()) value = null; } return value; } static Properties loadProperties(String path); static String trimToNull(String value); static List<String> safeList(List<String> values); static boolean isBlank(String value); static boolean isBlank(Object value); static String convertJsonMapToString(Map<String, Object> jsonMapValue); static DateFormat getISODateFormat(); static Date dateFromISOString(String string, boolean silent); static boolean isDateAfter(Object date, int thresholdInMinutes); static Map<String, Object> convertToJsonMap(String jsonData); static Integer getIntegerFromJsonMap(Map<String, Object> map, String key); @SuppressWarnings("unchecked") static List<String> getListOfStringsFromJsonMap(Map<String, Object> map, String key); static void mergeJsonMaps(Map<String, Object> source, Map<String, Object> target); static Map<String, Object> collapseURLParams(MultivaluedMap<String, String> params); static boolean isMysqlDialect(String databaseProductName); }### Answer:
@Test public void trimToNull() { Assert.assertNull(SearchUtils.trimToNull(null)); Assert.assertNull(SearchUtils.trimToNull("")); Assert.assertNull(SearchUtils.trimToNull(" ")); Assert.assertNull(SearchUtils.trimToNull(" \t ")); Assert.assertEquals("a", SearchUtils.trimToNull("a")); Assert.assertEquals("a", SearchUtils.trimToNull("a ")); Assert.assertEquals("a", SearchUtils.trimToNull(" a")); Assert.assertEquals("abcd aaa", SearchUtils.trimToNull(" abcd aaa \t ")); } |
### Question:
QuerySettingsParser { protected List<String> normalizeListParam(List<String> paramValue) { if (paramValue == null || paramValue.isEmpty()) { return null; } List<String> ret = new ArrayList<String>(); for (String s : paramValue) { s = SearchUtils.trimToNull(s); if (s != null) { ret.add(s); } } if (ret.isEmpty()) return null; else return ret; } QuerySettings parseUriParams(final MultivaluedMap<String, String> params); }### Answer:
@Test public void normalizeListParam() { QuerySettingsParser tested = getTested(); Assert.assertNull(tested.normalizeListParam(null)); Assert.assertNull(tested.normalizeListParam(new ArrayList<String>())); Assert.assertNull(tested.normalizeListParam(Arrays.asList(""))); Assert.assertNull(tested.normalizeListParam(Arrays.asList("", " ", " \n \t"))); Assert.assertArrayEquals(new String[] { "ahoj" }, tested.normalizeListParam(Arrays.asList("", " ", "ahoj ")) .toArray()); Assert.assertArrayEquals(new String[] { "ahoj", "cao" }, tested.normalizeListParam(Arrays.asList("", " ", "ahoj ", "\tcao ")).toArray()); } |
### Question:
QuerySettingsParser { protected Integer readIntegerParam(MultivaluedMap<String, String> params, String paramKey) throws IllegalArgumentException { if (params != null && params.containsKey(paramKey)) { try { String s = SearchUtils.trimToNull(params.getFirst(paramKey)); if (s == null) return null; return new Integer(s); } catch (NumberFormatException e) { throw new IllegalArgumentException(paramKey); } } return null; } QuerySettings parseUriParams(final MultivaluedMap<String, String> params); }### Answer:
@Test public void readIntegerParam() { QuerySettingsParser tested = getTested(); Assert.assertNull(tested.readIntegerParam(null, "key")); MultivaluedMap<String, String> params = new MultivaluedMapImpl<String, String>(); Assert.assertNull(tested.readIntegerParam(params, "key")); params.add("key", ""); Assert.assertNull(tested.readIntegerParam(params, "key")); params.clear(); params.add("key", " \t"); Assert.assertNull(tested.readIntegerParam(params, "key")); params.clear(); params.add("key", "10"); Assert.assertEquals(new Integer(10), tested.readIntegerParam(params, "key")); params.clear(); params.add("key", "10err"); try { tested.readIntegerParam(params, "key"); Assert.fail("IllegalArgumentException expected"); } catch (IllegalArgumentException e) { } } |
### Question:
QuerySettingsParser { protected boolean readBooleanParam(MultivaluedMap<String, String> params, String paramKey) { if (params != null && params.containsKey(paramKey)) { return Boolean.parseBoolean(SearchUtils.trimToNull(params.getFirst(paramKey))); } return false; } QuerySettings parseUriParams(final MultivaluedMap<String, String> params); }### Answer:
@Test public void readBooleanParam() { QuerySettingsParser tested = getTested(); Assert.assertFalse(tested.readBooleanParam(null, "key")); MultivaluedMap<String, String> params = new MultivaluedMapImpl<String, String>(); Assert.assertFalse(tested.readBooleanParam(params, "key")); params.clear(); params.add("key", ""); Assert.assertFalse(tested.readBooleanParam(params, "key")); params.clear(); params.add("key", "false"); Assert.assertFalse(tested.readBooleanParam(params, "key")); params.clear(); params.add("key", "False"); Assert.assertFalse(tested.readBooleanParam(params, "key")); params.clear(); params.add("key", "nonsense"); Assert.assertFalse(tested.readBooleanParam(params, "key")); params.clear(); params.add("key", "true"); Assert.assertTrue(tested.readBooleanParam(params, "key")); params.clear(); params.add("key", " True"); Assert.assertTrue(tested.readBooleanParam(params, "key")); params.clear(); params.add("key", "TRUE "); Assert.assertTrue(tested.readBooleanParam(params, "key")); } |
### Question:
Resources { @Produces @RequestScoped @Named("facesContext") public FacesContext produceFacesContext() { FacesContext ctx = FacesContext.getCurrentInstance(); if (ctx == null) { throw new ContextNotActiveException("FacesContext is not active"); } return ctx; } @Produces Logger produceLog(InjectionPoint injectionPoint); @Produces @RequestScoped @Named("facesContext") FacesContext produceFacesContext(); static String readStringFromClasspathFile(String filePath); }### Answer:
@Test public void produceFacesContext() { Resources tested = new Resources(); try { tested.produceFacesContext(); Assert.fail("ContextNotActiveException expected"); } catch (ContextNotActiveException e) { } try { FacesContext fcMock = Mockito.mock(FacesContext.class); FacesContextMock.setCurrentInstanceImpl(fcMock); Assert.assertEquals(fcMock, tested.produceFacesContext()); } finally { FacesContextMock.setCurrentInstanceImpl(null); } } |
### Question:
Resources { @Produces public Logger produceLog(InjectionPoint injectionPoint) { return Logger.getLogger(injectionPoint.getMember().getDeclaringClass().getName()); } @Produces Logger produceLog(InjectionPoint injectionPoint); @Produces @RequestScoped @Named("facesContext") FacesContext produceFacesContext(); static String readStringFromClasspathFile(String filePath); }### Answer:
@SuppressWarnings("unchecked") @Test public void produceLog() { Resources tested = new Resources(); InjectionPoint ipMock = Mockito.mock(InjectionPoint.class); Member memberMock = Mockito.mock(Member.class); Mockito.when(((Class<ProduceLogTestClass>) memberMock.getDeclaringClass())).thenReturn(ProduceLogTestClass.class); Mockito.when(ipMock.getMember()).thenReturn(memberMock); Logger l = tested.produceLog(ipMock); Assert.assertEquals("org.searchisko.api.util.ResourcesTest$ProduceLogTestClass", l.getName()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.