method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
UriRewriteFilter extends ZuulFilter { @Override public boolean shouldFilter() { RequestContext context = RequestContext.getCurrentContext(); String uri = context.get("requestURI").toString(); return uri.startsWith("/rest/"); } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void skippedIfRestNotInRequestURI() { context.set("requestURI", "/api/login"); assertThat(this.filter.shouldFilter(), is(false)); }
@Test public void skippedIfRequestURINotStartsWithRest() { context.set("requestURI", "/abc/rest/api/login"); assertThat(this.filter.shouldFilter(), is(false)); } |
### Question:
CustomerServiceImpl extends CustomerServiceSupport { public Customer createCustomer(String username, String password, MemberShipStatus status, int total_miles, int miles_ytd, String phoneNumber, PhoneType phoneNumberType, CustomerAddressImpl address) { CustomerImpl customer = new CustomerImpl(username, password, status, total_miles, miles_ytd, address, phoneNumber, phoneNumberType); customerRepository.save(customer); return customer; } @Override Long count(); @Override Long countSessions(); Customer createCustomer(String username, String password,
MemberShipStatus status, int total_miles, int miles_ytd,
String phoneNumber, PhoneType phoneNumberType,
CustomerAddressImpl address); CustomerAddressImpl createAddress(String streetAddress1, String streetAddress2,
String city, String stateProvince, String country, String postalCode); @Override Customer updateCustomer(Customer customer); @Override void invalidateSession(String sessionid); }### Answer:
@Test public void savesCustomerIntoDatabase() { Customer customer = customerService.createCustomer( this.customer.getCustomerId(), this.customer.getPassword(), this.customer.getStatus(), this.customer.getTotal_miles(), this.customer.getMiles_ytd(), this.customer.getPhoneNumber(), this.customer.getPhoneNumberType(), this.customer.getAddress() ); assertThat(customer, is(this.customer)); verify(customerRepository).save((CustomerImpl) customer); } |
### Question:
CustomerServiceImpl extends CustomerServiceSupport { public CustomerAddressImpl createAddress (String streetAddress1, String streetAddress2, String city, String stateProvince, String country, String postalCode){ return new CustomerAddressImpl(streetAddress1, streetAddress2, city, stateProvince, country, postalCode); } @Override Long count(); @Override Long countSessions(); Customer createCustomer(String username, String password,
MemberShipStatus status, int total_miles, int miles_ytd,
String phoneNumber, PhoneType phoneNumberType,
CustomerAddressImpl address); CustomerAddressImpl createAddress(String streetAddress1, String streetAddress2,
String city, String stateProvince, String country, String postalCode); @Override Customer updateCustomer(Customer customer); @Override void invalidateSession(String sessionid); }### Answer:
@Test public void createsCustomerAddress() { CustomerAddress address = customerService.createAddress( this.address.getStreetAddress1(), this.address.getStreetAddress2(), this.address.getCity(), this.address.getStateProvince(), this.address.getCountry(), this.address.getPostalCode() ); assertThat(address, is(this.address)); } |
### Question:
CustomerServiceImpl extends CustomerServiceSupport { @Override protected CustomerSession createSession(String sessionId, String customerId, Date creation, Date expiration) { CustomerSessionImpl cSession = new CustomerSessionImpl(sessionId, customerId, creation, expiration); sessionRepository.save(cSession); return cSession; } @Override Long count(); @Override Long countSessions(); Customer createCustomer(String username, String password,
MemberShipStatus status, int total_miles, int miles_ytd,
String phoneNumber, PhoneType phoneNumberType,
CustomerAddressImpl address); CustomerAddressImpl createAddress(String streetAddress1, String streetAddress2,
String city, String stateProvince, String country, String postalCode); @Override Customer updateCustomer(Customer customer); @Override void invalidateSession(String sessionid); }### Answer:
@Test public void savesSessionIntoDatabase() { CustomerSession session = customerService.createSession(customer.getCustomerId()); Date now = new Date(); assertThat(session.getId(), is(sessionId)); assertThat(session.getCustomerid(), is(customer.getCustomerId())); assertThat(session.getTimeoutTime().after(now), is(true)); verify(sessionRepository).save((CustomerSessionImpl) session); } |
### Question:
CustomerServiceImpl extends CustomerServiceSupport { @Override public void invalidateSession(String sessionid) { sessionRepository.delete(sessionid); } @Override Long count(); @Override Long countSessions(); Customer createCustomer(String username, String password,
MemberShipStatus status, int total_miles, int miles_ytd,
String phoneNumber, PhoneType phoneNumberType,
CustomerAddressImpl address); CustomerAddressImpl createAddress(String streetAddress1, String streetAddress2,
String city, String stateProvince, String country, String postalCode); @Override Customer updateCustomer(Customer customer); @Override void invalidateSession(String sessionid); }### Answer:
@Test public void deletesSessionFromDatabaseWhenInvalidated() { customerService.invalidateSession(sessionId); verify(sessionRepository).delete(sessionId); } |
### Question:
RemoteCustomerLoader implements CustomerLoader { @Override public void loadCustomers(long numCustomers) { restTemplate.postForEntity( getCustomerServiceAddress() + "/info/loader/load?number={numberOfCustomers}", null, String.class, numCustomers ); } RemoteCustomerLoader(RestTemplate restTemplate); @Override void loadCustomers(long numCustomers); }### Answer:
@Test @PactVerification public void requestsRemoteToLoadCustomers() throws IOException { customerLoader.loadCustomers(5); } |
### Question:
SlimAdapter extends AbstractSlimAdapter { private boolean isTypeMatch(Type type, Type targetType) { if (type instanceof Class && targetType instanceof Class) { if (((Class) type).isAssignableFrom((Class) targetType)) { return true; } } else if (type instanceof ParameterizedType && targetType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; ParameterizedType parameterizedTargetType = (ParameterizedType) targetType; if (isTypeMatch(parameterizedType.getRawType(), ((ParameterizedType) targetType).getRawType())) { Type[] types = parameterizedType.getActualTypeArguments(); Type[] targetTypes = parameterizedTargetType.getActualTypeArguments(); if (types == null || targetTypes == null || types.length != targetTypes.length) { return false; } int len = types.length; for (int i = 0; i < len; i++) { if (!isTypeMatch(types[i], targetTypes[i])) { return false; } } return true; } } return false; } protected SlimAdapter(); static SlimAdapter create(); static T create(Class<T> clazz); SlimAdapter updateData(List<?> data); List<?> getData(); @Override Object getItem(int position); @Override int getItemCount(); SlimAdapter enableDiff(); SlimAdapter enableDiff(SlimDiffUtil.Callback diffCallback); @Override SlimViewHolder onCreateViewHolder(ViewGroup parent, int viewType); SlimAdapter registerDefault(final int layoutRes, final SlimInjector slimInjector); SlimAdapter register(final int layoutRes, final SlimInjector<T> slimInjector); SlimAdapter attachTo(RecyclerView... recyclerViews); @Override int getItemViewType(int position); SlimAdapter enableLoadMore(SlimMoreLoader slimMoreLoader); @Override void onAttachedToRecyclerView(RecyclerView recyclerView); @Override void onDetachedFromRecyclerView(RecyclerView recyclerView); }### Answer:
@Test public void isTypeMatch() throws Exception { } |
### Question:
RF2Importer extends BaseImporter { @Override public Iterator<Ontology> getOntologyVersions(IProgressMonitor monitor) throws ImportException { return new OntologyInterator(monitor); } RF2Importer(RF2Input input); RF2Importer(Collection<Input> inputs); @Override Iterator<Ontology> getOntologyVersions(IProgressMonitor monitor); @Override List<String> getProblems(); }### Answer:
@Test public void testExtractVersionRows() { try { final RF2Input input = new RF2Input(); input.setInputType(InputType.CLASSPATH); input.setReleaseType(ReleaseType.FULL); input.setModuleDependenciesRefsetFiles(Collections.singleton("/der2_ssRefset_ModuleDependencyFull_AU1000036_20121130.txt")); input.setConceptsFiles(Collections.singleton("/rf2_full_con_test.txt")); input.setRelationshipsFiles(Collections.singleton("/rf2_full_rel_test.txt")); final RF2Importer rf2i = new RF2Importer(input); final Iterator<Ontology> itr = rf2i.getOntologyVersions(null); while (itr.hasNext()) { Ontology o = itr.next(); System.err.println(o); } } catch(Exception e) { e.printStackTrace(); Assert.assertTrue(false); } } |
### Question:
ModuleDependencyRefset extends Refset implements IModuleDependencyRefset { @Override public Map<String, Map<String, ModuleDependency>> getModuleDependencies() { return dependencies; } ModuleDependencyRefset(Set<ModuleDependencyRow> members, boolean validate); @Override Map<String, Map<String, ModuleDependency>> getModuleDependencies(); }### Answer:
@Test public void testIncomplete() throws ValidationException { Set<ModuleDependencyRow> members = new HashSet<ModuleDependencyRow>(); members.add(new ModuleDependencyRow("a", "20010101", true, "A", MDRS_ID, "B", "20010101", "10010101")); members.add(new ModuleDependencyRow("b", "10010101", true, "B", MDRS_ID, "C", "10010101", "10010101")); ModuleDependencyRefset mdrs = new ModuleDependencyRefset(members, true); Assert.assertEquals(2, mdrs.getModuleDependencies().size()); } |
### Question:
DialogManagerImpl implements DialogManager { @Override public boolean isDialogShowing(final int dialogId) { final Dialog dialog = mDialogInstances.get(dialogId); if (dialog != null) { return dialog.isShowing(); } final DialogFragment dialogFragment = mDialogFragmentInstances.get(dialogId); if (dialogFragment != null && dialogFragment.getDialog() != null) { return dialogFragment.getDialog().isShowing(); } return false; } DialogManagerImpl(@NonNull final FragmentManager fragmentManager); @Override void setCallback(@Nullable final DialogManagerCallback callback); @Nullable @Override DialogManagerCallback getCallback(); @Override void setListener(@Nullable final DialogManagerListener listener); @Nullable @Override DialogManagerListener getListener(); @Override void showDialog(final int dialogId); @Override void showDialog(final int dialogId, @Nullable final Bundle config); @Override void showDialogFragment(final int dialogId); @Override void showDialogFragment(final int dialogId, @Nullable final Bundle config); @Override boolean isDialogShowing(final int dialogId); @Override void dismissDialog(final int dialogId); @NonNull @Override Parcelable saveState(); @Override void restoreState(@Nullable final Parcelable state, final boolean showNow); @Override void recreateAll(final boolean showNow); @Override void unhideAll(); @Override void hideAll(); @Override void dismissAll(); @Override void dispose(); }### Answer:
@Test public void isDialogShowing() { final DialogManagerCallback callback = createCallbackMock(); final Dialog dialogMock = createDialogMock(); when(callback.onCreateDialog(eq(KNOWN_DIALOG), isNull())).thenReturn(dialogMock); mDialogManager.setCallback(callback); mDialogManager.showDialog(KNOWN_DIALOG); assertTrue(mDialogManager.isDialogShowing(KNOWN_DIALOG)); dialogMock.hide(); assertFalse(mDialogManager.isDialogShowing(KNOWN_DIALOG)); } |
### Question:
DialogManagerImpl implements DialogManager { @Override public void dismissDialog(final int dialogId) { final Dialog dialog = mDialogInstances.get(dialogId); if (dialog != null) { dialog.dismiss(); mDialogInstances.remove(dialogId); mDialogConfigs.remove(dialogId); return; } final DialogFragment dialogFragment = mDialogFragmentInstances.get(dialogId); if (dialogFragment != null) { dialogFragment.dismiss(); mDialogFragmentInstances.remove(dialogId); mDialogConfigs.remove(dialogId); } } DialogManagerImpl(@NonNull final FragmentManager fragmentManager); @Override void setCallback(@Nullable final DialogManagerCallback callback); @Nullable @Override DialogManagerCallback getCallback(); @Override void setListener(@Nullable final DialogManagerListener listener); @Nullable @Override DialogManagerListener getListener(); @Override void showDialog(final int dialogId); @Override void showDialog(final int dialogId, @Nullable final Bundle config); @Override void showDialogFragment(final int dialogId); @Override void showDialogFragment(final int dialogId, @Nullable final Bundle config); @Override boolean isDialogShowing(final int dialogId); @Override void dismissDialog(final int dialogId); @NonNull @Override Parcelable saveState(); @Override void restoreState(@Nullable final Parcelable state, final boolean showNow); @Override void recreateAll(final boolean showNow); @Override void unhideAll(); @Override void hideAll(); @Override void dismissAll(); @Override void dispose(); }### Answer:
@Test public void dismissDialog() { final DialogManagerCallback callback = createCallbackMock(); final Dialog dialogMock = createDialogMock(); when(callback.onCreateDialog(eq(KNOWN_DIALOG), isNull())).thenReturn(dialogMock); mDialogManager.setCallback(callback); mDialogManager.showDialog(KNOWN_DIALOG); assertTrue(mDialogManager.isDialogShowing(KNOWN_DIALOG)); mDialogManager.dismissDialog(KNOWN_DIALOG); assertFalse(mDialogManager.isDialogShowing(KNOWN_DIALOG)); } |
### Question:
DialogManagerImpl implements DialogManager { @Override public void dispose() { dismissAll(); mCallback = null; mListener = null; mFragmentManagerRef.clear(); } DialogManagerImpl(@NonNull final FragmentManager fragmentManager); @Override void setCallback(@Nullable final DialogManagerCallback callback); @Nullable @Override DialogManagerCallback getCallback(); @Override void setListener(@Nullable final DialogManagerListener listener); @Nullable @Override DialogManagerListener getListener(); @Override void showDialog(final int dialogId); @Override void showDialog(final int dialogId, @Nullable final Bundle config); @Override void showDialogFragment(final int dialogId); @Override void showDialogFragment(final int dialogId, @Nullable final Bundle config); @Override boolean isDialogShowing(final int dialogId); @Override void dismissDialog(final int dialogId); @NonNull @Override Parcelable saveState(); @Override void restoreState(@Nullable final Parcelable state, final boolean showNow); @Override void recreateAll(final boolean showNow); @Override void unhideAll(); @Override void hideAll(); @Override void dismissAll(); @Override void dispose(); }### Answer:
@Test public void dispose() { mDialogManager.setCallback(createCallbackMock()); mDialogManager.setListener(createListenerMock()); mDialogManager.dispose(); assertNull(mDialogManager.getCallback()); assertNull(mDialogManager.getListener()); } |
### Question:
Rectangle { @Override public boolean equals(Object obj) { if (!(obj instanceof Rectangle)) return false; Rectangle otherRect = (Rectangle) obj; return origin.equals(otherRect.origin) && dimension.equals(otherRect.dimension); } Rectangle(Vector origin, Vector dimension); Rectangle(int x, int y, int width, int height); Rectangle add(Vector v); Rectangle sub(Vector v); boolean contains(Rectangle r); boolean contains(Vector v); Rectangle union(Rectangle rect); boolean intersects(Rectangle rect); Rectangle intersect(Rectangle r); boolean innerIntersects(Rectangle rect); Rectangle changeDimension(Vector dim); double distance(Vector to); Range<Integer> xRange(); Range<Integer> yRange(); @Override int hashCode(); @Override boolean equals(Object obj); DoubleRectangle toDoubleRectangle(); Vector center(); Segment[] getBoundSegments(); Vector[] getBoundPoints(); @Override String toString(); final Vector origin; final Vector dimension; }### Answer:
@Test public void equals() { assertEquals(new Rectangle(new Vector(1, 2), new Vector(2, 2)), new Rectangle(new Vector(1, 2), new Vector(2, 2))); assertFalse(new Rectangle(new Vector(1, 2), new Vector(2, 2)) .equals(new Rectangle(new Vector(1, 2), new Vector(2, 3)))); } |
### Question:
TreePath implements Comparable<TreePath<CompositeT>> { public boolean isEmpty() { return myPath.isEmpty(); } TreePath(CompositeT composite); TreePath(CompositeT from, CompositeT to); private TreePath(List<Integer> path); static void sort(List<? extends CompositeT> composites); static TreePath<CompositeT> deserialize(String text); CompositeT get(CompositeT root); boolean isValid(CompositeT root); boolean isEmpty(); int getLastIndex(); TreePath<CompositeT> getParent(); TreePath<CompositeT> getChild(int index); String serialize(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(TreePath<CompositeT> o); @Override String toString(); }### Answer:
@Test public void isEmpty() { TreePath<TestComposite> path = new TreePath<>(child1, child1); assertTrue(path.isEmpty()); } |
### Question:
TreePath implements Comparable<TreePath<CompositeT>> { public int getLastIndex() { if (myPath.isEmpty()) { throw new IllegalStateException(); } return myPath.get(myPath.size() - 1); } TreePath(CompositeT composite); TreePath(CompositeT from, CompositeT to); private TreePath(List<Integer> path); static void sort(List<? extends CompositeT> composites); static TreePath<CompositeT> deserialize(String text); CompositeT get(CompositeT root); boolean isValid(CompositeT root); boolean isEmpty(); int getLastIndex(); TreePath<CompositeT> getParent(); TreePath<CompositeT> getChild(int index); String serialize(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(TreePath<CompositeT> o); @Override String toString(); }### Answer:
@Test public void lastIndex() { TreePath<TestComposite> path = new TreePath<>(child2); assertEquals(1, path.getLastIndex()); } |
### Question:
TreePath implements Comparable<TreePath<CompositeT>> { public CompositeT get(CompositeT root) { if (!isValid(root)) { throw new IllegalStateException("Invalid context"); } CompositeT current = root; for (Integer i : myPath) { current = current.children().get(i); } return current; } TreePath(CompositeT composite); TreePath(CompositeT from, CompositeT to); private TreePath(List<Integer> path); static void sort(List<? extends CompositeT> composites); static TreePath<CompositeT> deserialize(String text); CompositeT get(CompositeT root); boolean isValid(CompositeT root); boolean isEmpty(); int getLastIndex(); TreePath<CompositeT> getParent(); TreePath<CompositeT> getChild(int index); String serialize(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(TreePath<CompositeT> o); @Override String toString(); }### Answer:
@Test public void restoreFromNonRoot() { TestComposite composite = new TestComposite(); child1.children().add(composite); TreePath<TestComposite> path = new TreePath<>(composite, child1); assertSame(composite, path.get(child1)); }
@Test public void saveRestore() { TreePath<TestComposite> path1 = new TreePath<>(child1); assertSame(child1, path1.get(root)); } |
### Question:
BaseId implements Serializable { @Override public boolean equals(Object obj) { if (obj == null) return false; if (obj.getClass() != getClass()) return false; BaseId otherId = (BaseId) obj; return Objects.equals(getId(), otherId.getId()); } protected BaseId(); protected BaseId(String id); protected BaseId(String id, String name); String getId(); String getName(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void idEquality() { MyId id1 = new MyId("abc.def"); MyId id2 = new MyId("abc.defz"); MyId id3 = new MyId("abc.def"); assertEquals(id1, id3); assertFalse(id2.equals(id3)); } |
### Question:
BaseId implements Serializable { public String getName() { return ourNames.get(myId); } protected BaseId(); protected BaseId(String id); protected BaseId(String id, String name); String getId(); String getName(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void nameDiscovery () { new MyId("e.f", "newName1"); MyId id2 = new MyId("e.f"); assertEquals("newName1", id2.getName()); } |
### Question:
BaseId implements Serializable { @Override public String toString() { String name = getName(); return name != null ? name + " [" + getId() + "]" : getId(); } protected BaseId(); protected BaseId(String id); protected BaseId(String id, String name); String getId(); String getName(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void stringRepresentation() { assertEquals("newName1 [g.h]", new MyId("g.h", "newName1").toString()); assertEquals("i.j", new MyId("i.j").toString()); } |
### Question:
BaseId implements Serializable { public String getId() { return myId; } protected BaseId(); protected BaseId(String id); protected BaseId(String id, String name); String getId(); String getName(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Slow @Test public void idRandomness() { int[] stats = new int[128]; for (int i = 0; i < 62000; i++) { String id = new BaseId() {}.getId(); for (int j = 0; j < id.length(); j++) { stats[id.charAt(j)] ++; } } checkUniform(stats, 'A', 'Z', 22000); checkUniform(stats, 'a', 'z', 22000); checkUniform(stats, '0', '9', 22000); } |
### Question:
Listeners { public Registration add(final ListenerT l) { if (isEmpty()) { beforeFirstAdded(); } if (myFireDepth > 0) { myListeners.add(new ListenerOp<>(l, true)); } else { if (myListeners == null) { myListeners = new ArrayList<>(1); } myListeners.add(l); myListenersCount++; } return new Registration() { @Override protected void doRemove() { if (myFireDepth > 0) { myListeners.add(new ListenerOp<>(l, false)); } else { myListeners.remove(l); myListenersCount--; } if (isEmpty()) { afterLastRemoved(); } } }; } boolean isEmpty(); Registration add(final ListenerT l); void fire(ListenerCaller<ListenerT> h); }### Answer:
@Test public void addAndRemoveRegistrationInFire() { myListeners.add(new Listener() { @Override public void act() { myListeners.add(createInnerListener()).remove(); } }); fireAndCheck(1); }
@Test public void addRemoveAddInFire() { myListeners.add(new Listener() { @Override public void act() { Listener l = createInnerListener(); myListeners.add(l).remove(); myListeners.add(l); } }); fireAndCheck(2); } |
### Question:
CompositeRegistration extends Registration { public CompositeRegistration add(Registration r) { myRegistrations.add(r); return this; } CompositeRegistration(Registration... regs); CompositeRegistration add(Registration r); CompositeRegistration add(Registration... rs); boolean isEmpty(); }### Answer:
@Test public void removalOrderManualAdd() { CompositeRegistration r = new CompositeRegistration(); r.add(createReg(1)).add(createReg(0)); r.remove(); assertEquals(2, myRemoveCounter); } |
### Question:
Vector { public Vector sub(Vector v) { return add(v.negate()); } Vector(int x, int y); Vector add(Vector v); Vector sub(Vector v); Vector negate(); Vector max(Vector v); Vector min(Vector v); Vector mul(int i); Vector div(int i); int dotProduct(Vector v); double length(); DoubleVector toDoubleVector(); Vector abs(); boolean isParallel(Vector to); Vector orthogonal(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); int getX(); int getY(); int get(Axis axis); static final Vector ZERO; final int x; final int y; }### Answer:
@Test public void sub() { assertThat(new Vector(1, 2).sub(new Vector(2, 2)), is(new Vector(-1, 0))); } |
### Question:
MappingContext { public <ValueT> ValueT get(MappingContextProperty<ValueT> property) { Object value = myProperties.get(property); if (value == null) { throw new IllegalStateException("Property " + property + " wasn't found"); } @SuppressWarnings("unchecked") ValueT result = (ValueT) value; return result; } Registration addListener(MappingContextListener l); Mapper<? super S, ?> getMapper(Mapper<?, ?> ancestor, S source); Set<Mapper<? super S, ?>> getMappers(Mapper<?, ?> ancestor, S source); void put(MappingContextProperty<ValueT> property, ValueT value); ValueT get(MappingContextProperty<ValueT> property); boolean contains(MappingContextProperty<?> property); ValueT remove(MappingContextProperty<ValueT> property); static final MappingContextProperty<CompositeRegistration> ON_DISPOSE; }### Answer:
@Test(expected = IllegalStateException.class) public void unknownPropertyFails() { context.get(TEST); } |
### Question:
MappingContext { public <ValueT> ValueT remove(MappingContextProperty<ValueT> property) { if (!myProperties.containsKey(property)) { throw new IllegalStateException("Property " + property + " wasn't found"); } @SuppressWarnings("unchecked") ValueT result = (ValueT) myProperties.remove(property); return result; } Registration addListener(MappingContextListener l); Mapper<? super S, ?> getMapper(Mapper<?, ?> ancestor, S source); Set<Mapper<? super S, ?>> getMappers(Mapper<?, ?> ancestor, S source); void put(MappingContextProperty<ValueT> property, ValueT value); ValueT get(MappingContextProperty<ValueT> property); boolean contains(MappingContextProperty<?> property); ValueT remove(MappingContextProperty<ValueT> property); static final MappingContextProperty<CompositeRegistration> ON_DISPOSE; }### Answer:
@Test(expected = IllegalStateException.class) public void removeUnknownProperty() { context.remove(TEST); } |
### Question:
MappingContext { public <ValueT> void put(MappingContextProperty<ValueT> property, ValueT value) { if (myProperties.containsKey(property)) { throw new IllegalStateException("Property " + property + " is already defined"); } if (value == null) { throw new IllegalArgumentException("Trying to set null as a value of " + property); } myProperties.put(property, value); } Registration addListener(MappingContextListener l); Mapper<? super S, ?> getMapper(Mapper<?, ?> ancestor, S source); Set<Mapper<? super S, ?>> getMappers(Mapper<?, ?> ancestor, S source); void put(MappingContextProperty<ValueT> property, ValueT value); ValueT get(MappingContextProperty<ValueT> property); boolean contains(MappingContextProperty<?> property); ValueT remove(MappingContextProperty<ValueT> property); static final MappingContextProperty<CompositeRegistration> ON_DISPOSE; }### Answer:
@Test(expected = IllegalStateException.class) public void putAllowedOnce() { context.put(TEST, "value"); context.put(TEST, "another value"); }
@Test(expected = IllegalArgumentException.class) public void nullNotAllowed() { context.put(TEST, null); } |
### Question:
ByTargetIndex implements Disposable { @Override public void dispose() { myRegistration.remove(); } ByTargetIndex(MappingContext ctx); Collection<Mapper<?, ?>> getMappers(Object target); @Override void dispose(); static final MappingContextProperty<ByTargetIndex> KEY; }### Answer:
@Test public void addWhenFinderDisposed() { finder.dispose(); Item anotherChild = new Item(); child.getObservableChildren().add(anotherChild); assertNotFound(anotherChild); } |
### Question:
Mapper { public final void detachRoot() { if (myMappingContext == null) { throw new IllegalStateException(); } if (myParent != null) { throw new IllegalStateException("Dispose can be called only on the root mapper"); } detach(); } protected Mapper(SourceT source, TargetT target); final Mapper<?, ?> getParent(); final boolean isAttached(); final MappingContext getMappingContext(); final Mapper<? super S, ?> getDescendantMapper(S source); final SourceT getSource(); final TargetT getTarget(); final void attachRoot(); final void attachRoot(MappingContext ctx); final void detachRoot(); final Iterable<Synchronizer> synchronizers(); final Iterable<Mapper<?, ?>> children(); final ObservableList<MapperT> createChildList(); final ObservableSet<MapperT> createChildSet(); final Property<MapperT> createChildProperty(); }### Answer:
@Test public void rolesAreCleanedOnDetach() { assertFalse(target.getObservableChildren().isEmpty()); assertFalse(target.getChildren().isEmpty()); assertFalse(target.getTransformedChildren().isEmpty()); mapper.detachRoot(); assertTrue(target.getObservableChildren().isEmpty()); assertTrue(target.getChildren().isEmpty()); assertTrue(target.getTransformedChildren().isEmpty()); } |
### Question:
Vector { public Vector negate() { return new Vector(-x, -y); } Vector(int x, int y); Vector add(Vector v); Vector sub(Vector v); Vector negate(); Vector max(Vector v); Vector min(Vector v); Vector mul(int i); Vector div(int i); int dotProduct(Vector v); double length(); DoubleVector toDoubleVector(); Vector abs(); boolean isParallel(Vector to); Vector orthogonal(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); int getX(); int getY(); int get(Axis axis); static final Vector ZERO; final int x; final int y; }### Answer:
@Test public void negate() { assertThat(new Vector(1, 2).negate(), is(new Vector(-1, -2))); } |
### Question:
Vector { public Vector max(Vector v) { return new Vector(Math.max(x, v.x), Math.max(y, v.y)); } Vector(int x, int y); Vector add(Vector v); Vector sub(Vector v); Vector negate(); Vector max(Vector v); Vector min(Vector v); Vector mul(int i); Vector div(int i); int dotProduct(Vector v); double length(); DoubleVector toDoubleVector(); Vector abs(); boolean isParallel(Vector to); Vector orthogonal(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); int getX(); int getY(); int get(Axis axis); static final Vector ZERO; final int x; final int y; }### Answer:
@Test public void max() { assertThat(new Vector(1, 2).max(new Vector(2, 1)), is(new Vector(2, 2))); } |
### Question:
Vector { public Vector min(Vector v) { return new Vector(Math.min(x, v.x), Math.min(y, v.y)); } Vector(int x, int y); Vector add(Vector v); Vector sub(Vector v); Vector negate(); Vector max(Vector v); Vector min(Vector v); Vector mul(int i); Vector div(int i); int dotProduct(Vector v); double length(); DoubleVector toDoubleVector(); Vector abs(); boolean isParallel(Vector to); Vector orthogonal(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); int getX(); int getY(); int get(Axis axis); static final Vector ZERO; final int x; final int y; }### Answer:
@Test public void min() { assertThat(new Vector(1, 2).min(new Vector(2, 1)), is(new Vector(1, 1))); } |
### Question:
Rectangles { public static int upperDistance(Rectangle inner, Rectangle outer) { assertOuterInner(outer, inner); return topLeft(inner).y - topLeft(outer).y; } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void upperDistance() { assertEquals(15, Rectangles.upperDistance(INNER, OUTER)); }
@Test(expected = IllegalArgumentException.class) public void badUpperDistance() { Rectangles.upperDistance(OUTER, INNER); } |
### Question:
Rectangles { public static int lowerDistance(Rectangle inner, Rectangle outer) { assertOuterInner(outer, inner); return bottomLeft(outer).y - bottomLeft(inner).y; } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void lowerDistance() { assertEquals(145, Rectangles.lowerDistance(INNER, OUTER)); }
@Test(expected = IllegalArgumentException.class) public void badLowerDistance() { Rectangles.lowerDistance(OUTER, INNER); } |
### Question:
Rectangles { public static int leftDistance(Rectangle inner, Rectangle outer) { assertOuterInner(outer, inner); return topLeft(inner).x - topLeft(outer).x; } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void leftDistance() { assertEquals(10, Rectangles.leftDistance(INNER, OUTER)); }
@Test(expected = IllegalArgumentException.class) public void badLeftDistance() { Rectangles.leftDistance(OUTER, INNER); } |
### Question:
Rectangles { public static int rightDistance(Rectangle inner, Rectangle outer) { assertOuterInner(outer, inner); return topRight(outer).x - topRight(inner).x; } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void rightDistance() { assertEquals(60, Rectangles.rightDistance(INNER, OUTER)); }
@Test(expected = IllegalArgumentException.class) public void badRightDistance() { Rectangles.rightDistance(OUTER, INNER); } |
### Question:
Rectangle { public Rectangle add(Vector v) { return new Rectangle(origin.add(v), dimension); } Rectangle(Vector origin, Vector dimension); Rectangle(int x, int y, int width, int height); Rectangle add(Vector v); Rectangle sub(Vector v); boolean contains(Rectangle r); boolean contains(Vector v); Rectangle union(Rectangle rect); boolean intersects(Rectangle rect); Rectangle intersect(Rectangle r); boolean innerIntersects(Rectangle rect); Rectangle changeDimension(Vector dim); double distance(Vector to); Range<Integer> xRange(); Range<Integer> yRange(); @Override int hashCode(); @Override boolean equals(Object obj); DoubleRectangle toDoubleRectangle(); Vector center(); Segment[] getBoundSegments(); Vector[] getBoundPoints(); @Override String toString(); final Vector origin; final Vector dimension; }### Answer:
@Test public void add() { assertEquals(new Rectangle(new Vector(1, 2), new Vector(2, 2)), new Rectangle(new Vector(0, 0), new Vector(2, 2)).add(new Vector(1, 2))); } |
### Question:
Rectangles { public static Rectangle extendUp(Rectangle r, int distance) { Vector change = new Vector(0, distance); return new Rectangle(r.origin.sub(change), r.dimension.add(change)); } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void extendUp() { assertEquals(new Rectangle(new Vector(10, 19), new Vector(30, 41)), Rectangles.extendUp(INNER, 1)); } |
### Question:
Rectangles { public static Rectangle extendDown(Rectangle r, int distance) { return r.changeDimension(r.dimension.add(new Vector(0, distance))); } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void extendDown() { assertEquals(new Rectangle(new Vector(10, 20), new Vector(30, 41)), Rectangles.extendDown(INNER, 1)); } |
### Question:
Rectangles { public static Rectangle extendLeft(Rectangle r, int distance) { Vector change = new Vector(distance, 0); return new Rectangle(r.origin.sub(change), r.dimension.add(change)); } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void extendLeft() { assertEquals(new Rectangle(new Vector(9, 20), new Vector(31, 40)), Rectangles.extendLeft(INNER, 1)); } |
### Question:
Rectangles { public static Rectangle extendRight(Rectangle r, int distance) { return r.changeDimension(r.dimension.add(new Vector(distance, 0))); } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void extendRight() { assertEquals(new Rectangle(new Vector(10, 20), new Vector(31, 40)), Rectangles.extendRight(INNER, 1)); } |
### Question:
Rectangles { public static Rectangle extendSides(int left, Rectangle r, int right) { return extendRight(extendLeft(r, left), right); } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void extendSides() { assertEquals(new Rectangle(new Vector(9, 20), new Vector(32, 40)), Rectangles.extendSides(1, INNER, 1)); } |
### Question:
Rectangles { public static Rectangle shrinkRight(Rectangle r, int distance) { if (r.dimension.x < distance) { throw new IllegalArgumentException("To small rectangle = " + r + ", distance = " + distance); } return r.changeDimension(r.dimension.sub(new Vector(distance, 0))); } private Rectangles(); static Rectangle zeroOrigin(Rectangle r); static int upperDistance(Rectangle inner, Rectangle outer); static int lowerDistance(Rectangle inner, Rectangle outer); static int leftDistance(Rectangle inner, Rectangle outer); static int rightDistance(Rectangle inner, Rectangle outer); static Rectangle extendUp(Rectangle r, int distance); static Rectangle extendDown(Rectangle r, int distance); static Rectangle extendLeft(Rectangle r, int distance); static Rectangle extendRight(Rectangle r, int distance); static Rectangle extendSides(int left, Rectangle r, int right); static Rectangle shrinkRight(Rectangle r, int distance); }### Answer:
@Test public void shrinkRight() { assertEquals(new Rectangle(new Vector(10, 20), new Vector(29, 40)), Rectangles.shrinkRight(INNER, 1)); }
@Test(expected = IllegalArgumentException.class) public void shrinkRightIncorrect() { Rectangles.shrinkRight(INNER, INNER.dimension.x + 1); } |
### Question:
DoubleRectangle { @Override public int hashCode() { return origin.hashCode() * 31 + dimension.hashCode(); } DoubleRectangle(double x, double y, double w, double h); DoubleRectangle(DoubleVector origin, DoubleVector dimension); static DoubleRectangle span(DoubleVector leftTop, DoubleVector rightBottom); DoubleVector getCenter(); double getLeft(); double getRight(); double getTop(); double getBottom(); double getWidth(); double getHeight(); Range<Double> xRange(); Range<Double> yRange(); boolean contains(DoubleVector v); DoubleRectangle union(DoubleRectangle rect); boolean intersects(DoubleRectangle rect); DoubleRectangle intersect(DoubleRectangle r); DoubleRectangle add(DoubleVector v); DoubleRectangle subtract(DoubleVector v); double distance(DoubleVector to); Iterable<DoubleSegment> getParts(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); final DoubleVector origin; final DoubleVector dimension; }### Answer:
@Test public void hashCodeWorks() { assertEquals(new DoubleRectangle(DoubleVector.ZERO, DoubleVector.ZERO).hashCode(), new DoubleRectangle(DoubleVector.ZERO, DoubleVector.ZERO).hashCode()); } |
### Question:
Rectangle { public Rectangle sub(Vector v) { return new Rectangle(origin.sub(v), dimension); } Rectangle(Vector origin, Vector dimension); Rectangle(int x, int y, int width, int height); Rectangle add(Vector v); Rectangle sub(Vector v); boolean contains(Rectangle r); boolean contains(Vector v); Rectangle union(Rectangle rect); boolean intersects(Rectangle rect); Rectangle intersect(Rectangle r); boolean innerIntersects(Rectangle rect); Rectangle changeDimension(Vector dim); double distance(Vector to); Range<Integer> xRange(); Range<Integer> yRange(); @Override int hashCode(); @Override boolean equals(Object obj); DoubleRectangle toDoubleRectangle(); Vector center(); Segment[] getBoundSegments(); Vector[] getBoundPoints(); @Override String toString(); final Vector origin; final Vector dimension; }### Answer:
@Test public void sub() { assertEquals(new Rectangle(new Vector(0, 0), new Vector(2, 2)), new Rectangle(new Vector(1, 2), new Vector(2, 2)).sub(new Vector(1, 2))); } |
### Question:
Colors { public static Color forName(String colorName) { Color res = colorsList.get(colorName.toLowerCase()); if (res != null) { return res; } else { throw new IllegalArgumentException(); } } private Colors(); static boolean isColorName(String colorName); static Color forName(String colorName); static double generateHueColor(); static Color generateColor(double s, double v); static Color rgbFromHsv(double h, double s); static Color rgbFromHsv(double h, double s, double v); static double[] hsvFromRgb(Color color); static Color darker(Color c); static Color lighter(Color c); static Color darker(Color c, double factor); static Color lighter(Color c, double factor); static Color mimicTransparency(Color color, double alpha, Color background); static Color withOpacity(Color c, double opacity); static double contrast(Color color, Color other); static double luminance(Color color); static boolean solid(Color c); static Color[] distributeEvenly(int count, double saturation); static Persister<Color> colorPersister(final Color defaultValue); static final double DEFAULT_FACTOR; }### Answer:
@Test(expected = IllegalArgumentException.class) public void unknownColor() { Colors.forName("unknown"); } |
### Question:
Color { public static Color parseHex(String hexColor) { if (!hexColor.startsWith("#")) { throw new IllegalArgumentException(); } hexColor = hexColor.substring(1); if (hexColor.length() != 6) { throw new IllegalArgumentException(); } Integer r = Integer.valueOf(hexColor.substring(0, 2), 16); Integer g = Integer.valueOf(hexColor.substring(2, 4), 16); Integer b = Integer.valueOf(hexColor.substring(4, 6), 16); return new Color(r, g, b); } Color(int r, int g, int b, int a); Color(int r, int g, int b); static Color parseColor(String text); static Color parseHex(String hexColor); int getRed(); int getGreen(); int getBlue(); int getAlpha(); Color changeAlpha(int newAlpha); @Override boolean equals(Object o); String toCssColor(); String toHexColor(); @Override int hashCode(); @Override String toString(); static final Color TRANSPARENT; static final Color WHITE; static final Color BLACK; static final Color LIGHT_GRAY; static final Color VERY_LIGHT_GRAY; static final Color GRAY; static final Color RED; static final Color LIGHT_GREEN; static final Color GREEN; static final Color DARK_GREEN; static final Color BLUE; static final Color DARK_BLUE; static final Color LIGHT_BLUE; static final Color YELLOW; static final Color LIGHT_YELLOW; static final Color VERY_LIGHT_YELLOW; static final Color MAGENTA; static final Color LIGHT_MAGENTA; static final Color DARK_MAGENTA; static final Color CYAN; static final Color LIGHT_CYAN; static final Color ORANGE; static final Color PINK; static final Color LIGHT_PINK; }### Answer:
@Test public void parseHex() { assertEquals(Color.RED, Color.parseHex(Color.RED.toHexColor())); } |
### Question:
Enums { public static <EnumT extends Enum<EnumT>> EnumT valueOf(Class<EnumT> cls, String name) { for (EnumT e : cls.getEnumConstants()) { if (Objects.equals(name, e.toString())) { return e; } } throw new IllegalArgumentException(name); } private Enums(); static EnumT valueOf(Class<EnumT> cls, String name); }### Answer:
@Test public void enumParsing() { Assert.assertEquals(TestEnum.A, Enums.valueOf(TestEnum.class, "aaa")); }
@Test(expected = IllegalArgumentException.class) public void illegalArgument() { Enums.valueOf(TestEnum.class, "A"); } |
### Question:
Rectangle { public boolean contains(Rectangle r) { return contains(r.origin) && contains(r.origin.add(r.dimension)); } Rectangle(Vector origin, Vector dimension); Rectangle(int x, int y, int width, int height); Rectangle add(Vector v); Rectangle sub(Vector v); boolean contains(Rectangle r); boolean contains(Vector v); Rectangle union(Rectangle rect); boolean intersects(Rectangle rect); Rectangle intersect(Rectangle r); boolean innerIntersects(Rectangle rect); Rectangle changeDimension(Vector dim); double distance(Vector to); Range<Integer> xRange(); Range<Integer> yRange(); @Override int hashCode(); @Override boolean equals(Object obj); DoubleRectangle toDoubleRectangle(); Vector center(); Segment[] getBoundSegments(); Vector[] getBoundPoints(); @Override String toString(); final Vector origin; final Vector dimension; }### Answer:
@Test public void contains() { Rectangle rect = new Rectangle(new Vector(0, 0), new Vector(1, 2)); assertFalse(rect.contains(new Vector(-1, -1))); assertTrue(rect.contains(new Vector(1, 1))); } |
### Question:
Asyncs { public static Async<Void> parallel(Async<?>... asyncs) { return parallel(Arrays.asList(asyncs)); } private Asyncs(); static boolean isFinished(Async<?> async); static Async<ValueT> constant(final ValueT val); static Async<ValueT> failure(final Throwable t); static Async<Void> toVoid(Async<ResultT> a); static Async<SecondT> seq(Async<FirstT> first, final Async<SecondT> second); static Async<Void> parallel(Async<?>... asyncs); static Async<Void> parallel(Collection<? extends Async<?>> asyncs); static Async<Void> parallel(Collection<? extends Async<?>> asyncs, boolean alwaysSucceed); @GwtIncompatible static Async<Void> threadSafeParallel(Collection<? extends Async<?>> asyncs); @GwtIncompatible static Async<List<ItemT>> parallelResult(Collection<Async<ItemT>> asyncs); static Async<List<ItemT>> composite(List<Async<ItemT>> asyncs); static void onAnyResult(Async<?> async, final Runnable r); static Async<ResultT> untilSuccess(final Supplier<Async<ResultT>> s); static Registration delegate(Async<? extends ValueT> from, final AsyncResolver<? super ValueT> to); static Async<Pair<FirstT, SecondT>> pair(Async<FirstT> first, Async<SecondT> second); @GwtIncompatible("Uses threading primitives") static ResultT get(Async<ResultT> async); @GwtIncompatible("Uses threading primitives") static ResultT get(Async<ResultT> async, final long timeout, final TimeUnit timeUnit); }### Answer:
@Test public void emptyParallel() { assertThat(Asyncs.parallel(), voidSuccess()); } |
### Question:
Rectangle { public boolean intersects(Rectangle rect) { Vector t1 = origin; Vector t2 = origin.add(dimension); Vector r1 = rect.origin; Vector r2 = rect.origin.add(rect.dimension); return r2.x >= t1.x && t2.x >= r1.x && r2.y >= t1.y && t2.y >= r1.y; } Rectangle(Vector origin, Vector dimension); Rectangle(int x, int y, int width, int height); Rectangle add(Vector v); Rectangle sub(Vector v); boolean contains(Rectangle r); boolean contains(Vector v); Rectangle union(Rectangle rect); boolean intersects(Rectangle rect); Rectangle intersect(Rectangle r); boolean innerIntersects(Rectangle rect); Rectangle changeDimension(Vector dim); double distance(Vector to); Range<Integer> xRange(); Range<Integer> yRange(); @Override int hashCode(); @Override boolean equals(Object obj); DoubleRectangle toDoubleRectangle(); Vector center(); Segment[] getBoundSegments(); Vector[] getBoundPoints(); @Override String toString(); final Vector origin; final Vector dimension; }### Answer:
@Test public void intersects() { assertFalse(new Rectangle(0, 0, 1, 1).intersects(new Rectangle(2, 2, 1, 1))); assertTrue(new Rectangle(0, 0, 2, 2).intersects(new Rectangle(1, 1, 2, 2))); } |
### Question:
Persisters { public static Persister<Integer> intPersister() { return INT_PERSISTER; } private Persisters(); static Persister<String> stringPersister(); static Persister<Integer> intPersister(); static Persister<Integer> intPersister(final int defaultValue); static Persister<E> enumPersister(final Class<E> cls, final E defaultValue); static Persister<Long> longPersister(); static Persister<Boolean> booleanPersister(); static Persister<Boolean> booleanPersister(final boolean defaultValue); static Persister<Double> doublePersister(); static Persister<Double> doublePersister(final double defaultValue); static Persister<ListT> listPersister(final Persister<T> itemPersister, final Supplier<ListT> empty); }### Answer:
@Test public void nullInt() { testNull(Persisters.intPersister(10)); } |
### Question:
Persisters { public static Persister<Long> longPersister() { return LONG_PERSISTER; } private Persisters(); static Persister<String> stringPersister(); static Persister<Integer> intPersister(); static Persister<Integer> intPersister(final int defaultValue); static Persister<E> enumPersister(final Class<E> cls, final E defaultValue); static Persister<Long> longPersister(); static Persister<Boolean> booleanPersister(); static Persister<Boolean> booleanPersister(final boolean defaultValue); static Persister<Double> doublePersister(); static Persister<Double> doublePersister(final double defaultValue); static Persister<ListT> listPersister(final Persister<T> itemPersister, final Supplier<ListT> empty); }### Answer:
@Test public void nullLong() { testNull(Persisters.longPersister()); } |
### Question:
Persisters { public static Persister<Boolean> booleanPersister() { return BOOLEAN_PERSISTER; } private Persisters(); static Persister<String> stringPersister(); static Persister<Integer> intPersister(); static Persister<Integer> intPersister(final int defaultValue); static Persister<E> enumPersister(final Class<E> cls, final E defaultValue); static Persister<Long> longPersister(); static Persister<Boolean> booleanPersister(); static Persister<Boolean> booleanPersister(final boolean defaultValue); static Persister<Double> doublePersister(); static Persister<Double> doublePersister(final double defaultValue); static Persister<ListT> listPersister(final Persister<T> itemPersister, final Supplier<ListT> empty); }### Answer:
@Test public void nullBoolean() { testNull(Persisters.booleanPersister(true)); } |
### Question:
Persisters { public static Persister<Double> doublePersister() { return DOUBLE_PERSISTER; } private Persisters(); static Persister<String> stringPersister(); static Persister<Integer> intPersister(); static Persister<Integer> intPersister(final int defaultValue); static Persister<E> enumPersister(final Class<E> cls, final E defaultValue); static Persister<Long> longPersister(); static Persister<Boolean> booleanPersister(); static Persister<Boolean> booleanPersister(final boolean defaultValue); static Persister<Double> doublePersister(); static Persister<Double> doublePersister(final double defaultValue); static Persister<ListT> listPersister(final Persister<T> itemPersister, final Supplier<ListT> empty); }### Answer:
@Test public void nullDouble() { testNull(Persisters.doublePersister(1.5)); } |
### Question:
Persisters { public static Persister<String> stringPersister() { return STRING_PERSISTER; } private Persisters(); static Persister<String> stringPersister(); static Persister<Integer> intPersister(); static Persister<Integer> intPersister(final int defaultValue); static Persister<E> enumPersister(final Class<E> cls, final E defaultValue); static Persister<Long> longPersister(); static Persister<Boolean> booleanPersister(); static Persister<Boolean> booleanPersister(final boolean defaultValue); static Persister<Double> doublePersister(); static Persister<Double> doublePersister(final double defaultValue); static Persister<ListT> listPersister(final Persister<T> itemPersister, final Supplier<ListT> empty); }### Answer:
@Test public void nullString() { Persister<String> persister = Persisters.stringPersister(); assertNull(persister.deserialize(persister.serialize(null))); } |
### Question:
Interval { public boolean contains(int point) { return myLowerBound <= point && point <= myUpperBound; } Interval(int lowerBound, int upperBound); int getLowerBound(); int getUpperBound(); int getLength(); boolean contains(int point); boolean contains(Interval other); boolean intersects(Interval other); Interval union(Interval other); Interval add(int delta); Interval sub(int delta); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void contains() { checkContains(i_1_4); checkContains(2, 3); checkContains(1, 2); checkContains(3, 4); checkNotContains(0, 4); checkNotContains(1, 5); checkNotContains(0, 5); checkNotContains(4, 10); } |
### Question:
Interval { public boolean intersects(Interval other) { return contains(other.getLowerBound()) || other.contains(getLowerBound()); } Interval(int lowerBound, int upperBound); int getLowerBound(); int getUpperBound(); int getLength(); boolean contains(int point); boolean contains(Interval other); boolean intersects(Interval other); Interval union(Interval other); Interval add(int delta); Interval sub(int delta); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void intersects() { checkIntersects(i_1_4); checkIntersects(2, 3); checkIntersects(1, 2); checkIntersects(3, 4); checkIntersects(0, 4); checkIntersects(0, 1); checkIntersects(2, 5); checkIntersects(4, 5); checkIntersects(0, 5); checkNotIntersects(-1, 0); checkNotIntersects(5, 6); } |
### Question:
Interval { public Interval union(Interval other) { return new Interval(Math.min(myLowerBound, other.myLowerBound), Math.max(myUpperBound, other.myUpperBound)); } Interval(int lowerBound, int upperBound); int getLowerBound(); int getUpperBound(); int getLength(); boolean contains(int point); boolean contains(Interval other); boolean intersects(Interval other); Interval union(Interval other); Interval add(int delta); Interval sub(int delta); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void union() { checkUnion(i(1, 2), i(3, 4)); checkUnion(i(1, 3), i(2, 4)); checkUnion(i(3, 4), i(1, 2)); checkUnion(i(2, 4), i(1, 3)); checkUnion(i_1_4, i(2, 3)); checkUnion(i(2, 3), i_1_4); } |
### Question:
Interval { public Interval add(int delta) { return new Interval(myLowerBound + delta, myUpperBound + delta); } Interval(int lowerBound, int upperBound); int getLowerBound(); int getUpperBound(); int getLength(); boolean contains(int point); boolean contains(Interval other); boolean intersects(Interval other); Interval union(Interval other); Interval add(int delta); Interval sub(int delta); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void add() { checkAdd(i(0, 3), 1); checkAdd(i_1_4, 0); checkAdd(i(2, 5), -1); } |
### Question:
Rectangle { public Rectangle intersect(Rectangle r) { if (!intersects(r)) { throw new IllegalStateException("rectangle [" + this + "] doesn't intersect [" + r + "]"); } Vector too = origin.add(dimension); Vector roo = r.origin.add(r.dimension); Vector ioo = too.min(roo); Vector io = origin.max(r.origin); return new Rectangle(io, ioo.sub(io)); } Rectangle(Vector origin, Vector dimension); Rectangle(int x, int y, int width, int height); Rectangle add(Vector v); Rectangle sub(Vector v); boolean contains(Rectangle r); boolean contains(Vector v); Rectangle union(Rectangle rect); boolean intersects(Rectangle rect); Rectangle intersect(Rectangle r); boolean innerIntersects(Rectangle rect); Rectangle changeDimension(Vector dim); double distance(Vector to); Range<Integer> xRange(); Range<Integer> yRange(); @Override int hashCode(); @Override boolean equals(Object obj); DoubleRectangle toDoubleRectangle(); Vector center(); Segment[] getBoundSegments(); Vector[] getBoundPoints(); @Override String toString(); final Vector origin; final Vector dimension; }### Answer:
@Test public void intersection() { assertEquals(new Rectangle(1, 1, 1, 1), new Rectangle(0, 0, 2, 2).intersect(new Rectangle(1, 1, 2, 2))); assertEquals(new Rectangle(1, 1, 2, 2), new Rectangle(0, 0, 3, 3).intersect(new Rectangle(1, 1, 2, 2))); } |
### Question:
Interval { public Interval sub(int delta) { return new Interval(myLowerBound - delta, myUpperBound - delta); } Interval(int lowerBound, int upperBound); int getLowerBound(); int getUpperBound(); int getLength(); boolean contains(int point); boolean contains(Interval other); boolean intersects(Interval other); Interval union(Interval other); Interval add(int delta); Interval sub(int delta); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void sub() { checkSub(i(0, 3), -1); checkSub(i_1_4, 0); checkSub(i(2, 5), 1); } |
### Question:
ThrowableHandlers { static void handleError(Throwable t) { if (isClient(t)) { return; } Error error = getError(t); if (error != null) { throw error; } } private ThrowableHandlers(); static Registration addHandler(Consumer<? super Throwable> handler); static void asInProduction(Runnable r); static void handle(Throwable t); static boolean checkForLeaks(PrintStream stream); static final boolean DEBUG; }### Answer:
@Test public void handleClientException() { ThrowableHandlers.handleError(createGwtException()); }
@Test public void handleClientError() { ThrowableHandlers.handleError(createGwtError()); }
@Test public void handleClientInnerError() { ThrowableHandlers.handleError(new RuntimeException(createGwtError())); }
@Test public void handleServerException() { ThrowableHandlers.handleError(new RuntimeException()); }
@Test(expected = NoClassDefFoundError.class) public void handleServerError() { ThrowableHandlers.handleError(new NoClassDefFoundError()); }
@Test(expected = NoClassDefFoundError.class) public void handleServerInnerError() { ThrowableHandlers.handleError(new RuntimeException(new NoClassDefFoundError())); } |
### Question:
RunningEdtManager implements EdtManager, EventDispatchThread { @Override public final void schedule(Runnable r) { checkCanSchedule(); doSchedule(r); } RunningEdtManager(); RunningEdtManager(String name); @Override EventDispatchThread getEdt(); @Override final void finish(); @Override final void kill(); @Override long getCurrentTimeMillis(); @Override final void schedule(Runnable r); @Override final Registration schedule(int delay, Runnable r); @Override final Registration scheduleRepeating(int period, Runnable r); @Override final boolean isStopped(); final void flush(); final void flush(final int tasksNum); String getName(); int size(); boolean isEmpty(); @Override String toString(); }### Answer:
@Test public void exceptionInTask() { ThrowableHandlers.asInProduction(new Runnable() { @Override public void run() { manager.schedule(new Runnable() { @Override public void run() { throw new RuntimeException(); } }); } }); final Value<Boolean> taskCompleted = new Value<>(false); manager.schedule(new Runnable() { @Override public void run() { taskCompleted.set(true); } }); assertTrue(taskCompleted.get()); } |
### Question:
EdtManagerPool implements EdtManagerFactory { boolean checkManager(EdtManager manager) { synchronized (myLock) { EdtManagerAdapter adapter = (EdtManagerAdapter) manager; return adapter.myManager == myManagers[adapter.myIndex]; } } EdtManagerPool(String name, int poolSize, EdtManagerFactory factory); @Override EdtManager createEdtManager(String name); }### Answer:
@Test public void checkManager() { init(); EdtManager temp1 = createManager(); EdtManager checking = createManager(); temp1.finish(); EdtManager temp2 = createManager(); assertTrue(pool.checkManager(checking)); } |
### Question:
ExecutorEdtManager implements EdtManager, EventDispatchThread { @Override public void finish() { ensureCanShutdown(); myEdt.getExecutor().shutdown(); waitTermination(); } ExecutorEdtManager(); ExecutorEdtManager(String name); @Override EventDispatchThread getEdt(); @Override void finish(); @Override void kill(); @Override boolean isStopped(); @Override long getCurrentTimeMillis(); @Override void schedule(Runnable runnable); @Override Registration schedule(int delay, Runnable r); @Override Registration scheduleRepeating(int period, Runnable r); @Override String toString(); }### Answer:
@Test public void finishFromItself() { shutdownFromItself(new Consumer<EdtManager>() { @Override public void accept(EdtManager edtManager) { edtManager.finish(); } }); } |
### Question:
Rectangle { public Rectangle union(Rectangle rect) { Vector newOrigin = origin.min(rect.origin); Vector corner = origin.add(dimension); Vector rectCorner = rect.origin.add(rect.dimension); Vector newCorner = corner.max(rectCorner); Vector newDimension = newCorner.sub(newOrigin); return new Rectangle(newOrigin, newDimension); } Rectangle(Vector origin, Vector dimension); Rectangle(int x, int y, int width, int height); Rectangle add(Vector v); Rectangle sub(Vector v); boolean contains(Rectangle r); boolean contains(Vector v); Rectangle union(Rectangle rect); boolean intersects(Rectangle rect); Rectangle intersect(Rectangle r); boolean innerIntersects(Rectangle rect); Rectangle changeDimension(Vector dim); double distance(Vector to); Range<Integer> xRange(); Range<Integer> yRange(); @Override int hashCode(); @Override boolean equals(Object obj); DoubleRectangle toDoubleRectangle(); Vector center(); Segment[] getBoundSegments(); Vector[] getBoundPoints(); @Override String toString(); final Vector origin; final Vector dimension; }### Answer:
@Test public void union() { assertEquals(new Rectangle(0, 0, 3, 3), new Rectangle(0, 0, 1, 1).union(new Rectangle(2, 2, 1, 1))); } |
### Question:
ExecutorEdtManager implements EdtManager, EventDispatchThread { @Override public void kill() { ensureCanShutdown(); myEdt.getExecutor().shutdownNow(); waitTermination(); } ExecutorEdtManager(); ExecutorEdtManager(String name); @Override EventDispatchThread getEdt(); @Override void finish(); @Override void kill(); @Override boolean isStopped(); @Override long getCurrentTimeMillis(); @Override void schedule(Runnable runnable); @Override Registration schedule(int delay, Runnable r); @Override Registration scheduleRepeating(int period, Runnable r); @Override String toString(); }### Answer:
@Test public void killFromItself() { shutdownFromItself(new Consumer<EdtManager>() { @Override public void accept(EdtManager edtManager) { edtManager.kill(); } }); } |
### Question:
ListItemProperty extends BaseReadableProperty<ValueT> implements Property<ValueT>, Disposable { @Override public ValueT get() { if (isValid()) { return myList.get(getIndex().get()); } else { return null; } } ListItemProperty(ObservableList<ValueT> list, int index); @Override Registration addHandler(EventHandler<? super PropertyChangeEvent<ValueT>> handler); @Override ValueT get(); @Override void set(ValueT value); boolean isValid(); @Override void dispose(); ReadableProperty<Integer> getIndex(); }### Answer:
@Test public void getsTheRightItem() { ObservableList<Integer> list = createList(5); ListItemProperty<Integer> p2 = new ListItemProperty<>(list, 2); assertEquals(2, p2.get().intValue()); ListItemProperty<Integer> p4 = new ListItemProperty<>(list, 4); assertEquals(4, p4.get().intValue()); } |
### Question:
ListItemProperty extends BaseReadableProperty<ValueT> implements Property<ValueT>, Disposable { @Override public void set(ValueT value) { if (isValid()) { myList.set(getIndex().get(), value); } else { throw new IllegalStateException("Property points to an invalid item, can’t set"); } } ListItemProperty(ObservableList<ValueT> list, int index); @Override Registration addHandler(EventHandler<? super PropertyChangeEvent<ValueT>> handler); @Override ValueT get(); @Override void set(ValueT value); boolean isValid(); @Override void dispose(); ReadableProperty<Integer> getIndex(); }### Answer:
@Test public void setsTheRightItem() { ObservableList<Integer> list = createList(5); ListItemProperty<Integer> p2 = new ListItemProperty<>(list, 2); p2.set(12); assertEquals("[0, 1, 12, 3, 4]", "" + list); ListItemProperty<Integer> p4 = new ListItemProperty<>(list, 4); p4.set(14); assertEquals("[0, 1, 12, 3, 14]", "" + list); }
@Test public void firesOnListSet() { list.add(2, 22); list.set(3, 12); assertThat(p1Handler, noEvents()); assertThat(p2Handler, singleEvent( allOf(oldValueIs(2), newValueIs(12)))); assertThat(p3Handler, noEvents()); }
@Test public void firesOnPropertySet() { ObservableList<Integer> list = createList(5); ListItemProperty<Integer> p2 = new ListItemProperty<>(list, 2); MatchingHandler<PropertyChangeEvent<Integer>> p2handler = setTestHandler(p2); p2.set(12); assertThat(p2handler, singleEvent( allOf(oldValueIs(2), newValueIs(12)))); }
@Test public void indexFiresNotOnListSet() { list.set(2, 22); assertThat(p1indexHandler, noEvents()); assertThat(p2indexHandler, noEvents()); assertThat(p3indexHandler, noEvents()); } |
### Question:
ListItemProperty extends BaseReadableProperty<ValueT> implements Property<ValueT>, Disposable { @Override public void dispose() { if (myDisposed) { throw new IllegalStateException("Double dispose"); } if (isValid()) { myReg.dispose(); } myDisposed = true; } ListItemProperty(ObservableList<ValueT> list, int index); @Override Registration addHandler(EventHandler<? super PropertyChangeEvent<ValueT>> handler); @Override ValueT get(); @Override void set(ValueT value); boolean isValid(); @Override void dispose(); ReadableProperty<Integer> getIndex(); }### Answer:
@Test public void disposeImmediately() { p1.dispose(); exception.expect(IllegalStateException.class); p1.dispose(); }
@Test public void indexFiresNotOnDispose() { p1.dispose(); assertThat(p1indexHandler, noEvents()); }
@Test public void indexFiresNotOnDisposeInvalid() { list.remove(1); assertThat(p1indexHandler, allEvents(hasSize(1))); p1.dispose(); assertThat(p1indexHandler, allEvents(hasSize(1))); } |
### Question:
UpdatableProperty extends BaseDerivedProperty<ValueT> { public void update() { somethingChanged(); } protected UpdatableProperty(); @Override String getPropExpr(); void update(); }### Answer:
@Test public void updateFiresEvent() { EventHandler<? super PropertyChangeEvent<String>> handler = Mockito.mock(EventHandler.class); property.addHandler(handler); value = "z"; property.update(); Mockito.verify(handler).onEvent(new PropertyChangeEvent<>(null, "z")); }
@Test public void updateWithoutChangeDoesntFireEvent() { EventHandler<? super PropertyChangeEvent<String>> handler = Mockito.mock(EventHandler.class); property.addHandler(handler); property.update(); Mockito.verifyNoMoreInteractions(handler); } |
### Question:
Rectangle { @Override public int hashCode() { return origin.hashCode() * 31 + dimension.hashCode(); } Rectangle(Vector origin, Vector dimension); Rectangle(int x, int y, int width, int height); Rectangle add(Vector v); Rectangle sub(Vector v); boolean contains(Rectangle r); boolean contains(Vector v); Rectangle union(Rectangle rect); boolean intersects(Rectangle rect); Rectangle intersect(Rectangle r); boolean innerIntersects(Rectangle rect); Rectangle changeDimension(Vector dim); double distance(Vector to); Range<Integer> xRange(); Range<Integer> yRange(); @Override int hashCode(); @Override boolean equals(Object obj); DoubleRectangle toDoubleRectangle(); Vector center(); Segment[] getBoundSegments(); Vector[] getBoundPoints(); @Override String toString(); final Vector origin; final Vector dimension; }### Answer:
@Test public void hashCodeWorks() { assertEquals(new Rectangle(0, 0, 3, 3).hashCode(), new Rectangle(0, 0, 3, 3).hashCode()); } |
### Question:
PropertyPersisters { public static <T> Persister<Property<T>> valuePropertyPersister(final Persister<T> itemPersister) { return new Persister<Property<T>>() { @Override public Property<T> deserialize(String value) { if (value == null) { return null; } if (!value.isEmpty() && value.charAt(0) == 'v') { return new ValueProperty<>(itemPersister.deserialize(value.substring(1))); } return new ValueProperty<>(); } @Override public String serialize(Property<T> value) { if (value == null) { return null; } if (value.get() == null) { return "n"; } else { return "v" + itemPersister.serialize(value.get()); } } @Override public String toString() { return "valuePropertyPersister[using = " + itemPersister + "]"; } }; } private PropertyPersisters(); static Persister<Property<T>> valuePropertyPersister(final Persister<T> itemPersister); }### Answer:
@Test public void nullStringValueProperty() { testNull(PropertyPersisters.valuePropertyPersister(stringPersister())); }
@Test public void valuePropertyEmptyString() { assertNull(PropertyPersisters.valuePropertyPersister(stringPersister()).deserialize("").get()); } |
### Question:
PropertyBinding { public static <ValueT> Registration bindTwoWay(final Property<ValueT> source, final Property<ValueT> target) { final Property<Boolean> syncing = new ValueProperty<>(false); target.set(source.get()); class UpdatingEventHandler implements EventHandler<PropertyChangeEvent<ValueT>> { private boolean myForward; UpdatingEventHandler(boolean forward) { myForward = forward; } @Override public void onEvent(PropertyChangeEvent<ValueT> event) { if (syncing.get()) return; syncing.set(true); try { if (myForward) { target.set(source.get()); } else { source.set(target.get()); } } finally { syncing.set(false); } } } return new CompositeRegistration( source.addHandler(new UpdatingEventHandler(true)), target.addHandler(new UpdatingEventHandler(false)) ); } private PropertyBinding(); static Registration bindOneWay(
ReadableProperty<? extends ValueT> source, final WritableProperty<? super ValueT> target); static Registration bindTwoWay(final Property<ValueT> source, final Property<ValueT> target); }### Answer:
@Test public void bidirectionalSync() { source.set("239"); Registration reg = PropertyBinding.bindTwoWay(source, target); assertEquals("239", target.get()); target.set("z"); assertEquals("z", source.get()); reg.remove(); source.set("zzz"); assertEquals("z", target.get()); } |
### Question:
ListMap { @Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append("{"); for (int i = 0; i < myData.length; i += 2) { @SuppressWarnings("unchecked") K k = (K) myData[i]; @SuppressWarnings("unchecked") V v = (V) myData[i + 1]; if (i != 0) { builder.append(","); } builder.append(k).append("=").append(v); } builder.append("}"); return builder.toString(); } ListMap(); boolean containsKey(K key); V remove(K key); Set<K> keySet(); boolean isEmpty(); Collection<V> values(); Set<Entry> entrySet(); int size(); V put(K key, V value); V get(K key); @Override String toString(); }### Answer:
@Test public void empty() { assertEquals("{}", list.toString()); } |
### Question:
ListMap { public V put(K key, V value) { int index = findByKey(key); if (index >= 0) { @SuppressWarnings("unchecked") V oldValue = (V) myData[index + 1]; myData[index + 1] = value; return oldValue; } Object[] newArray = new Object[myData.length + 2]; System.arraycopy(myData, 0, newArray, 0, myData.length); newArray[myData.length] = key; newArray[myData.length + 1] = value; myData = newArray; return null; } ListMap(); boolean containsKey(K key); V remove(K key); Set<K> keySet(); boolean isEmpty(); Collection<V> values(); Set<Entry> entrySet(); int size(); V put(K key, V value); V get(K key); @Override String toString(); }### Answer:
@Test public void put() { list.put("a", "b"); assertEquals("{a=b}", list.toString()); } |
### Question:
ListMap { public boolean isEmpty() { return size() == 0; } ListMap(); boolean containsKey(K key); V remove(K key); Set<K> keySet(); boolean isEmpty(); Collection<V> values(); Set<Entry> entrySet(); int size(); V put(K key, V value); V get(K key); @Override String toString(); }### Answer:
@Test public void isEmpty() { assertTrue(list.isEmpty()); } |
### Question:
ListMap { public boolean containsKey(K key) { return findByKey(key) >= 0; } ListMap(); boolean containsKey(K key); V remove(K key); Set<K> keySet(); boolean isEmpty(); Collection<V> values(); Set<Entry> entrySet(); int size(); V put(K key, V value); V get(K key); @Override String toString(); }### Answer:
@Test public void containsKey() { list.put("a", "b"); assertTrue(list.containsKey("a")); } |
### Question:
Vector { @Override public boolean equals(Object obj) { if (!(obj instanceof Vector)) return false; Vector otherVector = (Vector) obj; return x == otherVector.x && y == otherVector.y; } Vector(int x, int y); Vector add(Vector v); Vector sub(Vector v); Vector negate(); Vector max(Vector v); Vector min(Vector v); Vector mul(int i); Vector div(int i); int dotProduct(Vector v); double length(); DoubleVector toDoubleVector(); Vector abs(); boolean isParallel(Vector to); Vector orthogonal(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); int getX(); int getY(); int get(Axis axis); static final Vector ZERO; final int x; final int y; }### Answer:
@Test public void equals() { assertThat(new Vector(1, 2), is(new Vector(1, 2))); assertThat(new Vector(1, 2), is(not(new Vector(2, 1)))); } |
### Question:
ObservableCollections { public static <ItemT> ReadableProperty<Boolean> all( final ObservableCollection<ItemT> collection, Predicate<? super ItemT> predicate) { return Properties.map(count(collection, predicate), new Function<Integer, Boolean>() { @Override public Boolean apply(Integer value) { return value == collection.size(); } }); } private ObservableCollections(); static ObservableList<ItemT> toObservable(List<ItemT> l); static ObservableSet<ItemT> toObservable(Set<ItemT> s); static WritableProperty<ItemT> asWritableProp(final ObservableCollection<ItemT> coll); static Property<List<ItemT>> asProperty(final ObservableList<ItemT> list); static ObservableCollection<ItemT> empty(); static ObservableList<ItemT> emptyList(); static ReadableProperty<Integer> count(
final ObservableCollection<ItemT> collection, final Predicate<? super ItemT> predicate); static ReadableProperty<Boolean> all(
final ObservableCollection<ItemT> collection, Predicate<? super ItemT> predicate); static ReadableProperty<Boolean> any(
ObservableCollection<ItemT> collection, Predicate<? super ItemT> predicate); static ObservableCollection<ItemT> selectCollection(
ReadableProperty<ValueT> p, Function<ValueT, ObservableCollection<? extends ItemT>> s); static ObservableList<ItemT> selectList(
ReadableProperty<ValueT> p, Function<ValueT, ObservableList<? extends ItemT>> s); }### Answer:
@Test public void allTest() { ObservableCollection<String> collection = new ObservableArrayList<>(); ReadableProperty<Boolean> all = ObservableCollections.all(collection, STARTS_WITH_A); assertTrue(all.get()); collection.add("a"); assertTrue(all.get()); collection.add("b"); assertFalse(all.get()); collection.clear(); assertTrue(all.get()); } |
### Question:
ObservableCollections { public static <ItemT> ReadableProperty<Boolean> any( ObservableCollection<ItemT> collection, Predicate<? super ItemT> predicate) { return Properties.map(count(collection, predicate), new Function<Integer, Boolean>() { @Override public Boolean apply(Integer value) { return value > 0; } }); } private ObservableCollections(); static ObservableList<ItemT> toObservable(List<ItemT> l); static ObservableSet<ItemT> toObservable(Set<ItemT> s); static WritableProperty<ItemT> asWritableProp(final ObservableCollection<ItemT> coll); static Property<List<ItemT>> asProperty(final ObservableList<ItemT> list); static ObservableCollection<ItemT> empty(); static ObservableList<ItemT> emptyList(); static ReadableProperty<Integer> count(
final ObservableCollection<ItemT> collection, final Predicate<? super ItemT> predicate); static ReadableProperty<Boolean> all(
final ObservableCollection<ItemT> collection, Predicate<? super ItemT> predicate); static ReadableProperty<Boolean> any(
ObservableCollection<ItemT> collection, Predicate<? super ItemT> predicate); static ObservableCollection<ItemT> selectCollection(
ReadableProperty<ValueT> p, Function<ValueT, ObservableCollection<? extends ItemT>> s); static ObservableList<ItemT> selectList(
ReadableProperty<ValueT> p, Function<ValueT, ObservableList<? extends ItemT>> s); }### Answer:
@Test public void anyTest() { ObservableCollection<String> collection = new ObservableArrayList<>(); ReadableProperty<Boolean> any = ObservableCollections.any(collection, STARTS_WITH_A); assertFalse(any.get()); collection.add("b"); assertFalse(any.get()); collection.add("a"); assertTrue(any.get()); collection.clear(); assertFalse(any.get()); } |
### Question:
ObservableSetWrapper implements ObservableSet<TargetItemT> { @Override public boolean add(TargetItemT wrapper) { return mySource.add(myTtoS.apply(wrapper)); } ObservableSetWrapper(ObservableSet<SourceItemT> source, Function<SourceItemT, TargetItemT> toTarget, Function<TargetItemT, SourceItemT> toSource); @Override Registration addListener(CollectionListener<? super TargetItemT> l); @Override Registration addHandler(final EventHandler<? super CollectionItemEvent<? extends TargetItemT>> handler); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<TargetItemT> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(TargetItemT wrapper); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends TargetItemT> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); }### Answer:
@Test public void setMapAddSource() { source.add(15.0); assertThat(target, containsInAnyOrder(11, 16, 21, 31)); listener.assertEvents(1, 0); assertThat(listener.getAddEvents().get(0), is(addEvent(equalTo(16), equalTo(-1)))); }
@Test public void listMapAddTarget() { target.add(15); assertThat(target, containsInAnyOrder(11, 15, 21, 31)); assertThat(source, containsInAnyOrder(10.0, 14.0, 20.0, 30.0)); listener.assertEvents(1, 0); assertThat(listener.getAddEvents().get(0), is(addEvent(equalTo(15), equalTo(-1)))); } |
### Question:
ObservableSetWrapper implements ObservableSet<TargetItemT> { @Override public boolean remove(Object o) { @SuppressWarnings("unchecked") TargetItemT targetItem = (TargetItemT) o; return mySource.remove(myTtoS.apply(targetItem)); } ObservableSetWrapper(ObservableSet<SourceItemT> source, Function<SourceItemT, TargetItemT> toTarget, Function<TargetItemT, SourceItemT> toSource); @Override Registration addListener(CollectionListener<? super TargetItemT> l); @Override Registration addHandler(final EventHandler<? super CollectionItemEvent<? extends TargetItemT>> handler); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<TargetItemT> iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(TargetItemT wrapper); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends TargetItemT> c); @Override boolean retainAll(Collection<?> c); @Override boolean removeAll(Collection<?> c); @Override void clear(); }### Answer:
@Test public void setMapRemoveSource() { source.remove(30.0); assertThat(target, containsInAnyOrder(11, 21)); listener.assertEvents(0, 1); assertThat(listener.getRemoveEvents().get(0), is(removeEvent(equalTo(31), equalTo(-1)))); }
@Test public void setMapRemoveTarget() { target.remove(31); assertThat(target, containsInAnyOrder(11, 21)); assertThat(source, containsInAnyOrder(10.0, 20.0)); listener.assertEvents(0, 1); assertThat(listener.getRemoveEvents().get(0), is(removeEvent(equalTo(31), equalTo(-1)))); } |
### Question:
TreePath implements Comparable<TreePath<CompositeT>> { @Override public int compareTo(TreePath<CompositeT> o) { int maxIndex = Math.min(myPath.size(), o.myPath.size()); for (int i = 0; i < maxIndex; i++) { int delta = myPath.get(i) - o.myPath.get(i); if (delta != 0) return delta; } return myPath.size() - o.myPath.size(); } TreePath(CompositeT composite); TreePath(CompositeT from, CompositeT to); private TreePath(List<Integer> path); static void sort(List<? extends CompositeT> composites); static TreePath<CompositeT> deserialize(String text); CompositeT get(CompositeT root); boolean isValid(CompositeT root); boolean isEmpty(); int getLastIndex(); TreePath<CompositeT> getParent(); TreePath<CompositeT> getChild(int index); String serialize(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(TreePath<CompositeT> o); @Override String toString(); }### Answer:
@Test public void pathComparison() { assertTrue(new TreePath<>(root).compareTo(new TreePath<>(child1)) < 0); assertTrue(new TreePath<>(child1).compareTo(new TreePath<>(child2)) < 0); assertEquals(0, new TreePath<>(child1).compareTo(new TreePath<>(child1))); } |
### Question:
TreePath implements Comparable<TreePath<CompositeT>> { public static <CompositeT extends Composite<CompositeT>> void sort(List<? extends CompositeT> composites) { final Map<CompositeT, TreePath<CompositeT>> paths = new HashMap<>(); for (CompositeT composite : composites) { paths.put(composite, new TreePath<>(composite)); } Collections.sort(composites, new Comparator<CompositeT>() { @Override public int compare(CompositeT composite1, CompositeT composite2) { return paths.get(composite1).compareTo(paths.get(composite2)); } }); } TreePath(CompositeT composite); TreePath(CompositeT from, CompositeT to); private TreePath(List<Integer> path); static void sort(List<? extends CompositeT> composites); static TreePath<CompositeT> deserialize(String text); CompositeT get(CompositeT root); boolean isValid(CompositeT root); boolean isEmpty(); int getLastIndex(); TreePath<CompositeT> getParent(); TreePath<CompositeT> getChild(int index); String serialize(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(TreePath<CompositeT> o); @Override String toString(); }### Answer:
@Test public void sortByPath() { List<TestComposite> composites = new ArrayList<>(Arrays.asList(child2, child1, root)); TreePath.sort(composites); assertEquals(Arrays.asList(root, child1, child2), composites); } |
### Question:
TreePath implements Comparable<TreePath<CompositeT>> { public boolean isValid(CompositeT root) { CompositeT current = root; for (Integer i : myPath) { List<CompositeT> children = current.children(); if (i >= children.size()) { return false; } current = children.get(i); } return true; } TreePath(CompositeT composite); TreePath(CompositeT from, CompositeT to); private TreePath(List<Integer> path); static void sort(List<? extends CompositeT> composites); static TreePath<CompositeT> deserialize(String text); CompositeT get(CompositeT root); boolean isValid(CompositeT root); boolean isEmpty(); int getLastIndex(); TreePath<CompositeT> getParent(); TreePath<CompositeT> getChild(int index); String serialize(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(TreePath<CompositeT> o); @Override String toString(); }### Answer:
@Test public void pathValidity() { TreePath<TestComposite> path = new TreePath<>(child1); assertTrue(path.isValid(root)); assertFalse(path.isValid(child1)); } |
### Question:
Vector { public Vector add(Vector v) { return new Vector(x + v.x, y + v.y); } Vector(int x, int y); Vector add(Vector v); Vector sub(Vector v); Vector negate(); Vector max(Vector v); Vector min(Vector v); Vector mul(int i); Vector div(int i); int dotProduct(Vector v); double length(); DoubleVector toDoubleVector(); Vector abs(); boolean isParallel(Vector to); Vector orthogonal(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); int getX(); int getY(); int get(Axis axis); static final Vector ZERO; final int x; final int y; }### Answer:
@Test public void add() { assertThat(new Vector(1, 2).add(new Vector(1, 2)), is(new Vector(2, 4))); } |
### Question:
User extends BaseExpression { public Result apply(PathData item) throws IOException { if(requiredUser.equals(getFileStatus(item).getOwner())) { return Result.PASS; } return Result.FAIL; } User(); @Override void addArguments(Deque<String> args); @Override void initialise(FindOptions options); Result apply(PathData item); static void registerExpression(ExpressionFactory factory); }### Answer:
@Test public void applyBlank() throws IOException { when(fileStatus.getOwner()).thenReturn(""); assertEquals(Result.FAIL, user.apply(item)); }
@Test public void applyNull() throws IOException { when(fileStatus.getOwner()).thenReturn(null); assertEquals(Result.FAIL, user.apply(item)); }
@Test public void applyPass() throws IOException{ when(fileStatus.getOwner()).thenReturn("user"); assertEquals(Result.PASS, user.apply(item)); }
@Test public void applyFail() throws IOException { when(fileStatus.getOwner()).thenReturn("notuser"); assertEquals(Result.FAIL, user.apply(item)); } |
### Question:
And extends BaseExpression { @Override public void addChildren(Deque<Expression> expressions) { addChildren(expressions, 2); } And(); @Override Result apply(PathData item); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); static void registerExpression(ExpressionFactory factory); }### Answer:
@Test public void testInit() throws IOException { And and = new And(); Expression first = mock(Expression.class); Expression second = mock(Expression.class); Deque<Expression> children = new LinkedList<Expression>(); children.add(second); children.add(first); and.addChildren(children); FindOptions options = mock(FindOptions.class); and.initialise(options); verify(first).initialise(options); verify(second).initialise(options); verifyNoMoreInteractions(first); verifyNoMoreInteractions(second); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public void initialise(FindOptions options) throws IOException { expression.initialise(options); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void initialise() throws IOException { FindOptions options = mock(FindOptions.class); test.initialise(options); verify(expr).initialise(options); verifyNoMoreInteractions(expr); } |
### Question:
Depth extends BaseExpression { @Override public void initialise(FindOptions options) { options.setDepth(true); } Depth(); @Override Result apply(PathData item); @Override void initialise(FindOptions options); static void registerExpression(ExpressionFactory factory); }### Answer:
@Test public void initialise() throws IOException{ FindOptions options = new FindOptions(); Depth depth = new Depth(); assertFalse(options.isDepth()); depth.initialise(options); assertTrue(options.isDepth()); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public Result apply(PathData item) throws IOException { return expression.apply(item); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void apply() throws IOException { PathData item = mock(PathData.class); when(expr.apply(item)).thenReturn(Result.PASS).thenReturn(Result.FAIL); assertEquals(Result.PASS, test.apply(item)); assertEquals(Result.FAIL, test.apply(item)); verify(expr, times(2)).apply(item); verifyNoMoreInteractions(expr); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public void finish() throws IOException { expression.finish(); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void finish() throws IOException { test.finish(); verify(expr).finish(); verifyNoMoreInteractions(expr); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public String[] getUsage() { return expression.getUsage(); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void getUsage() { String[] usage = new String[]{"Usage 1", "Usage 2", "Usage 3"}; when(expr.getUsage()).thenReturn(usage); assertArrayEquals(usage, test.getUsage()); verify(expr).getUsage(); verifyNoMoreInteractions(expr); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public String[] getHelp() { return expression.getHelp(); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void getHelp() { String[] help = new String[]{"Help 1", "Help 2", "Help 3"}; when(expr.getHelp()).thenReturn(help); assertArrayEquals(help, test.getHelp()); verify(expr).getHelp(); verifyNoMoreInteractions(expr); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public boolean isAction() { return expression.isAction(); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void isAction() { when(expr.isAction()).thenReturn(true).thenReturn(false); assertTrue(test.isAction()); assertFalse(test.isAction()); verify(expr, times(2)).isAction(); verifyNoMoreInteractions(expr); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public boolean isOperator() { return expression.isOperator(); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void isOperator() { when(expr.isAction()).thenReturn(true).thenReturn(false); assertTrue(test.isAction()); assertFalse(test.isAction()); verify(expr, times(2)).isAction(); verifyNoMoreInteractions(expr); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public int getPrecedence() { return expression.getPrecedence(); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void getPrecedence() { int precedence = 12345; when(expr.getPrecedence()).thenReturn(precedence); assertEquals(precedence, test.getPrecedence()); verify(expr).getPrecedence(); verifyNoMoreInteractions(expr); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public void addChildren(Deque<Expression> expressions) { expression.addChildren(expressions); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void addChildren() { @SuppressWarnings("unchecked") Deque<Expression> expressions = mock(Deque.class); test.addChildren(expressions); verify(expr).addChildren(expressions); verifyNoMoreInteractions(expr); } |
### Question:
FilterExpression implements Expression, Configurable { @Override public void addArguments(Deque<String> args) { expression.addArguments(args); } protected FilterExpression(Expression expression); @Override void initialise(FindOptions options); @Override Result apply(PathData item); @Override void finish(); @Override String[] getUsage(); @Override String[] getHelp(); @Override boolean isAction(); @Override boolean isOperator(); @Override int getPrecedence(); @Override void addChildren(Deque<Expression> expressions); @Override void addArguments(Deque<String> args); @Override void setConf(Configuration conf); @Override Configuration getConf(); @Override String toString(); }### Answer:
@Test public void addArguments() { @SuppressWarnings("unchecked") Deque<String> args = mock(Deque.class); test.addArguments(args); verify(expr).addArguments(args); verifyNoMoreInteractions(expr); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.