Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: VertxServiceDiscovery { public ServiceReference lookupForAReference(Record record) { return serviceDiscovery.getReference(record); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }### Answer: @Test public void givenServiceDiscovery_whenPublishServiceAndLookupForItsServiceReference_thenShouldGetTheReference(TestContext context) throws Exception { publishTestRecord(record, context.asyncAssertSuccess(record -> { assertNotNull(vertxServiceDiscovery.lookupForAReference(record)); })); }
### Question: VertxServiceDiscovery { public ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration) { return serviceDiscovery.getReferenceWithConfiguration(record, configuration); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }### Answer: @Test public void givenServiceDiscovery_whenPublishServiceWithMetadataAndLookupForItsServiceReferencePassingConfiguration_thenShouldGetTheReferenceUponTheseConfigurations(TestContext context) throws Exception { publishTestRecord(record, context.asyncAssertSuccess(record -> { ServiceReference reference = vertxServiceDiscovery.lookupForAReferenceWithConfiguration(record, metadata); assertEquals(VALUE, reference.record().getMetadata().getString(KEY)); })); }
### Question: ListItemsUniqueModel extends AbstractValueModel { public void setValue(Object newValue) { throw new UnsupportedOperationException("ListItemsUniqueModel is read-only"); } ListItemsUniqueModel(ObservableList<E> list, Class<E> beanClass, String propertyName); Object getValue(); boolean calculate(); void setValue(Object newValue); }### Answer: @Test public void testEventsOnPropertyChange() { ObservableList<ValueHolder> list = new ArrayListModel<ValueHolder>(); ValueHolder v1 = new ValueHolder("A"); list.add(v1); ValueHolder v2 = new ValueHolder("B"); list.add(v2); ListItemsUniqueModel<ValueHolder> unique = new ListItemsUniqueModel<ValueHolder>(list, ValueHolder.class, "value"); PropertyChangeListener listener = EasyMock.createStrictMock(PropertyChangeListener.class); listener.propertyChange(JUnitUtil.eqPropertyChangeEvent( new PropertyChangeEvent(unique, "value", true, false))); listener.propertyChange(JUnitUtil.eqPropertyChangeEvent( new PropertyChangeEvent(unique, "value", false, true))); EasyMock.replay(listener); unique.addPropertyChangeListener(listener); v1.setValue("B"); v1.setValue("Bar"); EasyMock.verify(listener); }
### Question: CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() \|\| idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }### Answer: @Test public void testGetElementAtIndex() { assertEquals("A", CollectionUtil.getElementAtIndex(d_set, 0)); assertEquals("B", CollectionUtil.getElementAtIndex(d_set, 1)); } @Test(expected=IndexOutOfBoundsException.class) public void testGetElementAtIndexTooHigh() { CollectionUtil.getElementAtIndex(d_set, 2); } @Test(expected=IndexOutOfBoundsException.class) public void testGetElementAtIndexNegative() { CollectionUtil.getElementAtIndex(d_set, -1); }
### Question: CollectionUtil { public static <E> int getIndexOfElement(Collection<E> set, Object child) { int i = 0; for (E e : set) { if (e.equals(child)) { return i; } ++i; } return -1; } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }### Answer: @Test public void testGetIndexOfElement() { assertEquals(0, CollectionUtil.getIndexOfElement(d_set, "A")); assertEquals(1, CollectionUtil.getIndexOfElement(d_set, "B")); assertEquals(-1, CollectionUtil.getIndexOfElement(d_set, "C")); }
### Question: CollectionUtil { public static boolean nextLexicographicElement(int x[], int c[]) { assert(x.length == c.length); final int l = x.length; if (l < 1) { return false; } for (int i = l - 1; i >= 0; --i) { ++x[i]; if (x[i] == c[i]) { x[i] = 0; } else { return true; } } return false; } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }### Answer: @Test public void testNextLexicographicElement() { int c[] = new int[] {1, 2, 3, 1}; int x[] = new int[] {0, 0, 0, 0}; assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 0, 1, 0}, x); assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 0, 2, 0}, x); assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 1, 0, 0}, x); assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 1, 1, 0}, x); assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 1, 2, 0}, x); assertFalse(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 0, 0, 0}, x); assertFalse(CollectionUtil.nextLexicographicElement(new int[] { 0 }, new int[] { 1 })); assertTrue(CollectionUtil.nextLexicographicElement(new int[] { 0 }, new int[] { 2 })); }
### Question: GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); @Override E get(int index); @Override int size(); @Override void add(int index, E element); @Override E set(int index, E element); @Override E remove(int index); }### Answer: @Test(expected=IllegalArgumentException.class) public void testConstructionWithNonEmptyList() { ObservableList<Integer> list = new ArrayListModel<Integer>(); list.add(1); d_list = new GuardedObservableList<Integer>(list, new Predicate<Number>() { public boolean evaluate(Number object) { return object.doubleValue() > 0.0; } }); } @Test(expected=IllegalArgumentException.class) public void testAddBadValue() { d_list.add(-1); }
### Question: GuardedObservableList extends AbstractObservableList<E> { @Override public E set(int index, E element) { check(element); return d_nested.set(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); @Override E get(int index); @Override int size(); @Override void add(int index, E element); @Override E set(int index, E element); @Override E remove(int index); }### Answer: @Test(expected=IllegalArgumentException.class) public void testSetBadValue() { d_list.set(1, -1); }
### Question: ListMinimumSizeModel extends AbstractValueModel { public Boolean getValue() { return d_val; } ListMinimumSizeModel(ListModel list, int minSize); Boolean getValue(); void setValue(Object value); }### Answer: @Test public void testInitialValues() { assertFalse(new ListMinimumSizeModel(new ArrayListModel<String>(), 1).getValue()); assertTrue(new ListMinimumSizeModel(new ArrayListModel<String>(Arrays.asList("Test")), 1).getValue()); assertFalse(new ListMinimumSizeModel(new ArrayListModel<String>(Arrays.asList("Test")), 2).getValue()); assertTrue(new ListMinimumSizeModel(new ArrayListModel<String>(Arrays.asList("Test", "Test")), 2).getValue()); }
### Question: FilteredObservableList extends AbstractObservableList<E> { @Override public E remove(final int index) { return d_inner.remove((int) d_indices.get(index)); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }### Answer: @Test public void testContentsUpdateRemoveNone() { ListDataListener mock = createStrictMock(ListDataListener.class); replay(mock); d_outer.addListDataListener(mock); d_inner.remove("Daan"); assertEquals(Arrays.asList("Gert", "Jan"), d_outer); verify(mock); }
### Question: FilteredObservableList extends AbstractObservableList<E> { private void intervalRemoved(final int lower, final int upper) { final int first = firstAtLeast(lower); if (first >= d_indices.size()) { return; } final int last = firstOver(upper); d_indices.removeAll(new ArrayList<Integer>(d_indices.subList(first, last))); final int delta = upper - lower + 1; updateIndices(first, -delta); if (last > first) { fireIntervalRemoved(first, last - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }### Answer: @Test public void testContentsUpdateRemoveAll() { ListDataListener mock = createStrictMock(ListDataListener.class); mock.intervalRemoved(ListDataEventMatcher.eqListDataEvent(new ListDataEvent(d_outer, ListDataEvent.INTERVAL_REMOVED, 0, 1))); replay(mock); d_outer.addListDataListener(mock); d_inner.clear(); assertEquals(Collections.emptyList(), d_outer); verify(mock); }
### Question: FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }### Answer: @Test public void testContentsUpdateFirstElement() { d_inner.set(0, "Gaart"); assertEquals(Arrays.asList("Jan"), d_outer); d_inner.set(0, "Gert"); assertEquals(Arrays.asList("Gert", "Jan"), d_outer); } @Test public void testContentsUpdateLastElement() { d_inner.set(3, "Klees"); assertEquals(Arrays.asList("Gert", "Jan", "Klees"), d_outer); } @Test public void testContentsUpdateSetNoChangeExcl() { ListDataListener mock = createStrictMock(ListDataListener.class); replay(mock); d_outer.addListDataListener(mock); d_inner.set(3, "Paard"); assertEquals(Arrays.asList("Gert", "Jan"), d_outer); verify(mock); } @Test(expected=IllegalArgumentException.class) public void testSetNonAcceptable() { d_outer.set(1, "Maarten"); }
### Question: FilteredObservableList extends AbstractObservableList<E> { public void setFilter(final Predicate<E> filter) { d_filter = filter; final int oldSize = size(); if(!isEmpty()) { d_indices.clear(); fireIntervalRemoved(0, oldSize - 1); } initializeIndices(); if(!isEmpty()) { fireIntervalAdded(0, size() - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }### Answer: @Test public void testSetFilter() { ListDataListener mock = createStrictMock(ListDataListener.class); mock.intervalRemoved(ListDataEventMatcher.eqListDataEvent(new ListDataEvent(d_outer, ListDataEvent.INTERVAL_REMOVED, 0, 1))); mock.intervalAdded(ListDataEventMatcher.eqListDataEvent(new ListDataEvent(d_outer, ListDataEvent.INTERVAL_ADDED, 0, 2))); replay(mock); d_outer.addListDataListener(mock); d_outer.setFilter(new Predicate<String>() { public boolean evaluate(String str) { return !str.equals("Gert"); } }); assertEquals(Arrays.asList("Daan", "Jan", "Klaas"), d_outer); verify(mock); }
### Question: ListMinimumSizeModel extends AbstractValueModel { public void setValue(Object value) { throw new UnsupportedOperationException(); } ListMinimumSizeModel(ListModel list, int minSize); Boolean getValue(); void setValue(Object value); }### Answer: @Test(expected=UnsupportedOperationException.class) public void testSetValueNotSupported() { new ListMinimumSizeModel(new ArrayListModel<String>(), 2).setValue(true); }
### Question: SortedSetModel extends AbstractList<E> implements ObservableList<E> { @Override public E remove(int index) { if (index >= 0 && index < size()) { E e = get(index); d_set.remove(e); d_listenerManager.fireIntervalRemoved(index, index); return e; } throw new IndexOutOfBoundsException(); } SortedSetModel(); SortedSetModel(Comparator<? super E> comparator); SortedSetModel(Collection<? extends E> c); @Override int size(); @Override E get(int index); @Override void add(int index, E element); @Override E remove(int index); @Override boolean remove(Object o); int getSize(); Object getElementAt(int index); void addListDataListener(ListDataListener l); void removeListDataListener(ListDataListener l); SortedSet<E> getSet(); }### Answer: @Test public void testRemoving() { assertTrue(d_filledList.remove("Daan")); assertEquals(Arrays.asList("Gert", "Margreth"), d_filledList); assertEquals("Gert", d_filledList.remove(0)); assertEquals(Arrays.asList("Margreth"), d_filledList); resetFilledList(); d_filledList.clear(); assertEquals(Collections.emptyList(), d_filledList); resetFilledList(); ListIterator<String> it = d_filledList.listIterator(); int i = 0; while (it.hasNext()) { it.next(); if (i % 2 == 0) { it.remove(); } ++i; } assertEquals(Collections.singletonList("Gert"), d_filledList); }
### Question: SortedSetModel extends AbstractList<E> implements ObservableList<E> { @Override public void add(int index, E element) { if (!d_set.contains(element)) { d_set.add(element); int idx = indexOf(element); d_listenerManager.fireIntervalAdded(idx, idx); } } SortedSetModel(); SortedSetModel(Comparator<? super E> comparator); SortedSetModel(Collection<? extends E> c); @Override int size(); @Override E get(int index); @Override void add(int index, E element); @Override E remove(int index); @Override boolean remove(Object o); int getSize(); Object getElementAt(int index); void addListDataListener(ListDataListener l); void removeListDataListener(ListDataListener l); SortedSet<E> getSet(); }### Answer: @Test public void testAdding() { SortedSetModel<String> ssm = new SortedSetModel<String>(); ssm.add(0, "Gert"); assertEquals(Arrays.asList("Gert"), ssm); ssm.add(0, "Margreth"); assertEquals(Arrays.asList("Gert", "Margreth"), ssm); }
### Question: SortedSetModel extends AbstractList<E> implements ObservableList<E> { public SortedSet<E> getSet() { return new TreeSet<E>(d_set); } SortedSetModel(); SortedSetModel(Comparator<? super E> comparator); SortedSetModel(Collection<? extends E> c); @Override int size(); @Override E get(int index); @Override void add(int index, E element); @Override E remove(int index); @Override boolean remove(Object o); int getSize(); Object getElementAt(int index); void addListDataListener(ListDataListener l); void removeListDataListener(ListDataListener l); SortedSet<E> getSet(); }### Answer: @Test public void testGetSet() { assertEquals(new TreeSet<String>(d_filledList), d_filledList.getSet()); }
### Question: ValueEqualsModel extends AbstractConverter { public void setValue(final Object newValue) { throw new UnsupportedOperationException(getClass().getSimpleName() + " is read-only"); } ValueEqualsModel(final ValueModel model, final Object expectedValue); void setValue(final Object newValue); Object convertFromSubject(final Object subjectValue); void setExpected(Object expectedValue); }### Answer: @Test public void testEqualsExpected() { ValueHolder valueModel = new ValueHolder("name"); ValueEqualsModel equalsModel = new ValueEqualsModel(valueModel, "name"); assertEquals(Boolean.TRUE, equalsModel.getValue()); PropertyChangeListener listener = EasyMock.createStrictMock(PropertyChangeListener.class); listener.propertyChange(JUnitUtil.eqPropertyChangeEvent(new PropertyChangeEvent(equalsModel, "value", true, false))); EasyMock.replay(listener); equalsModel.addPropertyChangeListener(listener); valueModel.setValue("naem"); EasyMock.verify(listener); }
### Question: ValueEqualsModel extends AbstractConverter { public void setExpected(Object expectedValue) { Object oldVal = getValue(); d_expectedValue = expectedValue; firePropertyChange("value", oldVal, getValue()); } ValueEqualsModel(final ValueModel model, final Object expectedValue); void setValue(final Object newValue); Object convertFromSubject(final Object subjectValue); void setExpected(Object expectedValue); }### Answer: @Test public void testChangeExpected() { ValueHolder valueModel = new ValueHolder("name"); ValueEqualsModel equalsModel = new ValueEqualsModel(valueModel, "name"); assertEquals(Boolean.TRUE, equalsModel.getValue()); PropertyChangeListener listener = EasyMock.createStrictMock(PropertyChangeListener.class); listener.propertyChange(JUnitUtil.eqPropertyChangeEvent(new PropertyChangeEvent(equalsModel, "value", true, false))); EasyMock.replay(listener); equalsModel.addPropertyChangeListener(listener); equalsModel.setExpected(15); EasyMock.verify(listener); }
### Question: DateUtil { public static Date getCurrentDateWithoutTime() { Calendar cal = Calendar.getInstance(); cal.set(Calendar.HOUR, 0); cal.set(Calendar.MINUTE, 0); cal.set(Calendar.SECOND, 0); cal.set(Calendar.MILLISECOND, 0); cal.set(Calendar.AM_PM, Calendar.AM); Date date = cal.getTime(); return date; } static Date getCurrentDateWithoutTime(); }### Answer: @SuppressWarnings("deprecation") @Test public void testGetCurrentDateWithoutTime() { Date now = new Date(); Date woTime = DateUtil.getCurrentDateWithoutTime(); assertEquals(now.getYear(), woTime.getYear()); assertEquals(now.getMonth(), woTime.getMonth()); assertEquals(now.getDay(), woTime.getDay()); assertEquals(0, woTime.getHours()); assertEquals(0, woTime.getMinutes()); assertEquals(0, woTime.getSeconds()); }
### Question: Statistics { public static EstimateWithPrecision meanDifference( double m0, double s0, double n0, double m1, double s1, double n1) { double md = m1 - m0; double se = Math.sqrt((s0 * s0) / n0 + (s1 * s1) / n1); return new EstimateWithPrecision(md, se); } private Statistics(); static double logit(double p); static double ilogit(double x); static EstimateWithPrecision logOddsRatio( int a, int n, int c, int m, boolean corrected); static EstimateWithPrecision meanDifference( double m0, double s0, double n0, double m1, double s1, double n1); }### Answer: @Test public void testMeanDifference() { EstimateWithPrecision e = Statistics.meanDifference( -2.5, 1.6, 177, -2.6, 1.5, 176); assertEquals(-0.1, e.getPointEstimate(), EPSILON); assertEquals(0.1650678, e.getStandardError(), EPSILON); }
### Question: SimpleSuspendableTask implements SimpleTask { public boolean wakeUp() { return d_suspendable.wakeUp(); } SimpleSuspendableTask(Suspendable suspendable, String str); SimpleSuspendableTask(Runnable runnable, String str); SimpleSuspendableTask(Runnable runnable); SimpleSuspendableTask(Suspendable suspendable); void addTaskListener(TaskListener l); void removeTaskListener(TaskListener l); void run(); boolean isStarted(); boolean isFinished(); boolean isFailed(); Throwable getFailureCause(); boolean isAborted(); boolean isSuspended(); boolean suspend(); boolean wakeUp(); boolean abort(); @Override String toString(); }### Answer: @Test public void wakeUpWakesNested() { Suspendable mockSuspendable = createStrictMock(Suspendable.class); expect(mockSuspendable.wakeUp()).andReturn(true); replay(mockSuspendable); SimpleTask task = new SimpleSuspendableTask(mockSuspendable); task.wakeUp(); verify(mockSuspendable); }
### Question: SimpleSuspendableTask implements SimpleTask { public boolean abort() { return d_suspendable.abort(); } SimpleSuspendableTask(Suspendable suspendable, String str); SimpleSuspendableTask(Runnable runnable, String str); SimpleSuspendableTask(Runnable runnable); SimpleSuspendableTask(Suspendable suspendable); void addTaskListener(TaskListener l); void removeTaskListener(TaskListener l); void run(); boolean isStarted(); boolean isFinished(); boolean isFailed(); Throwable getFailureCause(); boolean isAborted(); boolean isSuspended(); boolean suspend(); boolean wakeUp(); boolean abort(); @Override String toString(); }### Answer: @Test public void wakeUpAbortsNested() { Suspendable mockSuspendable = createStrictMock(Suspendable.class); expect(mockSuspendable.abort()).andReturn(true); replay(mockSuspendable); SimpleTask task = new SimpleSuspendableTask(mockSuspendable); task.abort(); verify(mockSuspendable); }
### Question: DecisionTransition implements Transition { public List<Task> transition() { if (!isReady()) { throw new RuntimeException("Not ready for transition."); } if (d_condition.evaluate()) { return Collections.singletonList(d_ifTask); } else { return Collections.singletonList(d_elTask); } } DecisionTransition(Task source, Task ifTask, Task elTask, Condition condition); List<Task> getSources(); List<Task> getTargets(); boolean isReady(); List<Task> transition(); }### Answer: @Test public void testTrueCondition() { MockTask source = new MockTask(); Task ifTask = new MockTask(); Task elTask = new MockTask(); Condition condition = createStrictMock(Condition.class); expect(condition.evaluate()).andReturn(true); replay(condition); Transition trans = new DecisionTransition(source, ifTask, elTask, condition); source.start(); source.finish(); assertEquals(Collections.singletonList(ifTask), trans.transition()); verify(condition); } @Test public void testFalseCondition() { MockTask source = new MockTask(); Task ifTask = new MockTask(); Task elTask = new MockTask(); Condition condition = createStrictMock(Condition.class); expect(condition.evaluate()).andReturn(false); replay(condition); Transition trans = new DecisionTransition(source, ifTask, elTask, condition); source.start(); source.finish(); assertEquals(Collections.singletonList(elTask), trans.transition()); verify(condition); }
### Question: StringNotEmptyModel extends AbstractValueModel { public Boolean getValue() { return d_val; } StringNotEmptyModel(ValueModel nested); Boolean getValue(); void setValue(Object value); }### Answer: @Test public void testInitialValues() { assertFalse(new StringNotEmptyModel(new ValueHolder(null)).getValue()); assertFalse(new StringNotEmptyModel(new ValueHolder(new Object())).getValue()); assertFalse(new StringNotEmptyModel(new ValueHolder("")).getValue()); assertTrue(new StringNotEmptyModel(new ValueHolder("Test")).getValue()); }
### Question: ActivityModel { public Set<Task> getNextStates() { if (isFinished()) { return Collections.emptySet(); } return findAccessibleStates(d_start); } ActivityModel(Task start, Task end, Collection<? extends Transition> transitions); Set<Task> getNextStates(); boolean isFinished(); Task getStartState(); Task getEndState(); Set<Task> getStates(); Task getStateByName(String name); Set<Transition> getTransitions(); }### Answer: @Test public void testInitialState() { MockTask start = new MockTask(); start.start(); MockTask end = new MockTask(); Transition trans = new DirectTransition(start, end); ActivityModel model = new ActivityModel(start, end, Collections.singleton(trans)); assertEquals(Collections.singleton(start), model.getNextStates()); } @Test public void testSimpleTransition() { MockTask start = new MockTask(); start.start(); MockTask end = new MockTask(); Transition trans = new DirectTransition(start, end); ActivityModel model = new ActivityModel(start, end, Collections.singleton(trans)); start.finish(); assertEquals(Collections.singleton(end), model.getNextStates()); }
### Question: ActivityModel { public boolean isFinished() { return d_end.isFinished(); } ActivityModel(Task start, Task end, Collection<? extends Transition> transitions); Set<Task> getNextStates(); boolean isFinished(); Task getStartState(); Task getEndState(); Set<Task> getStates(); Task getStateByName(String name); Set<Transition> getTransitions(); }### Answer: @Test public void testIsFinished() { MockTask start = new MockTask(); start.start(); MockTask end = new MockTask(); Transition trans = new DirectTransition(start, end); ActivityModel model = new ActivityModel(start, end, Collections.singleton(trans)); start.finish(); end.start(); end.finish(); assertTrue(model.isFinished()); assertEquals(Collections.<Task>emptySet(), model.getNextStates()); }
### Question: IterativeTask extends SimpleSuspendableTask { public void setReportingInterval(int interval) { ((IterativeSuspendable)d_suspendable).setReportingInterval(interval); } IterativeTask(IterativeComputation computation, String str); IterativeTask(IterativeComputation computation); void setReportingInterval(int interval); @Override String toString(); }### Answer: @Test public void testNotifyProgress() { IterativeComputation comp = new ShortComputation(10); IterativeTask task = new IterativeTask(comp); task.setReportingInterval(3); TaskListener listener = createStrictMock(TaskListener.class); listener.taskEvent(new TaskStartedEvent(task)); listener.taskEvent(new TaskProgressEvent(task, 0, 10)); listener.taskEvent(new TaskProgressEvent(task, 3, 10)); listener.taskEvent(new TaskProgressEvent(task, 6, 10)); listener.taskEvent(new TaskProgressEvent(task, 9, 10)); listener.taskEvent(new TaskProgressEvent(task, 10, 10)); listener.taskEvent(new TaskFinishedEvent(task)); replay(listener); task.addTaskListener(listener); task.run(); verify(listener); } @Test public void testNotifyProgress2() { IterativeComputation comp = new ShortComputation(9); IterativeTask task = new IterativeTask(comp); task.setReportingInterval(3); TaskListener listener = createStrictMock(TaskListener.class); listener.taskEvent(new TaskStartedEvent(task)); listener.taskEvent(new TaskProgressEvent(task, 0, 9)); listener.taskEvent(new TaskProgressEvent(task, 3, 9)); listener.taskEvent(new TaskProgressEvent(task, 6, 9)); listener.taskEvent(new TaskProgressEvent(task, 9, 9)); listener.taskEvent(new TaskFinishedEvent(task)); replay(listener); task.addTaskListener(listener); task.run(); verify(listener); }
### Question: StringNotEmptyModel extends AbstractValueModel { public void setValue(Object value) { throw new UnsupportedOperationException(); } StringNotEmptyModel(ValueModel nested); Boolean getValue(); void setValue(Object value); }### Answer: @Test(expected=UnsupportedOperationException.class) public void testSetValueNotSupported() { new StringNotEmptyModel(new ValueHolder(null)).setValue(true); } @Test public void testEventChaining() { ValueHolder holder = new ValueHolder(null); StringNotEmptyModel model = new StringNotEmptyModel(holder); PropertyChangeListener mock = JUnitUtil.mockStrictListener(model, "value", false, true); model.addValueChangeListener(mock); holder.setValue("test"); holder.setValue("test2"); verify(mock); model.removeValueChangeListener(mock); mock = JUnitUtil.mockStrictListener(model, "value", true, false); model.addValueChangeListener(mock); holder.setValue(""); verify(mock); }
### Question: StudentTTable { public static double getT(int v) { if (v < 1) { throw new IllegalArgumentException("student T distribution defined only for positive degrees of freedom"); } TDistribution dist = new TDistribution(v); return dist.inverseCumulativeProbability(0.975); } static double getT(int v); }### Answer: @Test public void testTable() { assertEquals(12.706, StudentTTable.getT(1), 0.001); assertEquals(1.998, StudentTTable.getT(63), 0.001); assertEquals(1.96, StudentTTable.getT(1000), 0.01); assertEquals(1.96, StudentTTable.getT(2000), 0.01); assertEquals(StudentTTable.getT(160) / 2 + StudentTTable.getT(140) / 2, StudentTTable.getT(150), 0.01); assertEquals(3 * StudentTTable.getT(160) / 4 + StudentTTable.getT(140) / 4, StudentTTable.getT(155), 0.01); }
### Question: Interval { public double getLength() { return d_upperBound.doubleValue() - d_lowerBound.doubleValue(); } Interval(N lowerBound, N upperBound); N getLowerBound(); N getUpperBound(); double getLength(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testGetLength() { Interval<Double> in = new Interval<Double>(1.0, 6.0); assertEquals(5.0, in.getLength(), 0.00001); }
### Question: Interval { @Override public boolean equals(Object o) { if (o instanceof Interval<?>) { Interval<?> other = (Interval<?>) o; if (other.canEqual(this)) { if (other.getLowerBound().getClass().equals(getLowerBound().getClass())) { return ((getLowerBound().equals(other.getLowerBound())) && (getUpperBound().equals(other.getUpperBound()))); } } } return false; } Interval(N lowerBound, N upperBound); N getLowerBound(); N getUpperBound(); double getLength(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testEquals() { Interval<Double> in = new Interval<Double>(1.0, 6.0); Interval<Integer> in2 = new Interval<Integer>(1, 6); assertNotEquals(in, in2); Double d = new Double(1.0); Integer i = new Integer(6); assertNotEquals(d, in); assertNotEquals(i, in2); Interval<Double> in3 = new Interval<Double>(1.0, 6.0); Interval<Integer> in4 = new Interval<Integer>(1, 6); assertEquals(in, in3); assertEquals(in.hashCode(), in3.hashCode()); assertEquals(in2, in4); assertEquals(in2.hashCode(), in4.hashCode()); Interval<Double> in5 = new Interval<Double>(2.0, 5.0); assertNotEquals(in, in5); }
### Question: Interval { @Override public String toString() { return getLowerBound().toString() + "-" + getUpperBound().toString(); } Interval(N lowerBound, N upperBound); N getLowerBound(); N getUpperBound(); double getLength(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testToString() { Interval<Double> in = new Interval<Double>(1.0, 6.0); assertEquals("1.0-6.0", in.toString()); }
### Question: LogstashLayout implements Layout<String> { @PluginBuilderFactory @SuppressWarnings("WeakerAccess") public static Builder newBuilder() { return new Builder(); } private LogstashLayout(Builder builder); @Override String toSerializable(LogEvent event); @Override byte[] toByteArray(LogEvent event); @Override void encode(LogEvent event, ByteBufferDestination destination); @Override byte[] getFooter(); @Override byte[] getHeader(); @Override String getContentType(); @Override Map<String, String> getContentFormat(); @PluginBuilderFactory @SuppressWarnings("WeakerAccess") static Builder newBuilder(); }### Answer: @Test public void test_lineSeparator_suffix() { SimpleMessage message = new SimpleMessage("Hello, World!"); LogEvent logEvent = Log4jLogEvent .newBuilder() .setLoggerName(LogstashLayoutTest.class.getSimpleName()) .setLevel(Level.INFO) .setMessage(message) .build(); test_lineSeparator_suffix(logEvent, true); test_lineSeparator_suffix(logEvent, false); }
### Question: MainActivity extends AppCompatActivity { @VisibleForTesting void initViews() { EditText weightText = (EditText)findViewById(R.id.text_weight); EditText heightText = (EditText)findViewById(R.id.text_height); TextView resultText = (TextView)findViewById(R.id.text_result); mCalcButton = (Button)findViewById(R.id.button_calculate); View.OnClickListener buttonListener = createButtonListener(weightText, heightText, resultText); mCalcButton.setOnClickListener(buttonListener); } }### Answer: @Test public void initViews를호출하면버튼의Listener가설정된다() { EditText weightText = mock(EditText.class); EditText heightText = mock(EditText.class); TextView resultText = mock(TextView.class); Button resultButton = mock(Button.class); View.OnClickListener buttonListener = mock(View.OnClickListener.class); MainActivity activity = spy(new MainActivity()); when(activity.findViewById(R.id.text_weight)).thenReturn(weightText); when(activity.findViewById(R.id.text_height)).thenReturn(heightText); when(activity.findViewById(R.id.text_result)).thenReturn(resultText); when(activity.findViewById(R.id.button_calculate)).thenReturn(resultButton); when(activity.createButtonListener(weightText, heightText, resultText)).thenReturn(buttonListener); activity.initViews(); verify(activity, times(1)).createButtonListener(weightText, heightText, resultText); verify(resultButton, times(1)).setOnClickListener(buttonListener); }
### Question: SaveBmiService extends IntentService { public static void start(Context context, BmiValue bmiValue) { Intent intent = new Intent(context, SaveBmiService.class); intent.putExtra(PARAM_KEY_BMI_VALUE, bmiValue); context.startService(intent); } SaveBmiService(); @Override void onCreate(); static void start(Context context, BmiValue bmiValue); static final String ACTION_RESULT; static final String PARAM_RESULT; }### Answer: @Test public void static인start메소드를호출하면startService된다() { Context context = mock(Context.class); SaveBmiService.start(context, mock(BmiValue.class)); verify(context, times(1)).startService((Intent) any()); }
### Question: BmiCalculator { public BmiValue calculate(float heightInMeter, float weightInKg) { if (heightInMeter < 0 \|\| weightInKg < 0) { throw new RuntimeException("키와 몸무게는 양수로 지정해주세요"); } float bmiValue = weightInKg / (heightInMeter * heightInMeter); return createValueObj(bmiValue); } BmiValue calculate(float heightInMeter, float weightInKg); }### Answer: @Test(expected = RuntimeException.class) public void 신장에음수값을넘기면예외가발생한다() { calculator.calculate(-1f, 60.0f);
### Question: BmiValue implements Serializable { public float toFloat() { int rounded = Math.round(mValue * 100); return rounded / 100f; } BmiValue(float value); float toFloat(); String getMessage(); }### Answer: @Test public void 생성시에전달한Float값을소수점2자리까지반올림해반환한다() { BmiValue bmiValue = new BmiValue(20.00511f); Assert.assertEquals(20.01f, bmiValue.toFloat()); } @Test public void 생성시에전달한Float값을소수점2자리까지버림해반환한다() { BmiValue bmiValue = new BmiValue(20.00499f); Assert.assertEquals(20.00f, bmiValue.toFloat()); }
### Question: DriverSettings extends AbstractPropSettings { public String getGeckcoDriverPath() { return getProperty("GeckoDriverPath", geckoDriverPath); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); }### Answer: @Test public void testGetGeckcoDriverPath() { String expResult; if (isWin) { expResult = "./lib/Drivers/geckodriver.exe"; } else { expResult = "./lib/Drivers/geckodriver"; } String result = ds.getGeckcoDriverPath(); assertEquals(result, expResult); }
### Question: FParser { public static String evaljs(String script) { try { return JS.eval("JSON.stringify(" + script + ")").toString(); } catch (ScriptException ex) { LOG.log(Level.SEVERE, ex.getMessage(), ex); } return "undefined"; } static List<String> getFuncList(); static Object eval(String s); static String evaljs(String script); static List<String> FUNCTIONS; }### Answer: @Test(invocationCount = 10) public void testEvaljs() { System.out.println("Evaljs"); String script = "floor(100 + random() * 900)"; String result = FParser.evaljs(script); assertTrue(result.matches("[0-9]{3}"), "Test random "); script = "'test'+ floor(100 + random() * 900)+'[email protected]'"; result = (String) JSONValue.parse(FParser.evaljs(script)); assertTrue(result.matches("test[0-9]{3}[email protected]"), "Test random email "); }
### Question: KeyMap { public static String resolveContextVars(String in, Map<?,?> vMap) { return replaceKeys(in, CONTEXT_VARS, true, 1, vMap); } static Map<Object, Object> getSystemVars(); static String resolveContextVars(String in, Map<?,?> vMap); static String resolveEnvVars(String in); static String replaceKeys(String in, Pattern pattern, boolean preserveKeys, int passes, Map<?,?>... maps); static String replaceKeys(String in, Pattern p); static String resolveSystemVars(String in); static final Pattern CONTEXT_VARS; static final Pattern ENV_VARS; static final Pattern USER_VARS; }### Answer: @Test public void testResolveContextVars() { System.out.println("resolveContextVars"); String in = "this is a {scenario}/{testset} -> {testset}/{release} for {project}.{release}.{testcase} "; String expResult = "this is a myscn/ts -> ts/rel for pro.rel.tc "; String result = KeyMap.resolveContextVars(in, vMap); assertEquals(expResult, result); }
### Question: KeyMap { public static String resolveEnvVars(String in) { return replaceKeys(in, ENV_VARS); } static Map<Object, Object> getSystemVars(); static String resolveContextVars(String in, Map<?,?> vMap); static String resolveEnvVars(String in); static String replaceKeys(String in, Pattern pattern, boolean preserveKeys, int passes, Map<?,?>... maps); static String replaceKeys(String in, Pattern p); static String resolveSystemVars(String in); static final Pattern CONTEXT_VARS; static final Pattern ENV_VARS; static final Pattern USER_VARS; }### Answer: @Test public void testResolveEnvVars() { System.out.println("resolveEnvVars"); String in = "${val.1}-${var.1}-${val.2}-${val.1}-${val.3}-${val.4}-${var.4}-${var.1}-${var.2}-"; String expResult = "1-x-b-1-c-val.4-var.4-x-y-"; String result = KeyMap.resolveEnvVars(in); assertEquals(expResult, result); }
### Question: ChromeEmulators { public static String getPrefLocation() { if (SystemUtils.IS_OS_WINDOWS) { return SystemUtils.getUserHome().getAbsolutePath() + "/AppData/Local/Google/Chrome/User Data/Default"; } if (SystemUtils.IS_OS_MAC_OSX) { return SystemUtils.getUserHome().getAbsolutePath()+"/Library/Application Support/Google/Chrome/Default"; } if (SystemUtils.IS_OS_LINUX) { return SystemUtils.getUserHome().getAbsolutePath()+"/.config/google-chrome/Default"; } return "OSNotConfigured"; } static void sync(); static String getPrefLocation(); static List<String> getEmulatorsList(); }### Answer: @Test(enabled = false) public void testGetPrefLocation() { System.out.println("getPrefLocation"); File file = new File(ChromeEmulators.getPrefLocation(), "Preferences"); if (!file.exists()) { System.out.println(file.getAbsolutePath()); System.out.println("------------------------"); Stream.of(file.listFiles()) .map(File::getAbsolutePath).forEach(System.out::println); fail("Unable to fine preference file"); } }
### Question: ChromeEmulators { public static void sync() { try { LOG.info("Trying to load emulators from Chrome Installation"); File file = new File(getPrefLocation(), "Preferences"); if (file.exists()) { Map map = MAPPER.readValue(file, Map.class); Map devtools = (Map) map.get("devtools"); Map prefs = (Map) devtools.get("preferences"); String stdemulators = (String) prefs.get("standardEmulatedDeviceList"); List list = MAPPER.readValue(stdemulators, List.class); EMULATORS.clear(); EMULATORS.addAll( (List<String>) list.stream() .map((device) -> { return ((Map) device).get("title"); }) .map((val) -> val.toString()) .collect(Collectors.toList())); saveList(); } else { LOG.severe("Either Chrome is not installed or OS not supported"); } } catch (IOException ex) { LOG.log(Level.SEVERE, null, ex); } } static void sync(); static String getPrefLocation(); static List<String> getEmulatorsList(); }### Answer: @Test(enabled = false) public void testSync() { System.out.println("sync"); ChromeEmulators.sync(); assertTrue(!ChromeEmulators.getEmulatorsList().isEmpty(), "EmulatorsList is Empty"); }
### Question: ChromeEmulators { public static List<String> getEmulatorsList() { load(); return EMULATORS; } static void sync(); static String getPrefLocation(); static List<String> getEmulatorsList(); }### Answer: @Test(enabled = false) public void testGetEmulatorsList() { System.out.println("getEmulatorsList"); List<String> result = ChromeEmulators.getEmulatorsList(); assertTrue(Stream.of("Nexus 5", "Galaxy S5", "Nexus 6P", "iPhone 5", "iPhone 6 Plus") .allMatch(result::contains), "Some/all emulators missing in the EmulatorsList" ); }
### Question: DriverSettings extends AbstractPropSettings { public String getChromeDriverPath() { return getProperty("ChromeDriverPath", chromeDriverPath); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); }### Answer: @Test public void testGetChromeDriverPath() { String expResult; if (isWin) { expResult = "./lib/Drivers/chromedriver.exe"; } else { expResult = "./lib/Drivers/chromedriver"; } String result = ds.getChromeDriverPath(); assertEquals(result, expResult); }
### Question: JIRAClient { public boolean isConnected() { try { DLogger.Log(client.Get(new URL(client.url + PROJECT)).toString()); return true; } catch (Exception ex) { LOG.log(Level.SEVERE, ex.getMessage(), ex); return false; } } JIRAClient(String urlStr, String userName, String password, Map options); int updateResult(int status, String tc, String ts, String rc, String proj); void updateResult(int status, int eid); String addAttachment(int eid, File attachment); @SuppressWarnings("unchecked") JSONObject createIssue(JSONObject issue, List<File> attachments); @SuppressWarnings("unchecked") static JSONObject getJsonified(LinkedHashMap<String, String> dataMap); boolean containsProject(String project); boolean isConnected(); static final String ISSUE; }### Answer: @Test(enabled = false) public void testConnection() throws MalformedURLException { JIRASync sync = new JIRASync(Data.server, Data.uname, Data.pass, Data.project); Assert.assertTrue(sync.isConnected()); }
### Question: JIRAClient { @SuppressWarnings("unchecked") public JSONObject createIssue(JSONObject issue, List<File> attachments) { JSONObject res = null; try { res = client.post(new URL(client.url + ISSUE), issue.toString()); String restAttach = ISSUE_ATTACHMENTS.replace("issuekey", (String) res.get("id")); if (attachments != null && !attachments.isEmpty()) { List<JSONObject> attchRes = new ArrayList<>(); res.put("Attachments", attchRes); for (File f : attachments) { attchRes.add(client.post(new URL(client.url + restAttach), f)); } } else { LOG.log(Level.INFO, "no attachments to upload"); } LOG.log(Level.INFO, "issue response {0}", res.toString()); } catch (Exception ex) { LOG.log(Level.SEVERE, ex.getMessage(), ex); } return res; } JIRAClient(String urlStr, String userName, String password, Map options); int updateResult(int status, String tc, String ts, String rc, String proj); void updateResult(int status, int eid); String addAttachment(int eid, File attachment); @SuppressWarnings("unchecked") JSONObject createIssue(JSONObject issue, List<File> attachments); @SuppressWarnings("unchecked") static JSONObject getJsonified(LinkedHashMap<String, String> dataMap); boolean containsProject(String project); boolean isConnected(); static final String ISSUE; }### Answer: @Test(enabled = false) public void testCreateIssue_JSONObject_List() throws MalformedURLException { JSONObject res = null; JIRAClient jc = new JIRAClient(Data.server, Data.uname, Data.pass, null); Map issue = getIssue(Data.project); List<File> attach = null; res = jc.createIssue((JSONObject) issue, attach); }
### Question: DriverSettings extends AbstractPropSettings { public String getIEDriverPath() { return getProperty("IEDriverPath", "./lib/Drivers/IEDriverServer.exe"); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); }### Answer: @Test public void testGetIEDriverPath() { String expResult = "./lib/Drivers/IEDriverServer.exe"; String result = ds.getIEDriverPath(); assertEquals(result, expResult); }
### Question: DriverSettings extends AbstractPropSettings { public String getEdgeDriverPath() { return getProperty("EdgeDriverPath", "./lib/Drivers/MicrosoftWebDriver.exe"); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); }### Answer: @Test public void testGetEdgeDriverPath() { String expResult = "./lib/Drivers/MicrosoftWebDriver.exe"; String result = ds.getEdgeDriverPath(); assertEquals(result, expResult); }
### Question: DriverSettings extends AbstractPropSettings { public void setGeckcoDriverPath(String path) { setProperty("GeckoDriverPath", path); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); }### Answer: @Test public void testSetGeckcoDriverPath() { String path = "./lib/gk"; ds.setGeckcoDriverPath(path); assertEquals(ds.getGeckcoDriverPath(), path); }
### Question: DriverSettings extends AbstractPropSettings { public void setChromeDriverPath(String path) { setProperty("ChromeDriverPath", path); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); }### Answer: @Test public void testSetChromeDriverPath() { String path = "./lib/chrome"; ds.setChromeDriverPath(path); assertEquals(ds.getChromeDriverPath(), path); }
### Question: DriverSettings extends AbstractPropSettings { public void setIEDriverPath(String path) { setProperty("IEDriverPath", path); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); }### Answer: @Test public void testSetIEDriverPath() { String path = "./lib/ie"; ds.setIEDriverPath(path); assertEquals(ds.getIEDriverPath(), path); }
### Question: DriverSettings extends AbstractPropSettings { public void setEdgeDriverPath(String path) { setProperty("EdgeDriverPath", path); } DriverSettings(String location); void setFirefoxBinaryPath(String path); void setGeckcoDriverPath(String path); void setChromeDriverPath(String path); void setIEDriverPath(String path); void setEdgeDriverPath(String path); String getFirefoxBinaryPath(); String getGeckcoDriverPath(); String getChromeDriverPath(); String getIEDriverPath(); String getEdgeDriverPath(); Boolean useProxy(); }### Answer: @Test public void testSetEdgeDriverPath() { String path = "./lib/edge"; ds.setEdgeDriverPath(path); assertEquals(ds.getEdgeDriverPath(), path); }
### Question: FParser { public static List<String> getFuncList() { return FUNCTIONS; } static List<String> getFuncList(); static Object eval(String s); static String evaljs(String script); static List<String> FUNCTIONS; }### Answer: @Test public void testGetFuncList() { System.out.println("getFuncList"); String[] vals = {"Concat", "Random", "Round", "Pow", "Min", "Max", "Date"}; List<String> expResult = Arrays.asList(vals); Collections.sort(expResult); List<String> result = FParser.getFuncList(); Collections.sort(result); assertEquals(expResult.toString(), result.toString()); }
### Question: KeyLockManager { public static KeyLock getKeyLock(String type) { return keyLockMap.get(type); } static void init(String[] types, int keyLockExpireTime, int keyLockCycleSleepTime, ILog log); static KeyLock getKeyLock(String type); static Object lockMethod(String lockKey, String keyType, KeylockFunction func, Object... params); static Object lockMethod(String lockKey1, String lockKey2, String keyType, KeylockFunction func, Object... params); static int KEY_LOCK_EXPIRE_TIME; static int KEY_LOCK_CYCLE_SLEEP_TIME; static Map<String, KeyLock> keyLockMap; }### Answer: @Test public void testGetKeyLock() { KeyLock keylock = KeyLockManager.getKeyLock(TEST1); assertEquals(true, keylock != null); } @Test public void testLockPartOneKey() { boolean isKeyLockException = false; KeyLock keyLock = KeyLockManager.getKeyLock(TEST1); String lockKey = "111"; boolean result = false; try { keyLock.lock(lockKey); result = true; } catch (KeyLockException e) { isKeyLockException = true; } catch (Exception e) { } finally { if (!isKeyLockException) { keyLock.unlock(lockKey); } else { } } assertEquals(true, result); } @Test public void testLockPartTwoKey() { boolean isKeyLockException = false; KeyLock keyLock = KeyLockManager.getKeyLock(TEST1); String lockKey1 = "11"; String lockKey2 = "22"; boolean result = false; try { keyLock.lock(lockKey1, lockKey2); result = true; } catch (KeyLockException e) { isKeyLockException = true; } catch (Exception e) { } finally { if (!isKeyLockException) { keyLock.unlock(lockKey1, lockKey2); } else { } } assertEquals(true, result); }
### Question: RunMonitor { public void putMonitor(String content) { long time = System.currentTimeMillis(); contentList.add(content); timeList.add(time); } RunMonitor(String type, String opCode); void putMonitor(String content); String toString(String opCode); @Override String toString(); }### Answer: @Test public void testPutMonitor() { runMonitor.putMonitor("链接"); runMonitor.putMonitor("发送"); runMonitor.putMonitor("断开"); }
### Question: ThreadMsgManager { public static boolean addMapping(String msgOpCode, int[] threadPriority) { if (msgOpcodeType.containsKey(msgOpCode)) { return false; } if (threadPriority != null) { msgOpcodeType.put(msgOpCode, threadPriority); } return true; } static boolean addMapping(String msgOpCode, int[] threadPriority); static boolean dispatchThreadMsg(String msgOpCode, Object data, Object otherData); static HashMap<String, int[]> msgOpcodeType; }### Answer: @Test public void testAddMapping() throws InterruptedException { ThreadMsgManager.dispatchThreadMsg("createuser", 111, 222); ThreadMsgManager.dispatchThreadMsg("updateuser", 111, 222); Thread.sleep(1000); }
### Question: KeyLockManager { public static Object lockMethod(String lockKey, String keyType, KeylockFunction func, Object... params) { boolean isKeyLockException = false; KeyLock keyLock = KeyLockManager.getKeyLock(keyType); try { keyLock.lock(lockKey); return func.apply(params); } catch (KeyLockException e) { isKeyLockException = true; if (KeyLockManager.log != null) { KeyLockManager.log.error("keylock自定义异常", e); } } catch (Exception e) { if (KeyLockManager.log != null) { KeyLockManager.log.error("业务异常", e); } } finally { if (!isKeyLockException) { keyLock.unlock(lockKey); } else { } } return null; } static void init(String[] types, int keyLockExpireTime, int keyLockCycleSleepTime, ILog log); static KeyLock getKeyLock(String type); static Object lockMethod(String lockKey, String keyType, KeylockFunction func, Object... params); static Object lockMethod(String lockKey1, String lockKey2, String keyType, KeylockFunction func, Object... params); static int KEY_LOCK_EXPIRE_TIME; static int KEY_LOCK_CYCLE_SLEEP_TIME; static Map<String, KeyLock> keyLockMap; }### Answer: @Test public void testLockMethodOneKey() { String str = (String) KeyLockManager.lockMethod("111", TEST1, (params) -> lockFunction(params), new Object[] { "222", 111 }); assertEquals("222111", str); } @Test public void testLockMethodTwoKey() { String str = (String) KeyLockManager.lockMethod("111", "222", TEST1, (params) -> lockFunction(params), new Object[] { "222", 111 }); assertEquals("222111", str); }
### Question: AsyncThreadManager { public static boolean addHandle(IHandle handle, int threadId, int priority) { if (handle == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("handle为空"); } return false; } AsyncThread asyncThread = asyncThreadMap.get(threadId); if (asyncThread == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在线程id：" + threadId); } return false; } AsyncHandleData asyncHandleData = asyncThread.asyncHandleDataMap.get(priority); if (asyncHandleData == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在优先级：" + priority); } return false; } try { asyncHandleData.waitHandleQueue.put(handle); return true; } catch (InterruptedException e) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.error("放入handle至异步线程列队失败", e); } return false; } } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer: @Test public void testAddHandle() throws NoSuchMethodException, SecurityException, InterruptedException { PacketTest packetTest = new PacketTest(); Method method = HandlerManagerTest.class.getMethod("handle", new Class[] { Object.class }); ThreadHandle threadHandle = new ThreadHandle(packetTest, method, null); boolean result = AsyncThreadManager.addHandle(threadHandle, 1, 1); Thread.sleep(1000); assertEquals(true, result); }
### Question: AsyncThreadManager { public static boolean addCycle(ICycle cycle, int threadId, int priority) { if (cycle == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("ICycle为空"); } return false; } AsyncThread asyncThread = asyncThreadMap.get(threadId); if (asyncThread == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在线程id：" + threadId); } return false; } AsyncHandleData asyncHandleData = asyncThread.asyncHandleDataMap.get(priority); if (asyncHandleData == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在优先级：" + priority); } return false; } try { asyncHandleData.waitAddCycleQueue.put(cycle); return true; } catch (InterruptedException e) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.error("放入ICycle至异步线程列队失败", e); } return false; } } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer: @Test public void testAddCycle() { CycleTest cycleTest = new CycleTest(); cycleTest.name = "testAddCycle"; boolean result = AsyncThreadManager.addCycle(cycleTest, 1, 1); assertEquals(true, result); }
### Question: AsyncThreadManager { public static boolean removeCycle(ICycle cycle, int threadId, int priority) { if (cycle == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("ICycle为空"); } return false; } AsyncThread asyncThread = asyncThreadMap.get(threadId); if (asyncThread == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在线程id：" + threadId); } return false; } AsyncHandleData asyncHandleData = asyncThread.asyncHandleDataMap.get(priority); if (asyncHandleData == null) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.warn("不存在优先级：" + priority); } return false; } try { asyncHandleData.waitRemoveCycleQueue.put(cycle); return true; } catch (InterruptedException e) { if (AsyncThreadManager.log != null) { AsyncThreadManager.log.error("移除ICycle至异步线程列队失败", e); } return false; } } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer: @Test public void testRemoveCycle() { CycleTest cycleTest = new CycleTest(); cycleTest.name = "testRemoveCycle"; boolean result = AsyncThreadManager.addCycle(cycleTest, 1, 1); result = AsyncThreadManager.removeCycle(cycleTest, 1, 1); assertEquals(true, result); }
### Question: AsyncThreadManager { public static int[] getRandomThreadPriority() { int thread = (int) (Math.random() * (asyncThreadNum - lockThreadNum) + 1); int priority = (int) (Math.random() * asyncThreadPriorityNum + 1); return new int[] { thread, priority }; } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer: @Test public void testGetRandomThreadPriority() { int[] threadPriority = AsyncThreadManager.getRandomThreadPriority(); assertEquals(true, threadPriority != null); }
### Question: AsyncThreadManager { public static int[] getRandomThread() { int thread = (int) (Math.random() * (asyncThreadNum - lockThreadNum) + 1); return new int[] { thread, 1 }; } static void init(int asyncThreadCycleInterval, int asyncThreadNum, int asyncThreadPriorityNum, int lockThreadNum, ILog log); static boolean addHandle(IHandle handle, int threadId, int priority); static boolean addCycle(ICycle cycle, int threadId, int priority); static boolean removeCycle(ICycle cycle, int threadId, int priority); static int[] getRandomThreadPriority(); static int[] getRandomThread(); static int[] getLockThreadPriority(int lockNum); static void start(); }### Answer: @Test public void testGetRandomThread() { int[] threadPriority = AsyncThreadManager.getRandomThread(); assertEquals(true, threadPriority != null); }
### Question: RemoveIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) return false; Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, indexToBeRemoved)) { return false; } } return true; } RemoveIndex(String tableName, Index index); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getIndexToBeRemoved(); }### Answer: @Test public void testRemovingIndexFromNonExistentTable() { Schema testSchema = schema(appleTable); removeIndex = new RemoveIndex("Sweets", index("Sweets_1").unique().columns("pieces")); removeIndex.isApplied(testSchema, MockConnectionResources.build()); } @Test public void testRemovingIndexFromExistingTable() { Schema testSchema = schema(appleTable); removeIndex.isApplied(testSchema, MockConnectionResources.build()); }
### Question: RenameTable implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, oldTableName, newTableName); } RenameTable(String oldTableName, String newTableName); String getOldTableName(); String getNewTableName(); @Override Schema apply(Schema schema); @Override Schema reverse(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override void accept(SchemaChangeVisitor visitor); }### Answer: @Test(expected = IllegalArgumentException.class) public void testRenameTableNotExists() { Schema testSchema = schema(appleTable); RenameTable renameTable = new RenameTable("Pear", "Apple"); renameTable.apply(testSchema); } @Test(expected = IllegalArgumentException.class) public void testRenameTableAlreadyExists() { Schema testSchema = schema(appleTable, orangeTable); RenameTable renameTable = new RenameTable("Apple", "Orange"); renameTable.apply(testSchema); }
### Question: AuditRecordHelper { public static void addAuditRecord(SchemaChangeVisitor visitor, Schema schema, UUID uuid, String description) { if (!schema.tableExists("UpgradeAudit")) return; InsertStatement auditRecord = createAuditInsertStatement(uuid, description); visitor.visit(new ExecuteStatement(auditRecord)); } static void addAuditRecord(SchemaChangeVisitor visitor, Schema schema, UUID uuid, String description); static InsertStatement createAuditInsertStatement(UUID uuid, String description); }### Answer: @Test public void testAddAuditRecord() throws ParseException { SchemaChangeVisitor visitor = mock(SchemaChangeVisitor.class); Schema schema = mock(Schema.class); UUID uuid = UUID.randomUUID(); String description = "Description"; given(schema.tableExists("UpgradeAudit")).willReturn(true); AuditRecordHelper.addAuditRecord(visitor, schema, uuid, description); ArgumentCaptor<ExecuteStatement> argument = ArgumentCaptor.forClass(ExecuteStatement.class); verify(visitor).visit(argument.capture()); InsertStatement statement = (InsertStatement) argument.getValue().getStatement(); assertAuditInsertStatement(uuid, description, statement); }
### Question: AuditRecordHelper { public static InsertStatement createAuditInsertStatement(UUID uuid, String description) { InsertStatement auditRecord = new InsertStatement().into( new TableReference("UpgradeAudit")).values( new FieldLiteral(uuid.toString()).as("upgradeUUID"), new FieldLiteral(description).as("description"), cast(dateToYyyyMMddHHmmss(now())).asType(DataType.DECIMAL, 14).as("appliedTime") ); return auditRecord; } static void addAuditRecord(SchemaChangeVisitor visitor, Schema schema, UUID uuid, String description); static InsertStatement createAuditInsertStatement(UUID uuid, String description); }### Answer: @Test public void createAuditInsertStatement() throws Exception { UUID uuid = UUID.randomUUID(); String description = "Description"; InsertStatement statement = AuditRecordHelper.createAuditInsertStatement(uuid, description); assertAuditInsertStatement(uuid, description, statement); }
### Question: ChangeIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toIndex, fromIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getFromIndex(); Index getToIndex(); }### Answer: @Test public void testReverseChangeColumnType() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_3").unique().columns("colour", "pips"), index("Apple_3").columns("pips")); Schema updatedSchema = changeIndex.reverse(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 3, resultTable.indexes().size()); Index indexThree = resultTable.indexes().get(2); assertEquals("Post upgrade existing index 3 column count", 2, indexThree.columnNames().size()); assertEquals("Post upgrade existing index 3 uniqueness", true, indexThree.isUnique()); }
### Question: ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, toIndex)) { return true; } } return false; } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getFromIndex(); Index getToIndex(); }### Answer: @Test public void testChangeIndexOnNonExistentTable() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Sweets", index("Sweets_1").unique().columns("pieces"), index("Sweets_1").unique().columns("pieces")); changeIndex.isApplied(testSchema, MockConnectionResources.build()); } @Test public void testChangeIndexOnExistingTable() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), index("Apple_1").unique().columns("pips")); changeIndex.isApplied(testSchema, MockConnectionResources.build()); }
### Question: InlineTableUpgrader implements SchemaChangeVisitor { public void preUpgrade() { sqlStatementWriter.writeSql(sqlDialect.tableDeploymentStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUpgrade(); void postUpgrade(); @Override void visit(AddTable addTable); @Override void visit(RemoveTable removeTable); @Override void visit(AddIndex addIndex); @Override void visit(AddColumn addColumn); @Override void visit(ChangeColumn changeColumn); @Override void visit(RemoveColumn removeColumn); @Override void visit(RemoveIndex removeIndex); @Override void visit(ChangeIndex changeIndex); @Override void visit(final RenameIndex renameIndex); @Override void visit(ExecuteStatement executeStatement); @Override void visit(RenameTable renameTable); @Override void visit(ChangePrimaryKeyColumns changePrimaryKeyColumns); @Override void addAuditRecord(UUID uuid, String description); @Override void startStep(Class<? extends UpgradeStep> upgradeClass); @Override void visit(AddTableFrom addTableFrom); @Override void visit(AnalyseTable analyseTable); }### Answer: @Test public void testPreUpgrade() { final ArgumentCaptor<Table> captor = ArgumentCaptor.forClass(Table.class); upgrader.preUpgrade(); verify(sqlDialect).tableDeploymentStatements(captor.capture()); assertTrue("Temporary table", captor.getValue().isTemporary()); }
### Question: InlineTableUpgrader implements SchemaChangeVisitor { public void postUpgrade() { sqlStatementWriter.writeSql(sqlDialect.truncateTableStatements(idTable)); sqlStatementWriter.writeSql(sqlDialect.dropStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUpgrade(); void postUpgrade(); @Override void visit(AddTable addTable); @Override void visit(RemoveTable removeTable); @Override void visit(AddIndex addIndex); @Override void visit(AddColumn addColumn); @Override void visit(ChangeColumn changeColumn); @Override void visit(RemoveColumn removeColumn); @Override void visit(RemoveIndex removeIndex); @Override void visit(ChangeIndex changeIndex); @Override void visit(final RenameIndex renameIndex); @Override void visit(ExecuteStatement executeStatement); @Override void visit(RenameTable renameTable); @Override void visit(ChangePrimaryKeyColumns changePrimaryKeyColumns); @Override void addAuditRecord(UUID uuid, String description); @Override void startStep(Class<? extends UpgradeStep> upgradeClass); @Override void visit(AddTableFrom addTableFrom); @Override void visit(AnalyseTable analyseTable); }### Answer: @Test public void testPostUpgrade() { final ArgumentCaptor<Table> truncateCaptor = ArgumentCaptor.forClass(Table.class); final ArgumentCaptor<Table> dropCaptor = ArgumentCaptor.forClass(Table.class); upgrader.postUpgrade(); verify(sqlDialect).truncateTableStatements(truncateCaptor.capture()); verify(sqlDialect).dropStatements(dropCaptor.capture()); assertTrue("Truncate temporary table", truncateCaptor.getValue().isTemporary()); assertTrue("Drop temporary table", dropCaptor.getValue().isTemporary()); }
### Question: InlineTableUpgrader implements SchemaChangeVisitor { private void visitStatement(Statement statement) { writeStatements(sqlDialect.convertStatementToSQL(statement, currentSchema, idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUpgrade(); void postUpgrade(); @Override void visit(AddTable addTable); @Override void visit(RemoveTable removeTable); @Override void visit(AddIndex addIndex); @Override void visit(AddColumn addColumn); @Override void visit(ChangeColumn changeColumn); @Override void visit(RemoveColumn removeColumn); @Override void visit(RemoveIndex removeIndex); @Override void visit(ChangeIndex changeIndex); @Override void visit(final RenameIndex renameIndex); @Override void visit(ExecuteStatement executeStatement); @Override void visit(RenameTable renameTable); @Override void visit(ChangePrimaryKeyColumns changePrimaryKeyColumns); @Override void addAuditRecord(UUID uuid, String description); @Override void startStep(Class<? extends UpgradeStep> upgradeClass); @Override void visit(AddTableFrom addTableFrom); @Override void visit(AnalyseTable analyseTable); }### Answer: @Test public void testVisitStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); Statement statement = mock(Statement.class); given(executeStatement.getStatement()).willReturn(statement); when(sqlDialect.convertStatementToSQL(eq(statement), any(Schema.class), any(Table.class))).thenCallRealMethod(); try { upgrader.visit(executeStatement); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException e) { } }
### Question: RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; } } return false; } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); String getFromIndexName(); String getToIndexName(); }### Answer: @Test public void testRenameIndexOnNonExistentTable() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Sweets", "Sweets_1", "Sweets_2"); assertFalse("Should not be applied", renameIndex.isApplied(testSchema, MockConnectionResources.build())); } @Test public void testRenameIndexOnNonExistentIndex() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_3", "Apple_4"); assertFalse("Should not be applied", renameIndex.isApplied(testSchema, MockConnectionResources.build())); }
### Question: RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); String getFromIndexName(); String getToIndexName(); }### Answer: @Test(expected = IllegalArgumentException.class) public void testRenameIndexNoFromName() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", " ", "Apple_3"); renameIndex.apply(testSchema); } @Test(expected = IllegalArgumentException.class) public void testRenameIndexNoToName() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_1", " "); renameIndex.apply(testSchema); } @Test(expected = IllegalArgumentException.class) public void testRenameIndexNotExists() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_3", "Apple_4"); renameIndex.apply(testSchema); } @Test(expected = IllegalArgumentException.class) public void testRenameIndexAlreadyExists() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_1", "Apple_2"); renameIndex.apply(testSchema); }
### Question: AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundAndRemovedIndex = true; } else { indexeNames.add(index.getName()); } } if (!foundAndRemovedIndex) { throw new IllegalStateException("Error reversing AddIndex database change. Index [" + newIndex.getName() + "] not found in table [" + tableName + "] so it could not be reversed out"); } return new TableOverrideSchema(schema, new AlteredTable(original, null, null, indexeNames, null)); } AddIndex(String tableName, Index index); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getNewIndex(); }### Answer: @Test public void testReverseAddingIndex() { appleTable = table("Apple").columns( column("pips", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 10).nullable() ).indexes( index("Apple_1").unique().columns("pips") ); Schema testSchema = schema(appleTable); Schema downGradedSchema = addIndex.reverse(testSchema); Table resultTable = downGradedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 0, resultTable.indexes().size()); } @Test public void testRemovingNonExistantIndex() { Schema testSchema = schema(appleTable); try { addIndex.reverse(testSchema); fail("Should fail since index is not there"); } catch (Exception e) { } }
### Question: AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, newIndex)) { return true; } } return false; } AddIndex(String tableName, Index index); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Schema schema, ConnectionResources database); @Override Schema reverse(Schema schema); String getTableName(); Index getNewIndex(); }### Answer: @Test public void testAddIndexToNonExistentTable() { Schema testSchema = schema(appleTable); addIndex = new AddIndex("Sweets", index("Sweets_1").unique().columns("pieces")); assertFalse("Index should not have been applied", addIndex.isApplied(testSchema, MockConnectionResources.build())); } @Test public void testAddIndexToExistingTable() { Schema testSchema = schema(appleTable); assertFalse("Index should not have been applied", addIndex.isApplied(testSchema, MockConnectionResources.build())); }
### Question: TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } TableSetSchema(Collection<Table> tables); @Override Collection<Table> tables(); @Override Table getTable(final String name); @Override boolean isEmptyDatabase(); @Override boolean tableExists(final String name); @Override Collection<String> tableNames(); @Override boolean viewExists(String name); @Override View getView(String name); @Override Collection<String> viewNames(); @Override Collection<View> views(); }### Answer: @Test public void testTableExists() { assertTrue(schema.tableExists("Apple")); assertFalse(schema.tableExists("Peach")); } @Test public void testTableExistsNotCaseSensitive() { assertTrue(schema.tableExists("APPLE")); assertTrue(schema.tableExists("apple")); }
### Question: TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<Table> tables); @Override Collection<Table> tables(); @Override Table getTable(final String name); @Override boolean isEmptyDatabase(); @Override boolean tableExists(final String name); @Override Collection<String> tableNames(); @Override boolean viewExists(String name); @Override View getView(String name); @Override Collection<String> viewNames(); @Override Collection<View> views(); }### Answer: @Test public void testGetTable() { final String tableName = "Apple"; Table appleTable = schema.getTable(tableName); assertNotNull(appleTable); assertEquals(tableName, appleTable.getName()); } @Test public void testGetTableCaseInsensitive() { final String tableName = "Apple"; Table uppercaseTable = schema.getTable(tableName.toUpperCase()); Table lowercaseTable = schema.getTable(tableName.toLowerCase()); assertNotNull(uppercaseTable); assertNotNull(lowercaseTable); } @Test(expected = RuntimeException.class) public void testGetTableWhenTableDoesntExist() { final String wrongTable = "Peach"; schema.getTable(wrongTable); }
### Question: Escaping { static String escapeCharacters(String recordValue) { int last = 0; StringBuilder escapedValue = new StringBuilder(recordValue.length()); for (int i=0; i<recordValue.length(); i++) { if (!isCharValidForXml(recordValue.charAt(i))) { escapedValue.append(recordValue.substring(last, i)); escapedValue.append(String.format("\\u%04x", (int)recordValue.charAt(i))); last=i+1; } if (recordValue.charAt(i) == '\\') { escapedValue.append(recordValue.substring(last, i)); escapedValue.append("\\\\"); last=i+1; } } escapedValue.append(recordValue.substring(last, recordValue.length())); return escapedValue.toString(); } }### Answer: @Test public void testEscapeCharacters() { for (TestCase testCase : testCases) { assertEquals(testCase.escaped, escapeCharacters(testCase.unescaped)); } }
### Question: Escaping { static String unescapeCharacters(String attributeValue) { if (attributeValue == null) return null; char[] attributeChars = attributeValue.toCharArray(); StringBuilder result = new StringBuilder(attributeChars.length); int from = 0; int len = 0; int i = 0; while (i < attributeChars.length) { if (attributeChars[i] == '\\') { result.append(attributeChars, from, len); len = 0; switch(attributeChars[i+1]) { case '\\' : result.append('\\'); i++; break; case '0' : result.append((char) 0); i++; break; case 'u' : result.append(decodeEscapedCharacter(attributeChars, i)); i+=5; break; default: throw new IllegalStateException("Illegal escape sequence at char [" + i + "] in [" + attributeValue + "]"); } from = i+1; } else { len++; } i++; } result.append(attributeChars, from, len); return result.toString(); } }### Answer: @Test public void testUnescapeCharacters() { for (TestCase testCase : testCases) { assertEquals(testCase.unescaped, unescapeCharacters(testCase.escaped)); } assertEquals(string('a', 'b', 'c', (char) 0), unescapeCharacters("abc\0")); assertEquals(string('a', 'b', 'c', (char) 0), unescapeCharacters("abc\u0000")); }
### Question: DataMaskingXmlDataSetConsumer extends XmlDataSetConsumer { @Override protected String getValue(Record record, Column column, String table) { if (tableColumnsToMask.containsKey(table) && tableColumnsToMask.get(table).contains(column.getName())) { return null; } return super.getValue(record, column, table); } DataMaskingXmlDataSetConsumer(File file, Map<String, Set<String>> tableColumnsToMask); DataMaskingXmlDataSetConsumer(XmlOutputStreamProvider xmlOutputStreamProvider, Map<String, Set<String>> tableColumnsToMask); }### Answer: @Test public void getValue() { DummyXmlOutputStreamProvider dummyXmlOutputStreamProvider = new DummyXmlOutputStreamProvider(); DataSetConsumer testConsumer = new DataMaskingXmlDataSetConsumer(dummyXmlOutputStreamProvider, toMask); Table metaData = table("Test").columns( column("id", DataType.BIG_INTEGER).primaryKey().autoNumbered(123), versionColumn(), column("bar", DataType.STRING, 10).nullable(), column("baz", DataType.STRING, 10).nullable(), column("bob", DataType.DECIMAL, 13, 2).nullable() ).indexes( index("fizz").unique().columns("bar", "baz") ); testConsumer.open(); List<Record> mockRecords = new ArrayList<>(); mockRecords.add(record() .setInteger("id", 1) .setInteger("version", 1) .setString("bar", "abc") .setString("baz", "123") .setString("bob", "456.78")); testConsumer.table(metaData, mockRecords); testConsumer.close(CloseState.COMPLETE); assertEquals("Serialised data set", SourceXML.MASKED_SAMPLE, dummyXmlOutputStreamProvider.getXmlString().trim()); }
### Question: SchemaUtils { public static List<String> toUpperCase(List<String> listOfStrings) { return FluentIterable.from(listOfStrings).transform(new Function<String, String>() { @Override public String apply(String value) { return value.toUpperCase(); } }).toList(); } private SchemaUtils(); static Column idColumn(); static Column versionColumn(); static Schema schema(); static Schema schema(Table... tables); static Schema schema(View... views); static Schema schema(Iterable<Table> tables); static Schema schema(Collection<View> views); static Schema schema(Schema... schema); static Schema copy(Schema schema); static Schema copy(Schema schema, Collection<String> exclusionRegExes); static TableBuilder table(String name); static Table copy(Table table); static Index copy(Index index); static ColumnBuilder column(String name, DataType type, int width, int scale); static ColumnBuilder column(String name, DataType type, int width); static ColumnBuilder column(String name, DataType type); static ColumnBuilder column(Column column); static Column autonumber(String name, int startFrom); static IndexBuilder index(String name); static View view(String viewName, SelectStatement selectStatement, String... dependencies); static View copy(View view); static ColumnType type(DataType type); static ColumnType type(DataType type, int width); static ColumnType type(DataType type, int width, int scale); static ColumnType type(DataType type, int width, int scale, boolean nullable); static List<Column> primaryKeysForTable(Table table); static List<Column> autoNumbersForTable(Table table); static List<String> namesOfColumns(List<Column> columns); static List<String> toUpperCase(List<String> listOfStrings); }### Answer: @Test public void testToUpperCase() { assertEquals( Arrays.asList("ONE", "TWO", "THREE"), SchemaUtils.toUpperCase(Arrays.asList("One", "two", "thReE")) ); }
### Question: CompositeSchema implements Schema { @Override public Table getTable(String name) { for (Schema schema : delegates) if (schema.tableExists(name)) return schema.getTable(name); throw new IllegalArgumentException("Unknown table [" + name + "]"); } CompositeSchema(Schema... schema); @Override boolean isEmptyDatabase(); @Override boolean tableExists(String name); @Override Table getTable(String name); @Override Collection<String> tableNames(); @Override Collection<Table> tables(); @Override boolean viewExists(String name); @Override View getView(String name); @Override Collection<String> viewNames(); @Override Collection<View> views(); @Override String toString(); }### Answer: @Test public void testOrdering() { assertSame("Bar table", schema1.getTable("Bar"), new CompositeSchema(schema1, schema2).getTable("Bar")); }
### Question: TableHelper { public static Column columnWithName(Table table, String columnName) { for (Column currentColumn : table.columns()) { if (currentColumn.getName().equalsIgnoreCase(columnName)) { return currentColumn; } } return null; } static Column columnWithName(Table table, String columnName); static List<String> buildColumnNameList(Table table); static Index indexWithName(Table table, String indexName); }### Answer: @Test public void testColumnWithName() { String columnName = "columnName"; Table table = table("tableName").columns( idColumn(), versionColumn(), column(columnName, DataType.STRING, 10).nullable() ); assertEquals("Incorrect column", TableHelper.columnWithName(table, columnName).getName(), columnName); }
### Question: TableHelper { public static Index indexWithName(Table table, String indexName) { for (Index currentIndex : table.indexes()) { if (currentIndex.getName().equalsIgnoreCase(indexName)) { return currentIndex; } } return null; } static Column columnWithName(Table table, String columnName); static List<String> buildColumnNameList(Table table); static Index indexWithName(Table table, String indexName); }### Answer: @Test public void testIndexWithName() { String indexName = "indexName"; Table table = table("tableName").indexes(index(indexName)); assertEquals("Incorrect index", TableHelper.indexWithName(table, indexName).getName(), indexName); }
### Question: TableHelper { public static List<String> buildColumnNameList(Table table) { List<String> result = new ArrayList<String>(); for (Column currentColumn : table.columns()) { result.add(currentColumn.getName()); } return result; } static Column columnWithName(Table table, String columnName); static List<String> buildColumnNameList(Table table); static Index indexWithName(Table table, String indexName); }### Answer: @Test public void testBuildColumnNameList() { Table table = table("tableName").columns( idColumn(), versionColumn(), column("columnName1", DataType.STRING, 10).nullable(), column("columnName2", DataType.STRING, 10).nullable() ); assertEquals("Column list", Arrays.asList("id", "version", "columnName1", "columnName2"), TableHelper.buildColumnNameList(table)); }
### Question: SpreadsheetDataSetProducer implements DataSetProducer { private List<Record> getRecords(Sheet sheet) { try { long id = 1; int row = findHeaderRow(sheet); final Map<String, Integer> columnHeadingsMap = new HashMap<>(); for (int i = 0; i < countHeadings(sheet, row); i++) { columnHeadingsMap.put(columnName(sheet.getCell(i, row).getContents()), i); } final int translationColumn = getTranslationsColumnIndex(sheet, row); row++; List<Record> records = new LinkedList<>(); for (; row < sheet.getRows(); row++) { final Cell[] cells = sheet.getRow(row); if (allBlank(cells)) { break; } records.add(createRecord(id++, columnHeadingsMap, translationColumn, cells)); } return records; } catch (Exception e) { throw new RuntimeException("Failed to parse worksheet [" + sheet.getName() + "]", e); } } SpreadsheetDataSetProducer(final InputStream... excelFiles); @Override Schema getSchema(); @Override void open(); @Override void close(); @Override Iterable<Record> records(String tableName); @Override boolean isTableEmpty(String tableName); }### Answer: @Test public void testGetRecords() throws URISyntaxException { final SpreadsheetDataSetProducer producer = produceTestSpreadsheet(); List<Record> records = Lists.newArrayList(producer.records("UsageMeterType")); assertEquals("Number of rows [" + records + "]", 2, records.size()); Record record = records.get(0); assertEquals("Usage Meter", "KM", record.getString("usageMeter")); assertEquals("Description", "Kilometers", record.getString("description")); assertEquals("Usage Meter Type", "M", record.getString("usageMeterType")); record = records.get(1); assertEquals("Usage Meter", "HOUR", record.getString("usageMeter")); assertEquals("Description", "Hours", record.getString("description")); assertEquals("Usage Meter Type", "", record.getString("usageMeterType")); }
### Question: SchemaHomology { public boolean columnsMatch(Column column1, Column column2) { noDifferences = true; checkColumn(null, column1, column2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean schemasMatch(Schema schema1, Schema schema2, Collection<String> exclusionRegex); boolean tablesMatch(Table table1, Table table2); boolean columnsMatch(Column column1, Column column2); boolean indexesMatch(Index index1, Index index2); }### Answer: @Test public void testColumnsMatch() { assertTrue("columns should match", schemaHomology.columnsMatch(column("colour", DataType.STRING).nullable(), column("colour", DataType.STRING).nullable())); assertTrue("columns should match", schemaHomology.columnsMatch(column("colour", DataType.STRING).nullable(), column("COLOUR", DataType.STRING).nullable())); assertFalse("columns should not match", schemaHomology.columnsMatch(column("colour", DataType.STRING).nullable(), column("color", DataType.STRING).nullable())); } @Test public void testColumnDefaultValueIsChecked() { assertTrue("columns should match", schemaHomology.columnsMatch(column("colour", DataType.STRING, 10), column("colour", DataType.STRING, 10))); assertTrue("columns should match", schemaHomology.columnsMatch(column("colour", DataType.STRING, 10).defaultValue("XYZ"), column("colour", DataType.STRING, 10).defaultValue("XYZ"))); assertFalse("columns should not match", schemaHomology.columnsMatch(column("colour", DataType.STRING, 10).defaultValue("XYZ"), column("colour", DataType.STRING, 10).defaultValue("ABC"))); assertFalse("columns should not match", schemaHomology.columnsMatch(column("colour", DataType.STRING, 10).defaultValue("XYZ"), column("colour", DataType.STRING, 10))); }
### Question: SchemaHomology { public boolean indexesMatch(Index index1, Index index2) { noDifferences = true; checkIndex("unspecified", index1, index2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean schemasMatch(Schema schema1, Schema schema2, Collection<String> exclusionRegex); boolean tablesMatch(Table table1, Table table2); boolean columnsMatch(Column column1, Column column2); boolean indexesMatch(Index index1, Index index2); }### Answer: @Test public void testIndexesMatch() { assertTrue("indexes should match", schemaHomology.indexesMatch(index("ABC").unique().columns("a", "b", "c"), index("ABC").unique().columns("a", "b", "c"))); assertFalse("indexes should match", schemaHomology.indexesMatch(index("ABC").unique().columns("a", "b", "c"), index("ABC").unique().columns("a", "c", "b"))); }
### Question: SQLEntityNameValidationService { public boolean isNameConventional(String name) { return schemaValidator.isNameConventional(name); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); }### Answer: @Test @Parameters(method="getNamePatternTestSubjects") public void testValidNamePattern(String name, boolean expectedResult) { boolean result = sqlEntityNameValidationService.isNameConventional(name); assertEquals(format("%s should have been valid=%s but was valid=%s", name, expectedResult, result), expectedResult, result); }
### Question: SQLEntityNameValidationService { public boolean isReservedWord(String word) { return schemaValidator.isSQLReservedWord(word); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); }### Answer: @Test @Parameters(method="getReservedWordTestSubjects") public void testReservedWord(String name, boolean expectedResult) { boolean result = sqlEntityNameValidationService.isReservedWord(name); assertEquals(format("%s should have been reserved=%s but was reserved=%s", name, expectedResult, result), expectedResult, result); }
### Question: SQLEntityNameValidationService { public boolean isEntityNameLengthValid(String name) { return schemaValidator.isEntityNameLengthValid(name); } @Inject SQLEntityNameValidationService(); boolean isReservedWord(String word); boolean isNameConventional(String name); boolean isEntityNameLengthValid(String name); }### Answer: @Test @Parameters(method="getNameLengthTestSubjects") public void testValidNameLength(String name, boolean expectedResult) { boolean result = sqlEntityNameValidationService.isEntityNameLengthValid(name); assertEquals(format("%s should have been valid=%s but was valid=%s", name, expectedResult, result), expectedResult, result); }
### Question: UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public void tidyUp(DataSource dataSource) { try { new SqlScriptExecutorProvider(dataSource, sqlDialect).get().execute(sqlDialect.dropStatements(table(UpgradeStatusTableService.UPGRADE_STATUS))); } catch (RuntimeSqlException e) { if (getStatus(Optional.of(dataSource)) != NONE) { throw e; } } } @Inject UpgradeStatusTableServiceImpl(SqlScriptExecutorProvider sqlScriptExecutor, SqlDialect sqlDialect); @Override int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus); @Override List<String> updateTableScript(UpgradeStatus fromStatus, UpgradeStatus toStatus); @Override UpgradeStatus getStatus(Optional<DataSource> dataSource); @Override void tidyUp(DataSource dataSource); }### Answer: @Test public void testTidyUp() throws SQLException { upgradeStatusTableService.tidyUp(dataSource); ArgumentCaptor<Table> tableCaptor = ArgumentCaptor.forClass(Table.class); verify(sqlDialect).dropStatements(tableCaptor.capture()); assertEquals("Table", tableCaptor.getValue().getName(), UPGRADE_STATUS); }
### Question: UnionSetOperator implements SetOperator { @Override public Builder<SetOperator> deepCopy(DeepCopyTransformation transformer) { return TempTransitionalBuilderWrapper.<SetOperator>wrapper(new UnionSetOperator(getUnionStrategy(),transformer.deepCopy(getSelectStatement()))); } UnionSetOperator(UnionStrategy unionStrategy, SelectStatement parentSelect, SelectStatement childSelect); private UnionSetOperator(UnionStrategy unionStrategy, SelectStatement childSelect); @Override SelectStatement getSelectStatement(); UnionStrategy getUnionStrategy(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override void drive(ObjectTreeTraverser traverser); @Override Builder<SetOperator> deepCopy(DeepCopyTransformation transformer); }### Answer: @Test public void testDeepCopy() { SelectStatement parentSelect = new SelectStatement(); SelectStatement childSelect = new SelectStatement(); UnionSetOperator original = new UnionSetOperator(ALL, parentSelect, childSelect); UnionSetOperator copy = (UnionSetOperator) original.deepCopy(noTransformation()).build(); assertNotSame(original, copy); assertEquals(original.getUnionStrategy(), copy.getUnionStrategy()); assertNotSame(childSelect, copy.getSelectStatement()); }
### Question: BracketedExpression extends AliasedField implements Driver { public MathsField getInnerExpression() { return innerExpression; } BracketedExpression(MathsField innerExpression); private BracketedExpression(final String alias, MathsField innerExpression); @Override BracketedExpression as(String aliasName); MathsField getInnerExpression(); @Override void drive(ObjectTreeTraverser traverser); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void testInnerExpression() { assertEquals(plus(literal(1), literal(2)), onTest.getInnerExpression()); }
### Question: BracketedExpression extends AliasedField implements Driver { @Override public void drive(ObjectTreeTraverser traverser) { traverser.dispatch(getInnerExpression()); } BracketedExpression(MathsField innerExpression); private BracketedExpression(final String alias, MathsField innerExpression); @Override BracketedExpression as(String aliasName); MathsField getInnerExpression(); @Override void drive(ObjectTreeTraverser traverser); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void testDrive() { ObjectTreeTraverser.Callback callback = mock(ObjectTreeTraverser.Callback.class); onTest.drive(ObjectTreeTraverser.forCallback(callback)); verify(callback).visit(onTest.getInnerExpression()); }
### Question: FieldFromSelect extends AliasedField implements Driver { public SelectStatement getSelectStatement() { return selectStatement; } private FieldFromSelect(String alias, SelectStatement selectStatement); FieldFromSelect(SelectStatement selectStatement); SelectStatement getSelectStatement(); @Override void drive(ObjectTreeTraverser traverser); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void testDeepCopyDetail() { SelectStatement statementWithTwoFields = new SelectStatement(new FieldReference("agreementNumber")).from(new TableReference("Schedule")) .where(Criterion.eq(new FieldReference(new TableReference("Schedule"), "agreementNumber"), "A001003657")); FieldFromSelect ffs = new FieldFromSelect(statementWithTwoFields); ffs.as("field_alias"); FieldFromSelect ffsCopy = (FieldFromSelect)ffs.deepCopy(); assertTrue("Should be different instances of SelectStatement", ffs.getSelectStatement() != ffsCopy.getSelectStatement()); assertEquals("Field names should match", ((FieldReference)ffs.getSelectStatement().getFields().get(0)).getName(), ((FieldReference)ffsCopy.getSelectStatement().getFields().get(0)).getName()); assertEquals("Table names should match", ffs.getSelectStatement().getTable().getName(), ffsCopy.getSelectStatement().getTable().getName()); assertEquals("Operators should match", ffs.getSelectStatement().getWhereCriterion().getOperator(), ffsCopy.getSelectStatement().getWhereCriterion().getOperator()); assertEquals("Criterion field names should match", ((FieldReference)ffs.getSelectStatement().getWhereCriterion().getField()).getName(), ((FieldReference)ffsCopy.getSelectStatement().getWhereCriterion().getField()).getName()); assertEquals("Criterion values should match", ((String) ffs.getSelectStatement().getWhereCriterion().getValue()).toUpperCase(), ((String) ffsCopy.getSelectStatement().getWhereCriterion().getValue()).toUpperCase()); assertEquals("Alias", ffs.getAlias(), ffsCopy.getAlias()); }
### Question: TableReference implements DeepCopyableWithTransformation<TableReference, Builder<TableReference>> { @Override public int hashCode() { return new HashCodeBuilder(1559, 887) .append(schemaName) .append(name) .append(alias) .append(temporary) .toHashCode(); } private TableReference(TableReference sourceTable, String alias); TableReference(String name); TableReference(String schemaName, String tableName); TableReference(String tableName, boolean temporary); TableReference as(String aliasName); String getName(); String getAlias(); String getSchemaName(); boolean isTemporary(); @Deprecated void setName(String name); @Override Builder<TableReference> deepCopy(DeepCopyTransformation transformer); TableReference deepCopy(); @Override String toString(); FieldReference field(String fieldName); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { assertEquals(isEqual.hashCode(), onTest.hashCode()); assertEquals(isEqualAliased.hashCode(), onTestAliased.hashCode()); }
### Question: TableReference implements DeepCopyableWithTransformation<TableReference, Builder<TableReference>> { @Override public boolean equals(Object obj) { if (obj == null) return false; if (obj == this) return true; if (!(obj instanceof TableReference)) return false; TableReference rhs = (TableReference)obj; return new EqualsBuilder() .append(schemaName, rhs.schemaName) .append(name, rhs.name) .append(alias, rhs.alias) .append(temporary, rhs.temporary) .isEquals(); } private TableReference(TableReference sourceTable, String alias); TableReference(String name); TableReference(String schemaName, String tableName); TableReference(String tableName, boolean temporary); TableReference as(String aliasName); String getName(); String getAlias(); String getSchemaName(); boolean isTemporary(); @Deprecated void setName(String name); @Override Builder<TableReference> deepCopy(DeepCopyTransformation transformer); TableReference deepCopy(); @Override String toString(); FieldReference field(String fieldName); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { assertEquals(isEqual, onTest); assertFalse(onTest.equals(null)); assertNotEquals(notEqualDueToSchema, onTest); assertNotEquals(notEqualDueToName, onTest); assertNotEquals(notEqualDueToAlias, onTest); assertEquals(isEqualAliased, onTestAliased); assertNotEquals(differentSchema, onTestAliased); assertNotEquals(differentName, onTestAliased); assertNotEquals(differentAlias, onTestAliased); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.