Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: QualityAnalyzerRunsSchedulerOnStartup implements ApplicationListener<ContextRefreshedEvent> { @Override public void onApplicationEvent(ContextRefreshedEvent event) { if (alreadyExecuted.compareAndSet(false, true)) { List<Project> projects = projectRepository.findAll(); log.info("Schedule analyzer jobs for {} projects", projects.size()); for (Project project : projects) { analyzerScheduler.scheduleAnalyzer(project); } } else { log.info("Projects already scheduled."); } } @Autowired QualityAnalyzerRunsSchedulerOnStartup(QualityAnalyzerScheduler analyzerScheduler, ProjectRepository projectRepository); @Override void onApplicationEvent(ContextRefreshedEvent event); }### Answer: @Test public void scheduleAllProjects() { analyzerRunsSchedulerOnStartup.onApplicationEvent(null); verify(analyzerScheduler).scheduleAnalyzer(projectA); verify(analyzerScheduler).scheduleAnalyzer(projectB); verify(analyzerScheduler).scheduleAnalyzer(projectC); } @Test public void preventSchedulingProjectsTwice() { analyzerRunsSchedulerOnStartup.onApplicationEvent(null); analyzerRunsSchedulerOnStartup.onApplicationEvent(null); verify(analyzerScheduler, times(1)).scheduleAnalyzer(projectA); verify(analyzerScheduler, times(1)).scheduleAnalyzer(projectB); verify(analyzerScheduler, times(1)).scheduleAnalyzer(projectC); }
### Question: SonarServerValidator implements Validator { @Override public boolean supports(Class<?> clazz) { return SonarServer.class.equals(clazz); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }### Answer: @Test public void shouldSupportSonarServerType() { assertThat(validator.supports(SonarServer.class)).isTrue(); } @Test public void shouldNotSupportOtherTypeThanSonarServer() { assertThat(validator.supports(Object.class)).isFalse(); }
### Question: SonarConnectionSettingsValidator implements Validator { @Override public boolean supports(Class<?> clazz) { return SonarConnectionSettings.class.equals(clazz); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }### Answer: @Test public void shouldSupportSonarConnectionSettingsType() { assertThat(validator.supports(SonarConnectionSettings.class)).isTrue(); } @Test public void shouldNotSupportOtherTypeThanSonarConnectionSettings() { assertThat(validator.supports(Object.class)).isFalse(); }
### Question: ThriftyConverterFactory extends Converter.Factory { public static ThriftyConverterFactory create(ProtocolType protocolType) { return new ThriftyConverterFactory(protocolType); } private ThriftyConverterFactory(ProtocolType protocolType); static ThriftyConverterFactory create(ProtocolType protocolType); @Override @SuppressWarnings("unchecked") Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit); @Override @SuppressWarnings("unchecked") Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit); }### Answer: @Test public void generatedClassWithoutAdapter() throws IOException { Retrofit retrofit = new Retrofit.Builder() .baseUrl(server.url("/")) .addConverterFactory(ThriftyConverterFactory.create(ProtocolType.BINARY)) .build(); BrokenService brokenService = retrofit.create(BrokenService.class); try { brokenService.get(); fail(); } catch (IllegalArgumentException ignored) { } }
### Question: Angles { public void setSensorOffset(@NonNull Facing sensorFacing, int sensorOffset) { sanitizeInput(sensorOffset); mSensorFacing = sensorFacing; mSensorOffset = sensorOffset; if (mSensorFacing == Facing.FRONT) { mSensorOffset = sanitizeOutput(360 - mSensorOffset); } print(); } void setSensorOffset(@NonNull Facing sensorFacing, int sensorOffset); void setDisplayOffset(int displayOffset); void setDeviceOrientation(int deviceOrientation); int offset(@NonNull Reference from, @NonNull Reference to, @NonNull Axis axis); boolean flip(@NonNull Reference from, @NonNull Reference to); }### Answer: @Test public void testSetSensorOffset() { angles.setSensorOffset(Facing.BACK, 90); assertEquals(90, angles.mSensorOffset); angles.setSensorOffset(Facing.FRONT, 90); assertEquals(270, angles.mSensorOffset); } @Test(expected = IllegalStateException.class) public void testSetSensorOffset_throws() { angles.setSensorOffset(Facing.BACK, 135); }
### Question: Pool { @NonNull @Override public String toString() { return getClass().getSimpleName() + " - count:" + count() + ", active:" + activeCount() + ", recycled:" + recycledCount(); } Pool(int maxPoolSize, @NonNull Factory<T> factory); boolean isEmpty(); @Nullable T get(); void recycle(@NonNull T item); @CallSuper void clear(); final int count(); @SuppressWarnings("WeakerAccess") final int activeCount(); @SuppressWarnings("WeakerAccess") final int recycledCount(); @NonNull @Override String toString(); }### Answer: @Test public void testToString() { String string = pool.toString(); assertTrue(string.contains("count")); assertTrue(string.contains("active")); assertTrue(string.contains("recycled")); assertTrue(string.contains(Pool.class.getSimpleName())); }
### Question: Pool { public void recycle(@NonNull T item) { synchronized (lock) { LOG.v("RECYCLE - Recycling item.", this); if (--activeCount < 0) { throw new IllegalStateException("Trying to recycle an item which makes " + "activeCount < 0. This means that this or some previous items being " + "recycled were not coming from this pool, or some item was recycled " + "more than once. " + this); } if (!queue.offer(item)) { throw new IllegalStateException("Trying to recycle an item while the queue " + "is full. This means that this or some previous items being recycled " + "were not coming from this pool, or some item was recycled " + "more than once. " + this); } } } Pool(int maxPoolSize, @NonNull Factory<T> factory); boolean isEmpty(); @Nullable T get(); void recycle(@NonNull T item); @CallSuper void clear(); final int count(); @SuppressWarnings("WeakerAccess") final int activeCount(); @SuppressWarnings("WeakerAccess") final int recycledCount(); @NonNull @Override String toString(); }### Answer: @Test(expected = IllegalStateException.class) public void testRecycle_notActive() { Item item = new Item(); pool.recycle(item); }
### Question: Pool { @Nullable public T get() { synchronized (lock) { T item = queue.poll(); if (item != null) { activeCount++; LOG.v("GET - Reusing recycled item.", this); return item; } if (isEmpty()) { LOG.v("GET - Returning null. Too much items requested.", this); return null; } activeCount++; LOG.v("GET - Creating a new item.", this); return factory.create(); } } Pool(int maxPoolSize, @NonNull Factory<T> factory); boolean isEmpty(); @Nullable T get(); void recycle(@NonNull T item); @CallSuper void clear(); final int count(); @SuppressWarnings("WeakerAccess") final int activeCount(); @SuppressWarnings("WeakerAccess") final int recycledCount(); @NonNull @Override String toString(); }### Answer: @Test public void testGet_fromFactory() { pool.get(); assertEquals(1, instances); } @Test public void testGet_whenFull() { for (int i = 0; i < MAX_SIZE; i++) { pool.get(); } assertNull(pool.get()); } @Test public void testInstances() { for (int i = 0; i < MAX_SIZE; i++) { assertEquals(instances, i); pool.get(); } }
### Question: Frame { @Override public boolean equals(Object obj) { return obj instanceof Frame && ((Frame) obj).mTime == mTime; } Frame(@NonNull FrameManager manager); @Override boolean equals(Object obj); @SuppressLint("NewApi") @NonNull Frame freeze(); void release(); @SuppressWarnings("unchecked") @NonNull T getData(); @NonNull Class<?> getDataClass(); long getTime(); @Deprecated int getRotation(); int getRotationToUser(); int getRotationToView(); @NonNull Size getSize(); int getFormat(); }### Answer: @Test public void testEquals() { Frame f1 = new Frame(manager); long time = 1000; f1.setContent("foo", time, 90, 180, new Size(5, 5), ImageFormat.NV21); Frame f2 = new Frame(manager); f2.setContent("bar", time, 0, 90, new Size(10, 10), ImageFormat.NV21); assertEquals(f1, f2); f2.setContent("foo", time + 1, 0, 90, new Size(10, 10), ImageFormat.NV21); assertNotEquals(f1, f2); }
### Question: Frame { @SuppressLint("NewApi") @NonNull public Frame freeze() { ensureHasContent(); Frame other = new Frame(mManager); Object data = mManager.cloneFrameData(getData()); other.setContent(data, mTime, mUserRotation, mViewRotation, mSize, mFormat); return other; } Frame(@NonNull FrameManager manager); @Override boolean equals(Object obj); @SuppressLint("NewApi") @NonNull Frame freeze(); void release(); @SuppressWarnings("unchecked") @NonNull T getData(); @NonNull Class<?> getDataClass(); long getTime(); @Deprecated int getRotation(); int getRotationToUser(); int getRotationToView(); @NonNull Size getSize(); int getFormat(); }### Answer: @Test public void testFreeze() { Frame frame = new Frame(manager); String data = "test data"; long time = 1000; int userRotation = 90; int viewRotation = 90; Size size = new Size(10, 10); int format = ImageFormat.NV21; frame.setContent(data, time, userRotation, viewRotation, size, format); Frame frozen = frame.freeze(); assertEquals(data, frozen.getData()); assertEquals(time, frozen.getTime()); assertEquals(userRotation, frozen.getRotationToUser()); assertEquals(viewRotation, frozen.getRotationToView()); assertEquals(size, frozen.getSize()); frame.setContent("new data", 50, 180, 180, new Size(1, 1), ImageFormat.JPEG); assertEquals(data, frozen.getData()); assertEquals(time, frozen.getTime()); assertEquals(userRotation, frozen.getRotationToUser()); assertEquals(viewRotation, frozen.getRotationToView()); assertEquals(size, frozen.getSize()); assertEquals(format, frozen.getFormat()); }
### Question: AspectRatio implements Comparable<AspectRatio> { @Override public boolean equals(Object o) { if (o == null) { return false; } if (this == o) { return true; } if (o instanceof AspectRatio) { return toFloat() == ((AspectRatio) o).toFloat(); } return false; } private AspectRatio(int x, int y); @NonNull static AspectRatio of(@NonNull Size size); @NonNull static AspectRatio of(int x, int y); @NonNull @SuppressWarnings("WeakerAccess") static AspectRatio parse(@NonNull String string); int getX(); int getY(); boolean matches(@NonNull Size size); boolean matches(@NonNull Size size, float tolerance); @Override boolean equals(Object o); @NonNull @Override String toString(); float toFloat(); @Override int hashCode(); @Override int compareTo(@NonNull AspectRatio another); @SuppressWarnings("SuspiciousNameCombination") @NonNull AspectRatio flip(); }### Answer: @Test public void testEquals() { AspectRatio ratio = AspectRatio.of(50, 10); assertNotNull(ratio); assertEquals(ratio, ratio); AspectRatio ratio1 = AspectRatio.of(5, 1); assertEquals(ratio, ratio1); AspectRatio.sCache.clear(); AspectRatio ratio2 = AspectRatio.of(500, 100); assertEquals(ratio, ratio2); Size size = new Size(500, 100); assertTrue(ratio.matches(size)); }
### Question: AspectRatio implements Comparable<AspectRatio> { @NonNull @SuppressWarnings("WeakerAccess") public static AspectRatio parse(@NonNull String string) { String[] parts = string.split(":"); if (parts.length != 2) { throw new NumberFormatException("Illegal AspectRatio string. Must be x:y"); } int x = Integer.parseInt(parts[0]); int y = Integer.parseInt(parts[1]); return of(x, y); } private AspectRatio(int x, int y); @NonNull static AspectRatio of(@NonNull Size size); @NonNull static AspectRatio of(int x, int y); @NonNull @SuppressWarnings("WeakerAccess") static AspectRatio parse(@NonNull String string); int getX(); int getY(); boolean matches(@NonNull Size size); boolean matches(@NonNull Size size, float tolerance); @Override boolean equals(Object o); @NonNull @Override String toString(); float toFloat(); @Override int hashCode(); @Override int compareTo(@NonNull AspectRatio another); @SuppressWarnings("SuspiciousNameCombination") @NonNull AspectRatio flip(); }### Answer: @Test(expected = NumberFormatException.class) public void testParse_notNumbers() { AspectRatio.parse("a:b"); } @Test(expected = NumberFormatException.class) public void testParse_noColon() { AspectRatio.parse("24"); } @Test public void testParse() { AspectRatio ratio = AspectRatio.parse("16:9"); assertEquals(ratio.getX(), 16); assertEquals(ratio.getY(), 9); }
### Question: Angles { public void setDisplayOffset(int displayOffset) { sanitizeInput(displayOffset); mDisplayOffset = displayOffset; print(); } void setSensorOffset(@NonNull Facing sensorFacing, int sensorOffset); void setDisplayOffset(int displayOffset); void setDeviceOrientation(int deviceOrientation); int offset(@NonNull Reference from, @NonNull Reference to, @NonNull Axis axis); boolean flip(@NonNull Reference from, @NonNull Reference to); }### Answer: @Test public void testSetDisplayOffset() { angles.setDisplayOffset(90); assertEquals(90, angles.mDisplayOffset); } @Test(expected = IllegalStateException.class) public void testSetDisplayOffset_throws() { angles.setDisplayOffset(135); }
### Question: Size implements Comparable<Size> { @SuppressWarnings("SuspiciousNameCombination") public Size flip() { return new Size(mHeight, mWidth); } Size(int width, int height); int getWidth(); int getHeight(); @SuppressWarnings("SuspiciousNameCombination") Size flip(); @Override boolean equals(Object o); @NonNull @Override String toString(); @Override int hashCode(); @Override int compareTo(@NonNull Size another); }### Answer: @Test public void testFlip() { Size size = new Size(10, 20); Size flipped = size.flip(); assertEquals(size.getWidth(), flipped.getHeight()); assertEquals(size.getHeight(), flipped.getWidth()); }
### Question: Size implements Comparable<Size> { @Override public boolean equals(Object o) { if (o == null) { return false; } if (this == o) { return true; } if (o instanceof Size) { Size size = (Size) o; return mWidth == size.mWidth && mHeight == size.mHeight; } return false; } Size(int width, int height); int getWidth(); int getHeight(); @SuppressWarnings("SuspiciousNameCombination") Size flip(); @Override boolean equals(Object o); @NonNull @Override String toString(); @Override int hashCode(); @Override int compareTo(@NonNull Size another); }### Answer: @Test public void testEquals() { Size s1 = new Size(10, 20); assertEquals(s1, s1); assertNotEquals(s1, null); assertNotEquals(s1, ""); Size s2 = new Size(10, 0); Size s3 = new Size(10, 20); assertEquals(s1, s3); assertNotEquals(s1, s2); }
### Question: Size implements Comparable<Size> { @Override public int hashCode() { return mHeight ^ ((mWidth << (Integer.SIZE / 2)) \| (mWidth >>> (Integer.SIZE / 2))); } Size(int width, int height); int getWidth(); int getHeight(); @SuppressWarnings("SuspiciousNameCombination") Size flip(); @Override boolean equals(Object o); @NonNull @Override String toString(); @Override int hashCode(); @Override int compareTo(@NonNull Size another); }### Answer: @Test public void testHashCode() { Size s1 = new Size(10, 20); Size s2 = new Size(10, 0); assertNotEquals(s1.hashCode(), s2.hashCode()); }
### Question: Size implements Comparable<Size> { @Override public int compareTo(@NonNull Size another) { return mWidth * mHeight - another.mWidth * another.mHeight; } Size(int width, int height); int getWidth(); int getHeight(); @SuppressWarnings("SuspiciousNameCombination") Size flip(); @Override boolean equals(Object o); @NonNull @Override String toString(); @Override int hashCode(); @Override int compareTo(@NonNull Size another); }### Answer: @Test public void testCompare() { Size s1 = new Size(10, 20); Size s2 = new Size(10, 0); Size s3 = new Size(10, 20); assertTrue(s1.compareTo(s3) == 0); assertTrue(s1.compareTo(s2) > 0); assertTrue(s2.compareTo(s1) < 0); }
### Question: SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector withFilter(@NonNull Filter filter) { return new FilterSelector(filter); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testWithFilter() { SizeSelector selector = SizeSelectors.withFilter(new SizeSelectors.Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getWidth() == 600; } }); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(600, 900)); assertEquals(list.get(1), new Size(600, 600)); }
### Question: SizeSelectors { @NonNull public static SizeSelector maxWidth(final int width) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getWidth() <= width; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testMaxWidth() { SizeSelector selector = SizeSelectors.maxWidth(50); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(30, 40)); assertEquals(list.get(1), new Size(40, 30)); }
### Question: SizeSelectors { @NonNull public static SizeSelector minWidth(final int width) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getWidth() >= width; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testMinWidth() { SizeSelector selector = SizeSelectors.minWidth(1000); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(1600, 900)); assertEquals(list.get(1), new Size(2000, 4000)); }
### Question: SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector maxHeight(final int height) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getHeight() <= height; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testMaxHeight() { SizeSelector selector = SizeSelectors.maxHeight(50); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(30, 40)); assertEquals(list.get(1), new Size(40, 30)); }
### Question: SizeSelectors { @NonNull public static SizeSelector minHeight(final int height) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getHeight() >= height; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testMinHeight() { SizeSelector selector = SizeSelectors.minHeight(1000); List<Size> list = selector.select(input); assertEquals(list.size(), 1); assertEquals(list.get(0), new Size(2000, 4000)); }
### Question: SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector aspectRatio(AspectRatio ratio, final float delta) { final float desired = ratio.toFloat(); return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { float candidate = AspectRatio.of(size.getWidth(), size.getHeight()).toFloat(); return candidate >= desired - delta && candidate <= desired + delta; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testAspectRatio() { SizeSelector selector = SizeSelectors.aspectRatio(AspectRatio.of(16, 9), 0); List<Size> list = selector.select(input); assertEquals(list.size(), 1); assertEquals(list.get(0), new Size(1600, 900)); selector = SizeSelectors.aspectRatio(AspectRatio.of(1, 2), 0); list = selector.select(input); assertEquals(list.size(), 3); assertEquals(list.get(0), new Size(100, 200)); assertEquals(list.get(1), new Size(150, 300)); assertEquals(list.get(2), new Size(2000, 4000)); }
### Question: Angles { public void setDeviceOrientation(int deviceOrientation) { sanitizeInput(deviceOrientation); mDeviceOrientation = deviceOrientation; print(); } void setSensorOffset(@NonNull Facing sensorFacing, int sensorOffset); void setDisplayOffset(int displayOffset); void setDeviceOrientation(int deviceOrientation); int offset(@NonNull Reference from, @NonNull Reference to, @NonNull Axis axis); boolean flip(@NonNull Reference from, @NonNull Reference to); }### Answer: @Test public void testSetDeviceOrientation() { angles.setDeviceOrientation(90); assertEquals(90, angles.mDeviceOrientation); } @Test(expected = IllegalStateException.class) public void testSetDeviceOrientation_throws() { angles.setDeviceOrientation(135); }
### Question: SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector biggest() { return new SizeSelector() { @NonNull @Override public List<Size> select(@NonNull List<Size> source) { Collections.sort(source); Collections.reverse(source); return source; } }; } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testMax() { SizeSelector selector = SizeSelectors.biggest(); List<Size> list = selector.select(input); assertEquals(list.size(), input.size()); assertEquals(list.get(0), new Size(2000, 4000)); }
### Question: SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector smallest() { return new SizeSelector() { @NonNull @Override public List<Size> select(@NonNull List<Size> source) { Collections.sort(source); return source; } }; } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testMin() { SizeSelector selector = SizeSelectors.smallest(); List<Size> list = selector.select(input); assertEquals(list.size(), input.size()); assertTrue(list.get(0).equals(new Size(30, 40)) \|\| list.get(0).equals(new Size(40, 30))); }
### Question: SizeSelectors { @NonNull @SuppressWarnings("WeakerAccess") public static SizeSelector maxArea(final int area) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getHeight() * size.getWidth() <= area; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testMaxArea() { SizeSelector selector = SizeSelectors.maxArea(100 * 100); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(30, 40)); assertEquals(list.get(1), new Size(40, 30)); }
### Question: SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector minArea(final int area) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getHeight() * size.getWidth() >= area; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testMinArea() { SizeSelector selector = SizeSelectors.minArea(1000 * 1000); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(1600, 900)); assertEquals(list.get(1), new Size(2000, 4000)); }
### Question: SizeSelectors { @NonNull public static SizeSelector and(SizeSelector... selectors) { return new AndSelector(selectors); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); }### Answer: @Test public void testAnd() { SizeSelector selector = SizeSelectors.and( SizeSelectors.aspectRatio(AspectRatio.of(1, 2), 0), SizeSelectors.maxWidth(100) ); List<Size> list = selector.select(input); assertEquals(list.size(), 1); assertEquals(list.get(0), new Size(100, 200)); }
### Question: ExifHelper { public static int getOrientation(int exifOrientation) { int orientation; switch (exifOrientation) { case ExifInterface.ORIENTATION_NORMAL: case ExifInterface.ORIENTATION_FLIP_HORIZONTAL: orientation = 0; break; case ExifInterface.ORIENTATION_ROTATE_180: case ExifInterface.ORIENTATION_FLIP_VERTICAL: orientation = 180; break; case ExifInterface.ORIENTATION_ROTATE_90: case ExifInterface.ORIENTATION_TRANSPOSE: orientation = 90; break; case ExifInterface.ORIENTATION_ROTATE_270: case ExifInterface.ORIENTATION_TRANSVERSE: orientation = 270; break; default: orientation = 0; } return orientation; } static int getOrientation(int exifOrientation); static int getExifOrientation(int orientation); }### Answer: @Test public void testValues() { assertEquals(0, ExifHelper.getOrientation(ExifInterface.ORIENTATION_NORMAL)); assertEquals(0, ExifHelper.getOrientation(ExifInterface.ORIENTATION_FLIP_HORIZONTAL)); assertEquals(180, ExifHelper.getOrientation(ExifInterface.ORIENTATION_ROTATE_180)); assertEquals(180, ExifHelper.getOrientation(ExifInterface.ORIENTATION_FLIP_VERTICAL)); assertEquals(90, ExifHelper.getOrientation(ExifInterface.ORIENTATION_ROTATE_90)); assertEquals(90, ExifHelper.getOrientation(ExifInterface.ORIENTATION_TRANSPOSE)); assertEquals(270, ExifHelper.getOrientation(ExifInterface.ORIENTATION_ROTATE_270)); assertEquals(270, ExifHelper.getOrientation(ExifInterface.ORIENTATION_TRANSVERSE)); } @Test public void testUnknownValues() { assertEquals(0, ExifHelper.getOrientation(-15)); assertEquals(0, ExifHelper.getOrientation(-1)); assertEquals(0, ExifHelper.getOrientation(195)); assertEquals(0, ExifHelper.getOrientation(Integer.MAX_VALUE)); }
### Question: Pool { @CallSuper public void clear() { synchronized (lock) { queue.clear(); } } Pool(int maxPoolSize, @NonNull Factory<T> factory); boolean isEmpty(); @Nullable T get(); void recycle(@NonNull T item); @CallSuper void clear(); final int count(); @SuppressWarnings("WeakerAccess") final int activeCount(); @SuppressWarnings("WeakerAccess") final int recycledCount(); @NonNull @Override String toString(); }### Answer: @Test public void testClear() { Item item = pool.get(); assertNotNull(item); pool.recycle(item); assertEquals(pool.recycledCount(), 1); assertEquals(pool.activeCount(), 0); assertEquals(pool.count(), 1); pool.clear(); assertEquals(pool.recycledCount(), 0); assertEquals(pool.activeCount(), 0); assertEquals(pool.count(), 0); }
### Question: SchedulingStrategies { public static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ) { return new InvokerStrategy( logger ); } static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ); static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ); static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ); static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ); }### Answer: @Test public void invokerStrategy() throws InterruptedException { SchedulingStrategy strategy = SchedulingStrategies.createInvokerStrategy( new Logger() ); assertFalse( strategy.hasSharedThreadPool() ); assertTrue( strategy.canSchedule() ); Task task = new Task(); strategy.schedule( task ); assertTrue( strategy.canSchedule() ); assertTrue( task.result ); assertTrue( strategy.finished() ); assertFalse( strategy.canSchedule() ); }
### Question: JUnitCoreParameters { public boolean isParallelOptimization() { return parallelOptimization; } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void optimizationParameter() { assertFalse( newTestSetOptimization( false ).isParallelOptimization() ); }
### Question: JUnitCoreParameters { public boolean isParallelMethods() { return isAllParallel() \|\| lowerCase( "both", "methods", "suitesAndMethods", "classesAndMethods" ).contains( parallel ); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void isParallelMethod() { assertFalse( newTestSetClasses().isParallelMethods() ); assertTrue( newTestSetMethods().isParallelMethods() ); assertTrue( newTestSetBoth().isParallelMethods() ); }
### Question: JUnitCoreParameters { public boolean isParallelClasses() { return isAllParallel() \|\| lowerCase( "both", "classes", "suitesAndClasses", "classesAndMethods" ).contains( parallel ); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void isParallelClasses() { assertTrue( newTestSetClasses().isParallelClasses() ); assertFalse( newTestSetMethods().isParallelClasses() ); assertTrue( newTestSetBoth().isParallelClasses() ); }
### Question: JUnitCoreParameters { @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) public boolean isParallelBoth() { return isParallelMethods() && isParallelClasses(); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void isParallelBoth() { assertFalse( isParallelMethodsAndClasses( newTestSetClasses() ) ); assertFalse( isParallelMethodsAndClasses( newTestSetMethods() ) ); assertTrue( isParallelMethodsAndClasses( newTestSetBoth() ) ); }
### Question: SchedulingStrategies { public static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ) { return new NonSharedThreadPoolStrategy( logger, Executors.newFixedThreadPool( nThreads, DAEMON_THREAD_FACTORY ) ); } static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ); static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ); static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ); static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ); }### Answer: @Test public void nonSharedPoolStrategy() throws InterruptedException { SchedulingStrategy strategy = SchedulingStrategies.createParallelStrategy( new Logger(), 2 ); assertFalse( strategy.hasSharedThreadPool() ); assertTrue( strategy.canSchedule() ); Task task1 = new Task(); Task task2 = new Task(); strategy.schedule( task1 ); strategy.schedule( task2 ); assertTrue( strategy.canSchedule() ); assertTrue( strategy.finished() ); assertFalse( strategy.canSchedule() ); assertTrue( task1.result ); assertTrue( task2.result ); }
### Question: JUnitCoreParameters { public boolean isPerCoreThreadCount() { return perCoreThreadCount; } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void isPerCoreThreadCount() { assertFalse( newTestSetClasses().isPerCoreThreadCount() ); assertFalse( newTestSetMethods().isPerCoreThreadCount() ); assertTrue( newTestSetBoth().isPerCoreThreadCount() ); }
### Question: JUnitCoreParameters { public int getThreadCount() { return threadCount; } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void getThreadCount() { assertFalse( newTestSetClasses().isPerCoreThreadCount() ); assertFalse( newTestSetMethods().isPerCoreThreadCount() ); assertTrue( newTestSetBoth().isPerCoreThreadCount() ); }
### Question: JUnitCoreParameters { public boolean isUseUnlimitedThreads() { return useUnlimitedThreads; } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void isUseUnlimitedThreads() { assertFalse( newTestSetClasses().isUseUnlimitedThreads() ); assertTrue( newTestSetMethods().isUseUnlimitedThreads() ); assertFalse( newTestSetBoth().isUseUnlimitedThreads() ); }
### Question: JUnitCoreParameters { public boolean isNoThreading() { return !isParallelismSelected(); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void isNoThreading() { assertFalse( newTestSetClasses().isNoThreading() ); assertFalse( newTestSetMethods().isNoThreading() ); assertFalse( newTestSetBoth().isNoThreading() ); }
### Question: JUnitCoreParameters { public boolean isParallelismSelected() { return isParallelSuites() \|\| isParallelClasses() \|\| isParallelMethods(); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; }### Answer: @Test public void isAnyParallelismSelected() { assertTrue( newTestSetClasses().isParallelismSelected() ); assertTrue( newTestSetMethods().isParallelismSelected() ); assertTrue( newTestSetBoth().isParallelismSelected() ); }
### Question: SchedulingStrategies { public static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ) { if ( threadPool == null ) { throw new NullPointerException( "null threadPool in #createParallelSharedStrategy" ); } return new SharedThreadPoolStrategy( logger, threadPool ); } static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ); static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ); static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ); static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ); }### Answer: @Test(expected = NullPointerException.class) public void sharedPoolStrategyNullPool() { SchedulingStrategies.createParallelSharedStrategy( new Logger(), null ); } @Test public void sharedPoolStrategy() throws InterruptedException { ExecutorService sharedPool = Executors.newCachedThreadPool( DAEMON_THREAD_FACTORY ); SchedulingStrategy strategy1 = SchedulingStrategies.createParallelSharedStrategy( new Logger(), sharedPool ); assertTrue( strategy1.hasSharedThreadPool() ); assertTrue( strategy1.canSchedule() ); SchedulingStrategy strategy2 = SchedulingStrategies.createParallelSharedStrategy( new Logger(), sharedPool ); assertTrue( strategy2.hasSharedThreadPool() ); assertTrue( strategy2.canSchedule() ); Task task1 = new Task(); Task task2 = new Task(); Task task3 = new Task(); Task task4 = new Task(); strategy1.schedule( task1 ); strategy2.schedule( task2 ); strategy1.schedule( task3 ); strategy2.schedule( task4 ); assertTrue( strategy1.canSchedule() ); assertTrue( strategy2.canSchedule() ); assertTrue( strategy1.finished() ); assertFalse( strategy1.canSchedule() ); assertTrue( strategy2.finished() ); assertFalse( strategy2.canSchedule() ); assertTrue( task1.result ); assertTrue( task2.result ); assertTrue( task3.result ); assertTrue( task4.result ); }
### Question: SchedulingStrategies { public static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ) { return new NonSharedThreadPoolStrategy( logger, Executors.newCachedThreadPool( DAEMON_THREAD_FACTORY ) ); } static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ); static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ); static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ); static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ); }### Answer: @Test public void infinitePoolStrategy() throws InterruptedException { SchedulingStrategy strategy = SchedulingStrategies.createParallelStrategyUnbounded( new Logger() ); assertFalse( strategy.hasSharedThreadPool() ); assertTrue( strategy.canSchedule() ); Task task1 = new Task(); Task task2 = new Task(); strategy.schedule( task1 ); strategy.schedule( task2 ); assertTrue( strategy.canSchedule() ); assertTrue( strategy.finished() ); assertFalse( strategy.canSchedule() ); assertTrue( task1.result ); assertTrue( task2.result ); }
### Question: ClassName { public String get() { return this.fullClassNameWithGenerics; } ClassName(String fullClassNameWithGenerics); String get(); String toString(); String getSimpleName(); String getPackageName(); List<String> getGenericsWithoutBounds(); List<String> getGenericsWithBounds(); String getGenericPart(); String getGenericPartWithoutBrackets(); String getWithoutGenericPart(); }### Answer: @Test public void stripRepeatedTypeVarsOfOuterClasses() { assertThat( new ClassName("java.util.Map<K, V>.Entry<K, V>").get(), is("java.util.Map.Entry<K, V>")); assertThat( new ClassName("java.util.Foo<K extends java.util.Bar<K>>.Entry<K extends java.util.Bar<K>>").get(), is("java.util.Foo.Entry<K extends java.util.Bar<K>>")); }
### Question: ActionRouter { public void directAlertAction(Action action) { AlertActionRoute[] alertActionRoutes = AlertActionRoute.values(); for (AlertActionRoute alertActionRoute : alertActionRoutes) { if (alertActionRoute.identifier().equals(action.type())) { alertActionRoute.direct(action); return; } } logWarn("Unknown type in Alert action: " + action); } void directAlertAction(Action action); void directMotherAction(Action action); }### Answer: @Test public void assertDirectAlertActionTest() throws Exception { Action action = new Action("", "", "createAlert", null, "", false, null); actionRouter.directAlertAction(action); Assert.assertNotNull(actionRouter); }
### Question: CryptographicHelper { public void generateKey(String keyAlias) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { legacyCryptography.generateKey(keyAlias); } else { mCryptography.generateKey(keyAlias); } } static CryptographicHelper getInstance(Context context_); static byte[] encrypt(byte[] data, String keyAlias); static byte[] decrypt(byte[] data, String keyAlias); void generateKey(String keyAlias); Key getKey(String keyAlias); void deleteKey(String keyAlias); void setLegacyCryptography(AndroidLegacyCryptography legacyCryptography); void setMCryptography(AndroidMCryptography androidMCryptography); }### Answer: @Test @Config(sdk = Build.VERSION_CODES.LOLLIPOP_MR1) public void testCryptographicHelperGenerateKeyInvokesLegacyGenerateKeyMethod() { cryptographicHelper.generateKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidLegacyCryptography).generateKey(SAMPLE_KEY_ALIAS); } @Test public void testCryptographicHelperGenerateKeyInvokesAndroidMGenerateKeyMethod() { cryptographicHelper.generateKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidMCryptography).generateKey(SAMPLE_KEY_ALIAS); }
### Question: CryptographicHelper { public Key getKey(String keyAlias) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { return legacyCryptography.getKey(keyAlias); } else { return mCryptography.getKey(keyAlias); } } static CryptographicHelper getInstance(Context context_); static byte[] encrypt(byte[] data, String keyAlias); static byte[] decrypt(byte[] data, String keyAlias); void generateKey(String keyAlias); Key getKey(String keyAlias); void deleteKey(String keyAlias); void setLegacyCryptography(AndroidLegacyCryptography legacyCryptography); void setMCryptography(AndroidMCryptography androidMCryptography); }### Answer: @Test public void testCryptographicHelperGetKeyInvokesAndroidMGetKeyMethod() { cryptographicHelper.getKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidMCryptography).getKey(SAMPLE_KEY_ALIAS); } @Test @Config(sdk = Build.VERSION_CODES.LOLLIPOP_MR1) public void testCryptographicHelperGetKeyInvokesLegacyGetKeyMethod() { cryptographicHelper.getKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidLegacyCryptography).getKey(SAMPLE_KEY_ALIAS); }
### Question: CryptographicHelper { public void deleteKey(String keyAlias) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { legacyCryptography.deleteKey(keyAlias); } else { mCryptography.deleteKey(keyAlias); } } static CryptographicHelper getInstance(Context context_); static byte[] encrypt(byte[] data, String keyAlias); static byte[] decrypt(byte[] data, String keyAlias); void generateKey(String keyAlias); Key getKey(String keyAlias); void deleteKey(String keyAlias); void setLegacyCryptography(AndroidLegacyCryptography legacyCryptography); void setMCryptography(AndroidMCryptography androidMCryptography); }### Answer: @Test public void testCryptographicHelperDeleteKeyInvokesAndroidMGetKeyMethod() { cryptographicHelper.deleteKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidMCryptography).deleteKey(SAMPLE_KEY_ALIAS); } @Test @Config(sdk = Build.VERSION_CODES.LOLLIPOP_MR1) public void testCryptographicHelperDeleteKeyInvokesLegacyGetKeyMethod() { cryptographicHelper.deleteKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidLegacyCryptography).deleteKey(SAMPLE_KEY_ALIAS); }
### Question: AndroidMCryptography extends BaseCryptography implements ICryptography { @Override public String getAESMode() { return AES_MODE; } AndroidMCryptography(Context context); @RequiresApi(api = Build.VERSION_CODES.KITKAT) @Override byte[] encrypt(byte[] input, String keyAlias); @Override String getAESMode(); void generateInitializationVector(); @RequiresApi(api = Build.VERSION_CODES.KITKAT) @Override byte[] decrypt(byte[] encrypted, String keyAlias); @Override Key getKey(String keyAlias); @TargetApi(Build.VERSION_CODES.M) @Override void generateKey(String keyAlias); static final String AES_MODE; }### Answer: @Test public void testAndroidMCryptographyClassInitsCorrectly() { Assert.assertNotNull(androidMCryptography); Assert.assertNotNull(androidMCryptography.secureRandom); Assert.assertNotNull(androidMCryptography.getAESMode()); Assert.assertEquals(AndroidMCryptography.AES_MODE, androidMCryptography.getAESMode()); }
### Question: AndroidLegacyCryptography extends BaseCryptography implements ICryptography { @Override public String getAESMode() { return AES_MODE; } AndroidLegacyCryptography(Context context); @Override String getAESMode(); @Override byte[] encrypt(byte[] input, String keyAlias); @Override byte[] decrypt(byte[] encrypted, String keyAlias); @Override Key getKey(String keyAlias); @Override void generateKey(String keyAlias); String generateAESKey(String encryptedAESKeyKey, String rsaPrivateKeyAlias); void generateRSAKeys(String rsaKeyAlias); static final String AES_MODE; }### Answer: @Test public void testAndroidLegacyCryptographyClassInitsCorrectly() { Assert.assertNotNull(androidLegacyCryptography); Assert.assertNotNull(androidLegacyCryptography.secureRandom); Assert.assertNotNull(androidLegacyCryptography.getAESMode()); Assert.assertEquals(AndroidLegacyCryptography.AES_MODE, androidLegacyCryptography.getAESMode()); }
### Question: ViewStubInflater { public ViewGroup get() { if (!isInflated()) { this.inflatedLayout = (ViewGroup) stub.inflate(); } return this.inflatedLayout; } ViewStubInflater(ViewStub stub); ViewGroup get(); void setVisibility(int visibility); }### Answer: @Test public void testGetInflatesLayoutCorrectly() { Mockito.doReturn(viewGroup).when(viewStub).inflate(); ViewStubInflater viewStubInflater = new ViewStubInflater(viewStub); Assert.assertNotNull(viewStubInflater); Assert.assertEquals(viewGroup, viewStubInflater.get()); }
### Question: ViewStubInflater { public void setVisibility(int visibility) { if (isInflated()) { inflatedLayout.setVisibility(visibility); } } ViewStubInflater(ViewStub stub); ViewGroup get(); void setVisibility(int visibility); }### Answer: @Test public void testSetVisiblityInvokesInflatedLayoutWithCorrectParams() { Mockito.doReturn(viewGroup).when(viewStub).inflate(); ViewStubInflater viewStubInflater = Mockito.spy(new ViewStubInflater(viewStub)); viewStubInflater.setVisibility(View.GONE); Mockito.verify(viewStubInflater).setVisibility(View.GONE); viewStubInflater.setVisibility(View.VISIBLE); Mockito.verify(viewStubInflater).setVisibility(View.VISIBLE); viewStubInflater.setVisibility(View.INVISIBLE); Mockito.verify(viewStubInflater).setVisibility(View.INVISIBLE); }
### Question: ChildRegisterProfilePhotoLoader implements ProfilePhotoLoader { public Drawable get(SmartRegisterClient client) { return FEMALE_GENDER.equalsIgnoreCase(((ChildSmartRegisterClient) client).gender()) ? femaleInfantDrawable : maleInfantDrawable; } ChildRegisterProfilePhotoLoader(Drawable maleInfantDrawable, Drawable femaleInfantDrawable); Drawable get(SmartRegisterClient client); }### Answer: @Test public void testGetReturnsCorrectDrawableForFemaleGender() { Drawable maleInfant = RuntimeEnvironment.application.getDrawable(R.drawable.child_boy_infant); Drawable femaleInfant = RuntimeEnvironment.application.getDrawable(R.drawable.child_girl_infant); ChildRegisterProfilePhotoLoader childRegisterProfilePhotoLoader = new ChildRegisterProfilePhotoLoader(maleInfant, femaleInfant); Assert.assertNotNull(childRegisterProfilePhotoLoader); Mockito.doReturn("female").when(smartRegisterClient).gender(); Assert.assertEquals(femaleInfant, childRegisterProfilePhotoLoader.get(smartRegisterClient)); } @Test public void testGetReturnsCorrectDrawableForMaleGender() { Drawable maleInfant = RuntimeEnvironment.application.getDrawable(R.drawable.child_boy_infant); Drawable femaleInfant = RuntimeEnvironment.application.getDrawable(R.drawable.child_girl_infant); ChildRegisterProfilePhotoLoader childRegisterProfilePhotoLoader = new ChildRegisterProfilePhotoLoader(maleInfant, femaleInfant); Assert.assertNotNull(childRegisterProfilePhotoLoader); Mockito.doReturn("male").when(smartRegisterClient).gender(); Assert.assertEquals(maleInfant, childRegisterProfilePhotoLoader.get(smartRegisterClient)); }
### Question: OnClickFormLauncher implements View.OnClickListener { @Override public void onClick(View view) { activity.startFormActivity(formName, entityId, metaData); } OnClickFormLauncher(SecuredActivity activity, String formName, String entityId); OnClickFormLauncher(SecuredActivity activity, String formName, String entityId, String metaData); @Override void onClick(View view); }### Answer: @Test public void testOnClickInvokesStartFormActivityWithCorrectParams() { String testMetadata = "{\"fieldOverrides\": \"metadata-override-values\"}"; Mockito.doNothing().when(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); OnClickFormLauncher onClickFormLauncher = new OnClickFormLauncher(activity, TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); Assert.assertNotNull(onClickFormLauncher); onClickFormLauncher.onClick(view); Mockito.verify(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); } @Test public void testOnClickInvokesStartFormActivityWithCorrectParamsNoMetadata() { Mockito.doNothing().when(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, ""); OnClickFormLauncher onClickFormLauncher = new OnClickFormLauncher(activity, TEST_FORM_NAME, TEST_BASE_ENTITY_ID); Assert.assertNotNull(onClickFormLauncher); onClickFormLauncher.onClick(view); Mockito.verify(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, (String) null); } @Test public void testOnClickInvokesStartFormActivityWithCorrectMapMetadataParams() { Map<String, String> testMetadata = new HashMap<>(); testMetadata.put("first_name", "john"); testMetadata.put("last_name", "doe"); Mockito.doNothing().when(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); OnClickFormLauncher onClickFormLauncher = new OnClickFormLauncher(activity, TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata.toString()); Assert.assertNotNull(onClickFormLauncher); onClickFormLauncher.onClick(view); Mockito.verify(activity, Mockito.times(1)).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata.toString()); } @Test public void testOnClickInvokesStartFormActivityWithEmptyMapMetadataParams() { Map<String, String> testMetadata = new HashMap<>(); Mockito.doNothing().when(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); OnClickFormLauncher onClickFormLauncher = new OnClickFormLauncher(activity, TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata.toString()); Assert.assertNotNull(onClickFormLauncher); onClickFormLauncher.onClick(view); Mockito.verify(activity, Mockito.times(1)).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata.toString()); }
### Question: SecuredFragment extends Fragment { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); logoutListener = data -> { if (getActivity() != null && !getActivity().isFinishing()) { getActivity().finish(); } }; Event.ON_LOGOUT.addListener(logoutListener); if (context().IsUserLoggedOut()) { DrishtiApplication application = (DrishtiApplication) this.getActivity() .getApplication(); application.logoutCurrentUser(); return; } if (getActivity() instanceof SecuredActivity) { formController = new FormController((SecuredActivity) getActivity()); } anmController = context().anmController(); navigationController = new NavigationController(getActivity(), anmController); onCreation(); } @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); @Override void onPause(); @Override boolean onOptionsItemSelected(MenuItem item); void logoutUser(); void startFormActivity(String formName, String entityId, String metaData); void startMicroFormActivity(String formName, String entityId, String metaData); boolean isPaused(); }### Answer: @Test public void testOnCreateInitializesFragmentFields() { securedFragment.onCreate(bundle); Listener<Boolean> logoutListener = ReflectionHelpers.getField(securedFragment, "logoutListener"); FormController formController = ReflectionHelpers.getField(securedFragment, "formController"); ANMController anmController = ReflectionHelpers.getField(securedFragment, "anmController"); NavigationController navigationController = ReflectionHelpers.getField(securedFragment, "navigationController"); Assert.assertNotNull(logoutListener); Assert.assertNotNull(formController); Assert.assertNotNull(anmController); Assert.assertNotNull(navigationController); }
### Question: SecuredFragment extends Fragment { @Override public void onResume() { super.onResume(); if (context().IsUserLoggedOut()) { DrishtiApplication application = (DrishtiApplication) this.getActivity() .getApplication(); application.logoutCurrentUser(); return; } onResumption(); isPaused = false; } @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); @Override void onPause(); @Override boolean onOptionsItemSelected(MenuItem item); void logoutUser(); void startFormActivity(String formName, String entityId, String metaData); void startMicroFormActivity(String formName, String entityId, String metaData); boolean isPaused(); }### Answer: @Test public void assertOnResumeLogsOutCurrentUserIfContextIsUserLoggedOutIsTrue() { Mockito.doReturn(true).when(context).IsUserLoggedOut(); securedFragment.onResume(); Mockito.verify(application).logoutCurrentUser(); }
### Question: SecuredFragment extends Fragment { @Override public void onPause() { super.onPause(); isPaused = true; } @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); @Override void onPause(); @Override boolean onOptionsItemSelected(MenuItem item); void logoutUser(); void startFormActivity(String formName, String entityId, String metaData); void startMicroFormActivity(String formName, String entityId, String metaData); boolean isPaused(); }### Answer: @Test public void assertOnPauseSetsOnPausedFlagToTrue() { ReflectionHelpers.setField(securedFragment, "isPaused", false); boolean onPauseFlag = ReflectionHelpers.getField(securedFragment, "isPaused"); Assert.assertFalse(onPauseFlag); securedFragment.onPause(); onPauseFlag = ReflectionHelpers.getField(securedFragment, "isPaused"); Assert.assertTrue(onPauseFlag); }
### Question: SecuredFragment extends Fragment { public void logoutUser() { context().userService().logout(); } @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); @Override void onPause(); @Override boolean onOptionsItemSelected(MenuItem item); void logoutUser(); void startFormActivity(String formName, String entityId, String metaData); void startMicroFormActivity(String formName, String entityId, String metaData); boolean isPaused(); }### Answer: @Test public void assertLogoutUserInvokesUserserviceLogoutMethod() { Mockito.doNothing().when(securedFragment).startActivity(ArgumentMatchers.any(Intent.class)); Mockito.doNothing().when(userService).logout(); securedFragment.logoutUser(); Mockito.verify(userService).logout(); }
### Question: SecuredFragment extends Fragment { public void startFormActivity(String formName, String entityId, String metaData) { launchForm(formName, entityId, metaData, FormActivity.class); } @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); @Override void onPause(); @Override boolean onOptionsItemSelected(MenuItem item); void logoutUser(); void startFormActivity(String formName, String entityId, String metaData); void startMicroFormActivity(String formName, String entityId, String metaData); boolean isPaused(); }### Answer: @Test public void assertStartFormActivityInvokesNavigationToFormActivity() { Mockito.doNothing().when(securedFragment).startActivityForResult(ArgumentMatchers.any(Intent.class), ArgumentMatchers.anyInt()); securedFragment.startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, null); Mockito.verify(securedFragment).startActivityForResult(intentArgumentCaptor.capture(), integerArgumentCaptor.capture()); Intent capturedIntent = intentArgumentCaptor.getValue(); Assert.assertNotNull(capturedIntent); Assert.assertEquals("org.smartregister.view.activity.FormActivity", capturedIntent.getComponent().getClassName()); Integer capturedInteger = integerArgumentCaptor.getValue(); Assert.assertNotNull(capturedInteger); Assert.assertEquals(AllConstants.FORM_SUCCESSFULLY_SUBMITTED_RESULT_CODE, capturedInteger.intValue()); } @Test public void testAddFieldOverridesIfExistAddsFieldOverrideParamsToRequestIntent() { String testMetadata = "{\"fieldOverrides\": \"metadata-override-values\"}"; Mockito.doNothing().when(securedFragment).startActivityForResult(ArgumentMatchers.any(Intent.class), ArgumentMatchers.anyInt()); securedFragment.startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); Mockito.verify(securedFragment).startActivityForResult(intentArgumentCaptor.capture(), integerArgumentCaptor.capture()); Intent capturedIntent = intentArgumentCaptor.getValue(); Assert.assertNotNull(capturedIntent); Assert.assertEquals("metadata-override-values", capturedIntent.getStringExtra(AllConstants.FIELD_OVERRIDES_PARAM)); }
### Question: SecuredFragment extends Fragment { public void startMicroFormActivity(String formName, String entityId, String metaData) { launchForm(formName, entityId, metaData, MicroFormActivity.class); } @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); @Override void onPause(); @Override boolean onOptionsItemSelected(MenuItem item); void logoutUser(); void startFormActivity(String formName, String entityId, String metaData); void startMicroFormActivity(String formName, String entityId, String metaData); boolean isPaused(); }### Answer: @Test public void assertStartMicroFormActivityInvokesNavigationToMicroFormActivity() { Mockito.doNothing().when(securedFragment).startActivityForResult(ArgumentMatchers.any(Intent.class), ArgumentMatchers.anyInt()); securedFragment.startMicroFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, null); Mockito.verify(securedFragment).startActivityForResult(intentArgumentCaptor.capture(), integerArgumentCaptor.capture()); Intent capturedIntent = intentArgumentCaptor.getValue(); Assert.assertNotNull(capturedIntent); Assert.assertEquals("org.smartregister.view.activity.MicroFormActivity", capturedIntent.getComponent().getClassName()); Integer capturedInteger = integerArgumentCaptor.getValue(); Assert.assertNotNull(capturedInteger); Assert.assertEquals(AllConstants.FORM_SUCCESSFULLY_SUBMITTED_RESULT_CODE, capturedInteger.intValue()); }
### Question: LibraryFragment extends Fragment implements LibraryContract.View { @Nullable @Override public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { return inflater.inflate(R.layout.fragment_library, container, false); } @Nullable @Override View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); }### Answer: @Test public void assertOnCreateViewInflatesCorrectLayout() { libraryFragment.onCreateView(inflater, container, null); Assert.assertNotNull(libraryFragment); Mockito.verify(inflater).inflate(R.layout.fragment_library, container, false); }
### Question: BaseProfileFragment extends SecuredFragment implements View.OnTouchListener { @Override public void onViewCreated(View view, Bundle savedInstanceState) { super.onCreate(savedInstanceState); gestureDetector = new GestureDetectorCompat(this.getActivity(), new ProfileFragmentsSwipeListener()); view.setOnTouchListener(this); } @Override void onViewCreated(View view, Bundle savedInstanceState); @Override boolean onTouch(View view, MotionEvent event); }### Answer: @Test public void testOnViewCreatedAddsOnTouchListenerHandlerToView() { Mockito.when(context.IsUserLoggedOut()).thenReturn(false); Mockito.doReturn(context).when(baseProfileFragment).context(); baseProfileFragment.onViewCreated(view, bundle); Mockito.verify(view).setOnTouchListener(baseProfileFragmentArgumentCaptor.capture()); Fragment baseProfileFragment = baseProfileFragmentArgumentCaptor.getValue(); Assert.assertNotNull(baseProfileFragment); Assert.assertTrue(baseProfileFragment instanceof BaseProfileFragment); } @Test public void testOnViewCreatedInstantiatesValidGestureDetectorField() { Mockito.when(context.IsUserLoggedOut()).thenReturn(false); Mockito.doReturn(context).when(baseProfileFragment).context(); GestureDetectorCompat gestureDetector = ReflectionHelpers.getField(baseProfileFragment, "gestureDetector"); Assert.assertNull(gestureDetector); baseProfileFragment.onViewCreated(view, bundle); gestureDetector = ReflectionHelpers.getField(baseProfileFragment, "gestureDetector"); Assert.assertNotNull(gestureDetector); }
### Question: BaseProfileFragment extends SecuredFragment implements View.OnTouchListener { @Override public boolean onTouch(View view, MotionEvent event) { return gestureDetector.onTouchEvent(event); } @Override void onViewCreated(View view, Bundle savedInstanceState); @Override boolean onTouch(View view, MotionEvent event); }### Answer: @Test public void testOnTouchAssignsMotionEventHandler() { ReflectionHelpers.setField(baseProfileFragment, "gestureDetector", gestureDetector); baseProfileFragment.onTouch(view, motionEvent); Mockito.verify(gestureDetector).onTouchEvent(motionEvent); }
### Question: BaseProfileFragment extends SecuredFragment implements View.OnTouchListener { @VisibleForTesting protected boolean onFlingProcessor(MotionEvent event, MotionEvent event2, float velocityY) { final int SWIPE_MIN_DISTANCE = 120; final int SWIPE_MAX_OFF_PATH = 300; final int SWIPE_THRESHOLD_VELOCITY = 200; try { if (Math.abs(event.getX() - event2.getX()) > SWIPE_MAX_OFF_PATH) { return true; } if (event.getY() - event2.getY() > SWIPE_MIN_DISTANCE && Math.abs(velocityY) > SWIPE_THRESHOLD_VELOCITY) { ((BaseProfileActivity) getActivity()).getProfileAppBarLayout().setExpanded(false, true); } else if (event2.getY() - event.getY() > SWIPE_MIN_DISTANCE && Math.abs(velocityY) > SWIPE_THRESHOLD_VELOCITY) { ((BaseProfileActivity) getActivity()).getProfileAppBarLayout().setExpanded(true, true); } } catch (Exception e) { } return false; } @Override void onViewCreated(View view, Bundle savedInstanceState); @Override boolean onTouch(View view, MotionEvent event); }### Answer: @Test public void testOnFlingProcessorReturnsTrueIfXTranlationGreatherThanSwipeOffMaxPath() { Mockito.doReturn(500f).when(motionEvent1).getX(); Mockito.doReturn(100f).when(motionEvent2).getX(); Boolean result = baseProfileFragment.onFlingProcessor(motionEvent1, motionEvent2, 1.0f); Assert.assertNotNull(result); Assert.assertTrue(result); } @Test public void testOnFlingProcessorReturnsFalseIfXTranlationLessThanSwipeOffMaxPath() { Mockito.doReturn(400f).when(motionEvent1).getX(); Mockito.doReturn(300f).when(motionEvent2).getX(); Boolean result = baseProfileFragment.onFlingProcessor(motionEvent1, motionEvent2, 1.0f); Assert.assertNotNull(result); Assert.assertFalse(result); } @Test public void testOnFlingProcessorSetsAppBarLayoutExpandedToTrueWhenYTranlationGreaterThanSwipeOffMinPath() { Mockito.doReturn(200f).when(motionEvent1).getY(); Mockito.doReturn(50f).when(motionEvent2).getY(); Mockito.doReturn(baseProfileActivity).when(baseProfileFragment).getActivity(); Mockito.doReturn(appBarLayout).when(baseProfileActivity).getProfileAppBarLayout(); Boolean result = baseProfileFragment.onFlingProcessor(motionEvent1, motionEvent2, 250.0f); Assert.assertNotNull(result); Assert.assertFalse(result); Mockito.verify(appBarLayout).setExpanded(appBarLayoutExpandedArgumentCaptor.capture(), appBarLayoutAnimateArgumentCaptor.capture()); Boolean isExpanded = appBarLayoutExpandedArgumentCaptor.getValue(); Assert.assertNotNull(isExpanded); Assert.assertFalse(isExpanded); } @Test public void testOnFlingProcessorSetsAppBarLayoutExpandedToFalseWhenYTranlationLessThanSwipeOffMinPath() { Mockito.doReturn(100f).when(motionEvent1).getY(); Mockito.doReturn(550f).when(motionEvent2).getY(); Mockito.doReturn(baseProfileActivity).when(baseProfileFragment).getActivity(); Mockito.doReturn(appBarLayout).when(baseProfileActivity).getProfileAppBarLayout(); Boolean result = baseProfileFragment.onFlingProcessor(motionEvent1, motionEvent2, 350.0f); Assert.assertNotNull(result); Assert.assertFalse(result); Mockito.verify(appBarLayout).setExpanded(appBarLayoutExpandedArgumentCaptor.capture(), appBarLayoutAnimateArgumentCaptor.capture()); Boolean isExpanded = appBarLayoutExpandedArgumentCaptor.getValue(); Assert.assertNotNull(isExpanded); Assert.assertTrue(isExpanded); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { @Override protected SecuredNativeSmartRegisterActivity.NavBarOptionsProvider getNavBarOptionsProvider() { return new SecuredNativeSmartRegisterActivity.NavBarOptionsProvider() { @Override public DialogOption[] filterOptions() { return new DialogOption[]{}; } @Override public DialogOption[] serviceModeOptions() { return new DialogOption[]{ }; } @Override public DialogOption[] sortingOptions() { return new DialogOption[]{ }; } @Override public String searchHint() { return context().getStringResource(R.string.search_hint); } }; } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void assertGetNavBarOptionsProviderNotNull() { SecuredNativeSmartRegisterActivity.NavBarOptionsProvider provider = baseRegisterFragment.getNavBarOptionsProvider(); Assert.assertNotNull(provider); } @Test public void assertGetNavBarOptionsProviderReturnsCorrectValueFormSearchHint() { SecuredNativeSmartRegisterActivity.NavBarOptionsProvider provider = baseRegisterFragment.getNavBarOptionsProvider(); Mockito.doReturn(opensrpContext).when(baseRegisterFragment).context(); Mockito.doReturn(RuntimeEnvironment.application.getResources().getString(R.string.search_hint)).when(opensrpContext).getStringResource(R.string.search_hint); String hint = RuntimeEnvironment.application.getResources().getString(R.string.search_hint); Assert.assertEquals(hint, provider.searchHint()); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { @Nullable @Override public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { View view = inflater.inflate(getLayout(), container, false); rootView = view; setUpActionBar(); setupViews(view); return view; } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void testOnCreateViewInitsToolbarConfigurationCorrectly() { View parentLayout = LayoutInflater.from(RuntimeEnvironment.application.getApplicationContext()).inflate(R.layout.fragment_base_register, null, false); Mockito.doReturn(parentLayout).when(layoutInflater).inflate(R.layout.fragment_base_register, container, false); Toolbar toolbar = parentLayout.findViewById(R.id.register_toolbar); AppCompatActivity activitySpy = Mockito.spy(activity); Mockito.doReturn(activitySpy).when(baseRegisterFragment).getActivity(); Mockito.doReturn(actionBar).when(activitySpy).getSupportActionBar(); baseRegisterFragment.onCreateView(layoutInflater, container, bundle); Mockito.verify(activitySpy).setSupportActionBar(toolbar); Mockito.verify(actionBar).setTitle(TEST_RANDOM_STRING); Mockito.verify(actionBar).setDisplayHomeAsUpEnabled(false); Mockito.verify(actionBar).setLogo(R.drawable.round_white_background); Mockito.verify(actionBar).setDisplayUseLogoEnabled(false); Mockito.verify(actionBar).setDisplayShowTitleEnabled(false); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { @LayoutRes protected int getLayout() { return R.layout.fragment_base_register; } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void assertGetLayoutReturnsCorrectLayout() { Assert.assertEquals(R.layout.fragment_base_register, baseRegisterFragment.getLayout()); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { protected void updateSearchView() { if (getSearchView() != null) { getSearchView().removeTextChangedListener(textWatcher); getSearchView().addTextChangedListener(textWatcher); getSearchView().setOnKeyListener(hideKeyboard); } } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void assertUpdateSearchViewAddsCorrectListenersToSearchView() { Mockito.doReturn(searchView).when(baseRegisterFragment).getSearchView(); ReflectionHelpers.setField(baseRegisterFragment, "textWatcher", textWatcher); ReflectionHelpers.setField(baseRegisterFragment, "hideKeyboard", hideKeyboard); baseRegisterFragment.updateSearchView(); Mockito.verify(searchView).removeTextChangedListener(textWatcher); Mockito.verify(searchView).addTextChangedListener(textWatcher); Mockito.verify(searchView).setOnKeyListener(hideKeyboard); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { @Override public void updateSearchBarHint(String searchBarText) { if (getSearchView() != null) { getSearchView().setHint(searchBarText); } } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void assertUpdateSearchBarHintSetsCorrectValue() { Mockito.doReturn(searchView).when(baseRegisterFragment).getSearchView(); baseRegisterFragment.updateSearchBarHint(TEST_RANDOM_STRING); Mockito.verify(searchView).setHint(TEST_RANDOM_STRING); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { public void setSearchTerm(String searchText) { if (getSearchView() != null) { getSearchView().setText(searchText); } } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void setSearchTermInitsCorrectValue() { Mockito.doReturn(searchView).when(baseRegisterFragment).getSearchView(); baseRegisterFragment.setSearchTerm(TEST_RANDOM_STRING); Mockito.verify(searchView).setText(TEST_RANDOM_STRING); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { @Override public void setTotalPatients() { if (headerTextDisplay != null) { headerTextDisplay.setText(clientAdapter.getTotalcount() > 1 ? String.format(getActivity().getString(R.string.clients), clientAdapter.getTotalcount()) : String.format(getActivity().getString(R.string.client), clientAdapter.getTotalcount())); filterRelativeLayout.setVisibility(View.GONE); } } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void testSetTotalPatientsSetsCorrectHeaderTextForDisplay() { Mockito.doReturn(activity).when(baseRegisterFragment).getActivity(); Mockito.doReturn(5).when(clientAdapter).getTotalcount(); baseRegisterFragment.setTotalPatients(); Mockito.verify(headerTextDisplay).setText(stringArgumentCaptor.capture()); String capturedHeaderText = stringArgumentCaptor.getValue(); Assert.assertEquals("5 Clients", capturedHeaderText); Mockito.doReturn(1).when(clientAdapter).getTotalcount(); baseRegisterFragment.setTotalPatients(); Mockito.verify(headerTextDisplay, Mockito.times(2)).setText(stringArgumentCaptor.capture()); capturedHeaderText = stringArgumentCaptor.getValue(); Assert.assertEquals("1 Client", capturedHeaderText); } @Test public void testSetTotalPatientsHidesFilterRelativeLayoutView() { Mockito.doReturn(activity).when(baseRegisterFragment).getActivity(); Mockito.doReturn(5).when(clientAdapter).getTotalcount(); baseRegisterFragment.setTotalPatients(); Mockito.verify(filterRelativeLayout).setVisibility(intArgumentCaptor.capture()); int visibility = intArgumentCaptor.getValue(); Assert.assertEquals(View.GONE, visibility); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { @Override protected SmartRegisterClientsProvider clientsProvider() { return null; } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void assertClientsProviderSetToNull() { Assert.assertNull(baseRegisterFragment.clientsProvider()); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { @Override protected void onCreation() { initializePresenter(); Bundle extras = getActivity().getIntent().getExtras(); if (extras != null) { boolean isRemote = extras.getBoolean(AllConstants.INTENT_KEY.IS_REMOTE_LOGIN); if (isRemote) { presenter.startSync(); } } } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void testOnCreationInvokesPresenterStartSyncForRemoteLogin() { Mockito.doReturn(activity).when(baseRegisterFragment).getActivity(); Intent intent = new Intent(); intent.putExtra(AllConstants.INTENT_KEY.IS_REMOTE_LOGIN, true); activity.setIntent(intent); baseRegisterFragment.onCreation(); Mockito.verify(presenter).startSync(); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { public boolean onBackPressed() { return false; } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void assertOnBackPressedReturnsFalse() { Assert.assertFalse(baseRegisterFragment.onBackPressed()); }
### Question: BaseRegisterFragment extends RecyclerViewFragment implements BaseRegisterFragmentContract.View, SyncStatusBroadcastReceiver.SyncStatusListener { @Override public void updateFilterAndFilterStatus(String filterText, String sortText) { if (headerTextDisplay != null) { headerTextDisplay.setText(Html.fromHtml(filterText)); filterRelativeLayout.setVisibility(View.VISIBLE); } if (filterStatus != null) { filterStatus.setText(Html.fromHtml(clientAdapter.getTotalcount() + " patients " + sortText)); } } @Nullable @Override View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void updateSearchBarHint(String searchBarText); void setSearchTerm(String searchText); void onQRCodeSucessfullyScanned(String qrCode); abstract void setUniqueID(String qrCode); abstract void setAdvancedSearchFormData(HashMap<String, String> advancedSearchFormData); @Override void setupViews(View view); @Override void setTotalPatients(); @Override void initializeQueryParams(String tableName, String countSelect, String mainSelect); void filter(String filterString, String joinTableString, String mainConditionString, boolean qrCode); @Override void updateFilterAndFilterStatus(String filterText, String sortText); boolean onBackPressed(); @Override void onSyncInProgress(FetchStatus fetchStatus); @Override void onSyncStart(); @Override void onSyncComplete(FetchStatus fetchStatus); @Override void onResume(); @Override void onPause(); static String TOOLBAR_TITLE; }### Answer: @Test public void testUpdateFilterAndFilterStatus() { View parentLayout = LayoutInflater.from(RuntimeEnvironment.application.getApplicationContext()).inflate(R.layout.fragment_base_register, null, false); Mockito.doReturn(parentLayout).when(layoutInflater).inflate(R.layout.fragment_base_register, container, false); TextView headerTextDisplay = parentLayout.findViewById(R.id.header_text_display); TextView filterStatus = parentLayout.findViewById(R.id.filter_status); RelativeLayout filterRelativeLayout = parentLayout.findViewById(R.id.filter_display_view); ReflectionHelpers.setField(baseRegisterFragment, "headerTextDisplay", headerTextDisplay); ReflectionHelpers.setField(baseRegisterFragment, "filterRelativeLayout", filterRelativeLayout); ReflectionHelpers.setField(baseRegisterFragment, "filterStatus", filterStatus); Mockito.doReturn(5).when(clientAdapter).getTotalcount(); baseRegisterFragment.updateFilterAndFilterStatus("benji", "ASC"); Assert.assertEquals("benji", headerTextDisplay.getText().toString()); Assert.assertEquals("5 patients ASC", filterStatus.getText().toString()); }
### Question: MeFragment extends Fragment implements MeContract.View { @Nullable @Override public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { return inflater.inflate(R.layout.fragment_me, container, false); } @Override void onCreate(Bundle savedInstanceState); @Nullable @Override View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState); @Override void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState); @Override void onStart(); @Override void onResume(); @Override void updateInitialsText(String userInitials); @Override void updateNameText(String name); }### Answer: @Test @Ignore public void testOnCreateViewReturnsCorrectLayoutView() { View layoutView = meFragment.onCreateView(layoutInflater, viewGroup, bundle); Assert.assertNotNull(layoutView); Mockito.verify(layoutInflater).inflate(R.layout.fragment_me, viewGroup, false); }
### Question: SecuredNativeSmartRegisterFragment extends SecuredFragment { public void setupSearchView(View view) { searchView = view.findViewById(R.id.edt_search); searchView.setHint(getNavBarOptionsProvider().searchHint()); searchView.addTextChangedListener(new TextWatcher() { @Override public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) { } @Override public void onTextChanged(CharSequence cs, int start, int before, int count) { currentSearchFilter = new ECSearchOption(cs.toString()); clientsAdapter.refreshList(currentVillageFilter, currentServiceModeOption, currentSearchFilter, currentSortOption); searchCancelView.setVisibility(isEmpty(cs) ? INVISIBLE : VISIBLE); } @Override public void afterTextChanged(Editable editable) { } }); searchCancelView = view.findViewById(R.id.btn_search_cancel); searchCancelView.setOnClickListener(searchCancelHandler); } EditText getSearchView(); View getSearchCancelView(); FilterOption getCurrentVillageFilter(); FilterOption getCurrentSearchFilter(); void setCurrentSearchFilter(FilterOption currentSearchFilter); SortOption getCurrentSortOption(); ServiceModeOption getCurrentServiceModeOption(); SmartRegisterPaginatedAdapter getClientsAdapter(); void setClientsAdapter(SmartRegisterPaginatedAdapter clientsAdapter); @Override View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState); void refreshListView(); void setupSearchView(View view); void onSortSelection(SortOption sortBy); void onFilterSelection(FilterOption filter); void gotoNextPage(); void goBackToPreviousPage(); boolean isRefreshList(); void setRefreshList(boolean refreshList); static final String DIALOG_TAG; static final List<? extends DialogOption> DEFAULT_FILTER_OPTIONS; public ListView clientsView; public ProgressBar clientsProgressView; public TextView serviceModeView; public TextView appliedVillageFilterView; public TextView appliedSortView; public EditText searchView; public View searchCancelView; public TextView titleLabelView; public View mView; }### Answer: @Test public void testSetupSearchView() { View parent = LayoutInflater.from(RuntimeEnvironment.application).inflate(R.layout.smart_register_activity, null, false); View parentSpy = Mockito.spy(parent); Mockito.doReturn(searchView).when(parentSpy).findViewById(R.id.edt_search); Mockito.doReturn(searchCancelButton).when(parentSpy).findViewById(R.id.btn_search_cancel); securedNativeSmartRegisterFragment.setupSearchView(parentSpy); Assert.assertNotNull(securedNativeSmartRegisterFragment.getSearchView()); Assert.assertNotNull(securedNativeSmartRegisterFragment.getSearchCancelView()); Mockito.verify(parentSpy).findViewById(R.id.edt_search); Mockito.verify(parentSpy).findViewById(R.id.btn_search_cancel); Mockito.verify(searchView).addTextChangedListener(ArgumentMatchers.any(TextWatcher.class)); Mockito.verify(searchCancelButton).setOnClickListener(ArgumentMatchers.any(SecuredNativeSmartRegisterFragment.SearchCancelHandler.class)); }
### Question: SecuredNativeSmartRegisterFragment extends SecuredFragment { protected void setServiceModeViewDrawableRight(Drawable drawable) { serviceModeView.setCompoundDrawables(null, null, drawable, null); } EditText getSearchView(); View getSearchCancelView(); FilterOption getCurrentVillageFilter(); FilterOption getCurrentSearchFilter(); void setCurrentSearchFilter(FilterOption currentSearchFilter); SortOption getCurrentSortOption(); ServiceModeOption getCurrentServiceModeOption(); SmartRegisterPaginatedAdapter getClientsAdapter(); void setClientsAdapter(SmartRegisterPaginatedAdapter clientsAdapter); @Override View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState); void refreshListView(); void setupSearchView(View view); void onSortSelection(SortOption sortBy); void onFilterSelection(FilterOption filter); void gotoNextPage(); void goBackToPreviousPage(); boolean isRefreshList(); void setRefreshList(boolean refreshList); static final String DIALOG_TAG; static final List<? extends DialogOption> DEFAULT_FILTER_OPTIONS; public ListView clientsView; public ProgressBar clientsProgressView; public TextView serviceModeView; public TextView appliedVillageFilterView; public TextView appliedSortView; public EditText searchView; public View searchCancelView; public TextView titleLabelView; public View mView; }### Answer: @Test public void testServiceModeViewSetsServiceModeViewWithCorrectCompoundDrawableValues() { Whitebox.setInternalState(securedNativeSmartRegisterFragment, "serviceModeView", serviceModeView); securedNativeSmartRegisterFragment.setServiceModeViewDrawableRight(drawable); Mockito.verify(serviceModeView).setCompoundDrawables(null, null, drawable, null); }
### Question: SecuredNativeSmartRegisterFragment extends SecuredFragment { public void refreshListView() { this.setRefreshList(true); this.onResumption(); this.setRefreshList(false); } EditText getSearchView(); View getSearchCancelView(); FilterOption getCurrentVillageFilter(); FilterOption getCurrentSearchFilter(); void setCurrentSearchFilter(FilterOption currentSearchFilter); SortOption getCurrentSortOption(); ServiceModeOption getCurrentServiceModeOption(); SmartRegisterPaginatedAdapter getClientsAdapter(); void setClientsAdapter(SmartRegisterPaginatedAdapter clientsAdapter); @Override View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState); void refreshListView(); void setupSearchView(View view); void onSortSelection(SortOption sortBy); void onFilterSelection(FilterOption filter); void gotoNextPage(); void goBackToPreviousPage(); boolean isRefreshList(); void setRefreshList(boolean refreshList); static final String DIALOG_TAG; static final List<? extends DialogOption> DEFAULT_FILTER_OPTIONS; public ListView clientsView; public ProgressBar clientsProgressView; public TextView serviceModeView; public TextView appliedVillageFilterView; public TextView appliedSortView; public EditText searchView; public View searchCancelView; public TextView titleLabelView; public View mView; }### Answer: @Test public void refreshListView() { Mockito.doNothing().when(securedNativeSmartRegisterFragment).onResumption(); securedNativeSmartRegisterFragment.refreshListView(); Mockito.verify(securedNativeSmartRegisterFragment).setRefreshList(true); Mockito.verify(securedNativeSmartRegisterFragment).onResumption(); Mockito.verify(securedNativeSmartRegisterFragment).setRefreshList(false); }
### Question: BaseListFragment extends Fragment implements ListContract.View<T> { @Override public void setLoadingState(boolean loadingState) { int result = loadingState ? incompleteRequests.incrementAndGet() : incompleteRequests.decrementAndGet(); progressBar.setVisibility(result > 0 ? View.VISIBLE : View.INVISIBLE); } @Override View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState); @Override void bindLayout(); @Override boolean hasDivider(); @Override void renderData(List<T> identifiables); @Override void refreshView(); @Override void setLoadingState(boolean loadingState); @Override abstract void onListItemClicked(T t, int layoutID); @NonNull @Override abstract ListContract.Adapter<T> adapter(); @NonNull @Override ListContract.Presenter<T> loadPresenter(); }### Answer: @Test public void testSetLoadingStateCalledTwiceHidesViewAfterBeingCalledTwice() { ProgressBar progressBar = Mockito.mock(ProgressBar.class); Whitebox.setInternalState(baseListFragment, "progressBar", progressBar); AtomicInteger incompleteRequests = new AtomicInteger(0); Whitebox.setInternalState(baseListFragment, "incompleteRequests", incompleteRequests); baseListFragment.setLoadingState(true); Assert.assertEquals(incompleteRequests.get(), 1); baseListFragment.setLoadingState(true); Assert.assertEquals(incompleteRequests.get(), 2); baseListFragment.setLoadingState(false); Assert.assertEquals(incompleteRequests.get(), 1); Mockito.verify(progressBar, Mockito.times(3)).setVisibility(View.VISIBLE); baseListFragment.setLoadingState(false); Assert.assertEquals(incompleteRequests.get(), 0); Mockito.verify(progressBar, Mockito.times(1)).setVisibility(View.INVISIBLE); }
### Question: BaseListFragment extends Fragment implements ListContract.View<T> { @NonNull @Override public ListContract.Presenter<T> loadPresenter() { if (presenter == null) { presenter = new ListPresenter<T>() .with(this); } return presenter; } @Override View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState); @Override void bindLayout(); @Override boolean hasDivider(); @Override void renderData(List<T> identifiables); @Override void refreshView(); @Override void setLoadingState(boolean loadingState); @Override abstract void onListItemClicked(T t, int layoutID); @NonNull @Override abstract ListContract.Adapter<T> adapter(); @NonNull @Override ListContract.Presenter<T> loadPresenter(); }### Answer: @Test public void testLoadPresenterAssignsPresenter() { Assert.assertNull(Whitebox.getInternalState(baseListFragment, "presenter")); ListContract.Presenter presenter = baseListFragment.loadPresenter(); Assert.assertNotNull(Whitebox.getInternalState(baseListFragment, "presenter")); Assert.assertEquals(presenter, Whitebox.getInternalState(baseListFragment, "presenter")); }
### Question: ViewHelper { public static ViewGroup getPaginationView(Activity context) { return (ViewGroup) context.getLayoutInflater() .inflate(R.layout.smart_register_pagination, null); } static PaginationHolder addPaginationCore(View.OnClickListener onClickListener, ListView clientsView); static ViewGroup getPaginationView(Activity context); }### Answer: @Test public void testGetPaginationViewInflatesCorrectLayout() { Mockito.doReturn(layoutInflater).when(activity).getLayoutInflater(); Mockito.doReturn(paginationView).when(layoutInflater).inflate(R.layout.smart_register_pagination, null); ViewHelper.getPaginationView(activity); Mockito.verify(layoutInflater).inflate(R.layout.smart_register_pagination, null); }
### Question: ViewHelper { public static PaginationHolder addPaginationCore(View.OnClickListener onClickListener, ListView clientsView) { ViewGroup footerView = getPaginationView((Activity) clientsView.getContext()); PaginationHolder paginationHolder = new PaginationHolder(); paginationHolder.setNextPageView(footerView.findViewById(R.id.btn_next_page)); paginationHolder.setPreviousPageView(footerView.findViewById(R.id.btn_previous_page)); paginationHolder.setPageInfoView(footerView.findViewById(R.id.txt_page_info)); paginationHolder.getNextPageView().setOnClickListener(onClickListener); paginationHolder.getPreviousPageView().setOnClickListener(onClickListener); footerView.setLayoutParams( new AbsListView.LayoutParams(AbsListView.LayoutParams.MATCH_PARENT, (int) clientsView.getContext().getResources().getDimension(R.dimen.pagination_bar_height))); clientsView.addFooterView(footerView); return paginationHolder; } static PaginationHolder addPaginationCore(View.OnClickListener onClickListener, ListView clientsView); static ViewGroup getPaginationView(Activity context); }### Answer: @Test public void testAddPaginationCoreCreatesPaginationHolderWithCorrectValues() { Mockito.doReturn(layoutInflater).when(activity).getLayoutInflater(); Mockito.doReturn(paginationView).when(layoutInflater).inflate(R.layout.smart_register_pagination, null); Mockito.doReturn(activity).when(clientsView).getContext(); Mockito.doReturn(nextPageButton).when(paginationView).findViewById(R.id.btn_next_page); Mockito.doReturn(prevPageButton).when(paginationView).findViewById(R.id.btn_previous_page); Mockito.doReturn(infoTextView).when(paginationView).findViewById(R.id.txt_page_info); Mockito.doReturn(LayoutDirection.LTR).when(paginationView).getLayoutDirection(); Mockito.doReturn(resources).when(activity).getResources(); Mockito.doReturn(1985.0f).when(resources).getDimension(ArgumentMatchers.anyInt()); PaginationHolder paginationHolder = ViewHelper.addPaginationCore(clickListener, clientsView); Assert.assertNotNull(paginationHolder); Assert.assertEquals(nextPageButton, paginationHolder.getNextPageView()); Assert.assertEquals(prevPageButton, paginationHolder.getPreviousPageView()); Assert.assertEquals(infoTextView, paginationHolder.getPageInfoView()); Mockito.verify(nextPageButton).setOnClickListener(clickListener); Mockito.verify(prevPageButton).setOnClickListener(clickListener); } @Test public void testAddPaginationCoreCreatesFooterViewCorrectly() { Mockito.doReturn(layoutInflater).when(activity).getLayoutInflater(); Mockito.doReturn(paginationView).when(layoutInflater).inflate(R.layout.smart_register_pagination, null); Mockito.doReturn(activity).when(clientsView).getContext(); Mockito.doReturn(nextPageButton).when(paginationView).findViewById(R.id.btn_next_page); Mockito.doReturn(prevPageButton).when(paginationView).findViewById(R.id.btn_previous_page); Mockito.doReturn(infoTextView).when(paginationView).findViewById(R.id.txt_page_info); Mockito.doReturn(LayoutDirection.LTR).when(paginationView).getLayoutDirection(); Mockito.doReturn(resources).when(activity).getResources(); Mockito.doReturn(TEST_DIMENSION).when(resources).getDimension(ArgumentMatchers.anyInt()); PaginationHolder paginationHolder = ViewHelper.addPaginationCore(clickListener, clientsView); Assert.assertNotNull(paginationHolder); AbsListView.LayoutParams layoutParams = (AbsListView.LayoutParams) paginationView.getLayoutParams(); Assert.assertNotNull(layoutParams); Assert.assertEquals(-1, layoutParams.width); Assert.assertEquals(1985.0f, layoutParams.height, 0); Mockito.verify(clientsView).addFooterView(paginationView); }
### Question: ReportIndicatorDetailViewController { public String get() { String annualTarget = (isBlank(indicatorDetails.annualTarget())) ? "NA" : indicatorDetails.annualTarget(); return new Gson().toJson(new IndicatorReportDetail(categoryDescription, indicatorDetails.reportIndicator().description(), indicatorDetails.reportIndicator().name(), annualTarget, indicatorDetails.monthlySummaries())); } ReportIndicatorDetailViewController(Context context, Report indicatorDetails, String categoryDescription); String get(); void startReportIndicatorCaseList(String month); }### Answer: @Test public void shouldGetIndicatorReportsForGivenCategory() throws Exception { List<MonthSummaryDatum> monthlySummaries = Arrays.asList(new MonthSummaryDatum("10", "2012", "2", "2", Arrays.asList("123", "456"))); Report iudReport = new Report("IUD", "40", new Gson().toJson(monthlySummaries)); ReportIndicatorDetailViewController controller = new ReportIndicatorDetailViewController(context, iudReport, "Family Planning"); String indicatorReportDetail = controller.get(); String expectedIndicatorReports = new Gson().toJson(new IndicatorReportDetail("Family Planning", "IUD Adoption", "IUD", "40", monthlySummaries)); Assert.assertEquals(expectedIndicatorReports, indicatorReportDetail); } @Test public void shouldShowNAIfAnnualTargetNotAvailable() throws Exception { List<MonthSummaryDatum> monthlySummaries = Arrays.asList(new MonthSummaryDatum("6", "2012", "2", "2", Arrays.asList("123", "456")), new MonthSummaryDatum("8", "2012", "2", "4", Arrays.asList("321", "654"))); Report iudReport = new Report("IUD", null, new Gson().toJson(monthlySummaries)); ReportIndicatorDetailViewController controller = new ReportIndicatorDetailViewController(context, iudReport, "Family Planning"); String indicatorReportDetail = controller.get(); String expectedIndicatorReports = new Gson().toJson(new IndicatorReportDetail("Family Planning", "IUD Adoption", "IUD", "NA", monthlySummaries)); Assert.assertEquals(expectedIndicatorReports, indicatorReportDetail); }
### Question: EligibleCoupleDetailController { @JavascriptInterface public String get() { EligibleCouple eligibleCouple = allEligibleCouples.findByCaseID(caseId); ECDetail ecContext = new ECDetail(caseId, eligibleCouple.village(), eligibleCouple.subCenter(), eligibleCouple.ecNumber(), eligibleCouple.isHighPriority(), null, eligibleCouple.photoPath(), new ArrayList<Child>(), new CoupleDetails(eligibleCouple.wifeName(), eligibleCouple.husbandName(), eligibleCouple.ecNumber(), eligibleCouple.isOutOfArea()), eligibleCouple.details()). addTimelineEvents(getEvents()); return new Gson().toJson(ecContext); } EligibleCoupleDetailController(Context context, String caseId, AllEligibleCouples allEligibleCouples, AllTimelineEvents allTimelineEvents); @JavascriptInterface String get(); @JavascriptInterface void takePhoto(); }### Answer: @Test public void shouldGetANCDetailsAsJSON() { TimelineEvent pregnancyEvent = TimelineEvent.forStartOfPregnancyForEC(caseId, "TC 1", "2011-10-21", "2011-10-21"); TimelineEvent fpEvent = TimelineEvent.forChangeOfFPMethod(caseId, "condom", "iud", "2011-12-22"); TimelineEvent eventVeryCloseToCurrentDate = TimelineEvent.forChangeOfFPMethod(caseId, "iud", "condom", "2012-07-29"); HashMap<String, String> details = new HashMap<String, String>(); details.put("ashaName", "Shiwani"); details.put("isHighPriority", "1"); Mockito.when(allEligibleCouples.findByCaseID(caseId)).thenReturn(new EligibleCouple("EC CASE 1", "Woman 1", "Husband 1", "EC Number 1", "Village 1", "Subcenter 1", details)); Mockito.when(allTimelineEvents.forCase(caseId)).thenReturn(Arrays.asList(pregnancyEvent, fpEvent, eventVeryCloseToCurrentDate)); ECDetail expectedDetail = new ECDetail(caseId, "Village 1", "Subcenter 1", "EC Number 1", true, null, null, new ArrayList<Child>(), new CoupleDetails("Woman 1", "Husband 1", "EC Number 1", false), details) .addTimelineEvents(Arrays.asList(eventFor(eventVeryCloseToCurrentDate, "29-07-2012"), eventFor(fpEvent, "22-12-2011"), eventFor(pregnancyEvent, "21-10-2011"))); String actualJson = controller.get(); ECDetail actualDetail = new Gson().fromJson(actualJson, ECDetail.class); Assert.assertEquals(expectedDetail, actualDetail); }
### Question: Cache { public T get(String key, CacheableData<T> cacheableData) { if (value.get(key) != null) { return value.get(key); } T fetchedData = cacheableData.fetch(); value.put(key, fetchedData); return fetchedData; } Cache(); T get(String key, CacheableData<T> cacheableData); void evict(String key); }### Answer: @Test public void shouldGetAndCacheValueOnlyWhenItDoesNotExist() throws Exception { Cache<String> cache = new Cache<String>(); Mockito.when(cacheableData.fetch()).thenReturn("value"); Assert.assertEquals("value", cache.get("key", cacheableData)); Mockito.verify(cacheableData).fetch(); Assert.assertEquals("value", cache.get("key", cacheableData)); Mockito.verify(cacheableData, Mockito.times(1)).fetch(); } @Test public void shouldClearCacheWhenActionsAreUpdated() throws Exception { Cache<String> cache = new Cache<String>(); Mockito.when(cacheableData.fetch()).thenReturn("value"); cache.get("key", cacheableData); Event.ON_DATA_FETCHED.notifyListeners(FetchStatus.fetched); Assert.assertEquals("value", cache.get("key", cacheableData)); Mockito.verify(cacheableData, Mockito.times(2)).fetch(); Event.ON_DATA_FETCHED.notifyListeners(FetchStatus.fetchedFailed); Assert.assertEquals("value", cache.get("key", cacheableData)); Mockito.verify(cacheableData, Mockito.times(2)).fetch(); } @Test public void shouldClearCacheWhenFormIsSubmitted() throws Exception { Cache<String> cache = new Cache<String>(); Mockito.when(cacheableData.fetch()).thenReturn("value"); cache.get("key", cacheableData); Event.FORM_SUBMITTED.notifyListeners("ec_registration"); Assert.assertEquals("value", cache.get("key", cacheableData)); Mockito.verify(cacheableData, Mockito.times(2)).fetch(); }
### Question: PNCDetailController { @JavascriptInterface public String get() { Mother mother = allBeneficiaries.findMotherWithOpenStatus(caseId); EligibleCouple couple = allEligibleCouples.findByCaseID(mother.ecCaseId()); LocalDate deliveryDate = LocalDate.parse(mother.referenceDate()); Days postPartumDuration = Days.daysBetween(deliveryDate, DateUtil.today()); PNCDetail detail = new PNCDetail(caseId, mother.thayiCardNumber(), new CoupleDetails(couple.wifeName(), couple.husbandName(), couple.ecNumber(), couple.isOutOfArea()).withCaste(couple.getDetail("caste")) .withEconomicStatus(couple.getDetail("economicStatus")) .withPhotoPath(couple.photoPath()), new LocationDetails(couple.village(), couple.subCenter()), new PregnancyOutcomeDetails(deliveryDate.toString(), postPartumDuration.getDays())) .addTimelineEvents(getEvents()).addExtraDetails(mother.details()); return new Gson().toJson(detail); } PNCDetailController(Context context, String caseId, AllEligibleCouples allEligibleCouples, AllBeneficiaries allBeneficiaries, AllTimelineEvents allTimelineEvents); @JavascriptInterface String get(); @JavascriptInterface void takePhoto(); }### Answer: @Test public void shouldGetPNCDetailsAsJSON() throws Exception { TimelineEvent pregnancyEvent = TimelineEvent.forStartOfPregnancy(caseId, "2011-10-21", "2011-10-21"); TimelineEvent ancEvent = TimelineEvent.forANCCareProvided(caseId, "2", "2011-12-22", new HashMap<String, String>()); TimelineEvent eventVeryCloseToCurrentDate = TimelineEvent.forANCCareProvided(caseId, "2", "2012-07-29", new HashMap<String, String>()); HashMap<String, String> details = new HashMap<String, String>(); details.put("ashaName", "Shiwani"); details.put("isHighRisk", "yes"); details.put("highRiskReason", "Anaemia"); Mockito.when(allBeneficiaries.findMotherWithOpenStatus(caseId)).thenReturn(new Mother(caseId, "EC CASE 1", "TC 1", "2012-07-28").withDetails(details)); HashMap<String, String> ecDetails = new HashMap<String, String>(); ecDetails.put("caste", "c_others"); ecDetails.put("economicStatus", "apl"); Mockito.when(allEligibleCouples.findByCaseID("EC CASE 1")).thenReturn(new EligibleCouple("EC CASE 1", "Woman 1", "Husband 1", "EC Number 1", "Village 1", "Subcenter 1", ecDetails).withPhotoPath("photo path")); Mockito.when(allTimelineEvents.forCase(caseId)).thenReturn(Arrays.asList(pregnancyEvent, ancEvent, eventVeryCloseToCurrentDate)); PNCDetail expectedDetail = new PNCDetail(caseId, "TC 1", new CoupleDetails("Woman 1", "Husband 1", "EC Number 1", false).withCaste("c_others").withEconomicStatus("apl").withPhotoPath("photo path"), new LocationDetails("Village 1", "Subcenter 1"), new PregnancyOutcomeDetails("2012-07-28", 4)) .addTimelineEvents(Arrays.asList(eventFor(eventVeryCloseToCurrentDate, "29-07-2012"), eventFor(ancEvent, "22-12-2011"), eventFor(pregnancyEvent, "21-10-2011"))) .addExtraDetails(details); String actualJson = controller.get(); PNCDetail actualDetail = new Gson().fromJson(actualJson, PNCDetail.class); Assert.assertEquals(expectedDetail, actualDetail); }
### Question: ConnectivityChangeReceiver extends BroadcastReceiver { @Override public void onReceive(final Context context, Intent intent) { logInfo("Connectivity change receiver triggered."); if (intent.getExtras() != null) { if (isDeviceDisconnectedFromNetwork(intent)) { logInfo("Device got disconnected from network. Stopping Dristhi Sync scheduler."); DrishtiSyncScheduler.stop(context); return; } if (isDeviceConnectedToNetwork(intent)) { logInfo("Device got connected to network. Trying to start Dristhi Sync scheduler."); DrishtiSyncScheduler.start(context); } } } @Override void onReceive(final Context context, Intent intent); }### Answer: @Test public void onReceiveShouldCreateAlarmWhenDeviceIsConnectedToNetwork() { Intent intent = new Intent(); NetworkInfo networkInfo = Mockito.mock(NetworkInfo.class); Mockito.doReturn(true).when(networkInfo).isConnected(); intent.putExtra(ConnectivityManager.EXTRA_NETWORK_INFO, networkInfo); DrishtiSyncScheduler.setReceiverClass(LoginActivityMock.class); AlarmManager alarmManager = (AlarmManager) RuntimeEnvironment.application.getSystemService(Context.ALARM_SERVICE); ShadowAlarmManager shadowAlarmManager = Shadows.shadowOf(alarmManager); Assert.assertNull(shadowAlarmManager.getNextScheduledAlarm()); connectivityChangeReceiver.onReceive(RuntimeEnvironment.application, intent); ShadowAlarmManager.ScheduledAlarm scheduledAlarm = shadowAlarmManager.getNextScheduledAlarm(); Assert.assertEquals(120000, scheduledAlarm.interval); Assert.assertNotNull(scheduledAlarm.operation); } @Test public void onReceiveShouldCancelAlarmWhenDeviceIsDisconnectFromNetwork() { Intent intent = new Intent(); NetworkInfo networkInfo = Mockito.mock(NetworkInfo.class); Mockito.doReturn(true).when(networkInfo).isConnected(); intent.putExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, true); DrishtiSyncScheduler.setReceiverClass(LoginActivityMock.class); DrishtiSyncScheduler.start(RuntimeEnvironment.application); AlarmManager alarmManager = (AlarmManager) RuntimeEnvironment.application.getSystemService(Context.ALARM_SERVICE); ShadowAlarmManager shadowAlarmManager = Shadows.shadowOf(alarmManager); Assert.assertNotNull(shadowAlarmManager.getNextScheduledAlarm()); connectivityChangeReceiver.onReceive(RuntimeEnvironment.application, intent); Assert.assertNull(shadowAlarmManager.getNextScheduledAlarm()); }
### Question: ListInteractor implements ListContract.Interactor<T> { @Override public void runRequest(@NotNull Callable<List<T>> callable, @NotNull AppExecutors.Request request, @NotNull ListContract.Presenter<T> presenter) { Runnable runnable = () -> { try { List<T> tList = callable.call(); appExecutors.mainThread().execute(() -> presenter.onItemsFetched(tList)); } catch (Exception e) { Timber.e(e); appExecutors.mainThread().execute(() -> presenter.onFetchRequestError(e)); } }; appExecutors.execute(runnable, request); } ListInteractor(); @VisibleForTesting ListInteractor(AppExecutors appExecutors); @Override void runRequest(@NotNull Callable<List<T>> callable, @NotNull AppExecutors.Request request, @NotNull ListContract.Presenter<T> presenter); }### Answer: @Test public void testRunRequest() { Callable<List<ListContract.Identifiable>> callable = Mockito.mock(Callable.class); AppExecutors.Request request = AppExecutors.Request.DISK_THREAD; interactor.runRequest(callable, request, presenter); Mockito.verify(appExecutors.diskIO()).execute(Mockito.any()); Mockito.verify(appExecutors.mainThread()).execute(Mockito.any()); }
### Question: OpenSRPViewPager extends ViewPager { @Override public boolean onInterceptTouchEvent(MotionEvent event) { return false; } OpenSRPViewPager(Context context); OpenSRPViewPager(Context context, AttributeSet attrs); @Override boolean onInterceptTouchEvent(MotionEvent event); @Override boolean onTouchEvent(MotionEvent event); }### Answer: @Test public void assertOnInterceptTouchEventReturnsFalse() { OpenSRPViewPager openSRPViewPager = new OpenSRPViewPager(RuntimeEnvironment.application); org.junit.Assert.assertEquals(openSRPViewPager.onInterceptTouchEvent(null), false); }
### Question: OpenSRPViewPager extends ViewPager { @Override public boolean onTouchEvent(MotionEvent event) { return false; } OpenSRPViewPager(Context context); OpenSRPViewPager(Context context, AttributeSet attrs); @Override boolean onInterceptTouchEvent(MotionEvent event); @Override boolean onTouchEvent(MotionEvent event); }### Answer: @Test public void assertOnTouchEventReturnsFalse() { OpenSRPViewPager openSRPViewPager = new OpenSRPViewPager(RuntimeEnvironment.application); org.junit.Assert.assertEquals(openSRPViewPager.onTouchEvent(null), false); }
### Question: SettingsActivity extends PreferenceActivity implements Preference.OnPreferenceChangeListener, Preference.OnPreferenceClickListener, View.OnClickListener { @Override public boolean onPreferenceChange(Preference preference, Object newValue) { if (newValue != null) { updateUrl(newValue.toString()); } return true; } @Override boolean onPreferenceChange(Preference preference, Object newValue); @Override boolean onPreferenceClick(Preference preference); @Override void onClick(View view); }### Answer: @Test public void testOnPreferenceChangeInvokesPreferenceSettingsWithCorrectValues() { ReflectionHelpers.setField(CoreLibrary.getInstance().context(), "allSharedPreferences", sharedPreferences); activity.onPreferenceChange(null, HOSTURL + ":" + PORT); Mockito.verify(sharedPreferences).savePort(8080); Mockito.verify(sharedPreferences).saveHost(HOSTURL); }
### Question: SettingsActivity extends PreferenceActivity implements Preference.OnPreferenceChangeListener, Preference.OnPreferenceClickListener, View.OnClickListener { @Override public void onClick(View view) { String newValue = baseUrlEditTextPreference.getEditText().getText().toString(); if (newValue != null && UrlUtil.isValidUrl(newValue)) { baseUrlEditTextPreference.onClick(null, DialogInterface.BUTTON_POSITIVE); dialog.dismiss(); } else { Utils.showShortToast(baseUrlEditTextPreference.getContext(), baseUrlEditTextPreference.getContext().getString(R.string.invalid_url_massage)); } } @Override boolean onPreferenceChange(Preference preference, Object newValue); @Override boolean onPreferenceClick(Preference preference); @Override void onClick(View view); }### Answer: @Test public void testOnClickInvokesBaseUrlEditTextPreferenceOnClickMethod() { ReflectionHelpers.setField(activity, "dialog", alertDialog); ReflectionHelpers.setField(activity, "baseUrlEditTextPreference", baseUrlEditTextPreference); Assert.assertNotNull(baseUrlEditTextPreference); baseUrlEditTextPreference.getEditText().setText(HOSTURL + ":" + PORT); activity.onClick(view); Mockito.verify(alertDialog).dismiss(); } @Test public void testOnClickInvokesShowErrorToastIfInvalidUrlEntered() { ReflectionHelpers.setField(activity, "dialog", alertDialog); ReflectionHelpers.setField(activity, "baseUrlEditTextPreference", baseUrlEditTextPreference); Assert.assertNotNull(baseUrlEditTextPreference); baseUrlEditTextPreference.getEditText().setText("baddly-formed-url:" + PORT); activity.onClick(view); Toast toast = ShadowToast.getLatestToast(); assertEquals(Toast.LENGTH_SHORT, toast.getDuration()); assertEquals(RuntimeEnvironment.application.getString(R.string.invalid_url_massage), ShadowToast.getTextOfLatestToast()); }
### Question: BaseRegisterActivity extends SecuredNativeSmartRegisterActivity implements BaseRegisterContract.View { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_base_register); mPager = findViewById(R.id.base_view_pager); Fragment[] otherFragments = getOtherFragments(); mBaseFragment = getRegisterFragment(); mBaseFragment.setArguments(this.getIntent().getExtras()); mPagerAdapter = new PagerAdapter(getSupportFragmentManager(), mBaseFragment, otherFragments); mPager.setOffscreenPageLimit(otherFragments.length); mPager.setAdapter(mPagerAdapter); mPager.addOnPageChangeListener(new ViewPager.SimpleOnPageChangeListener() { @Override public void onPageSelected(int position) { currentPage = position; } }); initializePresenter(); presenter.updateInitials(); registerBottomNavigation(); } @Override boolean onCreateOptionsMenu(Menu menu); @Override void onBackPressed(); @Override void displaySyncNotification(); @Override void displayToast(int resourceId); @Override void displayToast(String message); @Override void displayShortToast(int resourceId); @Override abstract void startFormActivity(String formName, String entityId, Map<String, String> metaData); @Override abstract void startFormActivity(JSONObject form); void refreshList(final FetchStatus fetchStatus); @Override void onResume(); @Override void showProgressDialog(int titleIdentifier); @Override void hideProgressDialog(); Fragment findFragmentByPosition(int position); abstract List<String> getViewIdentifiers(); @Override Context getContext(); void startQrCodeScanner(); @Override void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults); void switchToFragment(final int position); @Override void updateInitialsText(String initials); void switchToBaseFragment(); void setSelectedBottomBarMenuItem(int itemId); void setSearchTerm(String searchTerm); static int BASE_REG_POSITION; static int ADVANCED_SEARCH_POSITION; static int SORT_FILTER_POSITION; static int LIBRARY_POSITION; static int ME_POSITION; }### Answer: @Test public void testOnCreate() { assertNotNull(activity.presenter); assertNotNull(activity.getRegisterFragment()); assertNotNull(Whitebox.getInternalState(activity, "mPagerAdapter")); }
### Question: BaseRegisterActivity extends SecuredNativeSmartRegisterActivity implements BaseRegisterContract.View { protected void registerBottomNavigation() { bottomNavigationHelper = new BottomNavigationHelper(); bottomNavigationView = findViewById(R.id.bottom_navigation); if (bottomNavigationView != null) { bottomNavigationView.getMenu().add(Menu.NONE, R.string.action_me, Menu.NONE, R.string.me) .setIcon(bottomNavigationHelper .writeOnDrawable(R.drawable.bottom_bar_initials_background, userInitials, getResources())); bottomNavigationHelper.disableShiftMode(bottomNavigationView); BottomNavigationListener bottomNavigationListener = new BottomNavigationListener(this); bottomNavigationView.setOnNavigationItemSelectedListener(bottomNavigationListener); } } @Override boolean onCreateOptionsMenu(Menu menu); @Override void onBackPressed(); @Override void displaySyncNotification(); @Override void displayToast(int resourceId); @Override void displayToast(String message); @Override void displayShortToast(int resourceId); @Override abstract void startFormActivity(String formName, String entityId, Map<String, String> metaData); @Override abstract void startFormActivity(JSONObject form); void refreshList(final FetchStatus fetchStatus); @Override void onResume(); @Override void showProgressDialog(int titleIdentifier); @Override void hideProgressDialog(); Fragment findFragmentByPosition(int position); abstract List<String> getViewIdentifiers(); @Override Context getContext(); void startQrCodeScanner(); @Override void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults); void switchToFragment(final int position); @Override void updateInitialsText(String initials); void switchToBaseFragment(); void setSelectedBottomBarMenuItem(int itemId); void setSearchTerm(String searchTerm); static int BASE_REG_POSITION; static int ADVANCED_SEARCH_POSITION; static int SORT_FILTER_POSITION; static int LIBRARY_POSITION; static int ME_POSITION; }### Answer: @Test public void testRegisterBottomNavigation() { BottomNavigationView bottomNavigationView = activity.findViewById(R.id.bottom_navigation); assertNotNull(bottomNavigationView); assertEquals(5, bottomNavigationView.getMenu().size()); MenuItem item = bottomNavigationView.getMenu().findItem(R.string.action_me); assertEquals(activity.getString(R.string.me), item.getTitle()); assertNotNull(item.getIcon()); assertNotNull(Whitebox.getInternalState(bottomNavigationView, "selectedListener")); }
### Question: BaseRegisterActivity extends SecuredNativeSmartRegisterActivity implements BaseRegisterContract.View { @Override protected void onDestroy() { super.onDestroy(); presenter.onDestroy(isChangingConfigurations()); } @Override boolean onCreateOptionsMenu(Menu menu); @Override void onBackPressed(); @Override void displaySyncNotification(); @Override void displayToast(int resourceId); @Override void displayToast(String message); @Override void displayShortToast(int resourceId); @Override abstract void startFormActivity(String formName, String entityId, Map<String, String> metaData); @Override abstract void startFormActivity(JSONObject form); void refreshList(final FetchStatus fetchStatus); @Override void onResume(); @Override void showProgressDialog(int titleIdentifier); @Override void hideProgressDialog(); Fragment findFragmentByPosition(int position); abstract List<String> getViewIdentifiers(); @Override Context getContext(); void startQrCodeScanner(); @Override void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults); void switchToFragment(final int position); @Override void updateInitialsText(String initials); void switchToBaseFragment(); void setSelectedBottomBarMenuItem(int itemId); void setSearchTerm(String searchTerm); static int BASE_REG_POSITION; static int ADVANCED_SEARCH_POSITION; static int SORT_FILTER_POSITION; static int LIBRARY_POSITION; static int ME_POSITION; }### Answer: @Test public void testOnDestroy() { BaseRegisterContract.Presenter presenter = activity.presenter; activity.onDestroy(); verify(presenter).onDestroy(false); }
### Question: BaseRegisterActivity extends SecuredNativeSmartRegisterActivity implements BaseRegisterContract.View { @Override public boolean onCreateOptionsMenu(Menu menu) { return true; } @Override boolean onCreateOptionsMenu(Menu menu); @Override void onBackPressed(); @Override void displaySyncNotification(); @Override void displayToast(int resourceId); @Override void displayToast(String message); @Override void displayShortToast(int resourceId); @Override abstract void startFormActivity(String formName, String entityId, Map<String, String> metaData); @Override abstract void startFormActivity(JSONObject form); void refreshList(final FetchStatus fetchStatus); @Override void onResume(); @Override void showProgressDialog(int titleIdentifier); @Override void hideProgressDialog(); Fragment findFragmentByPosition(int position); abstract List<String> getViewIdentifiers(); @Override Context getContext(); void startQrCodeScanner(); @Override void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults); void switchToFragment(final int position); @Override void updateInitialsText(String initials); void switchToBaseFragment(); void setSelectedBottomBarMenuItem(int itemId); void setSearchTerm(String searchTerm); static int BASE_REG_POSITION; static int ADVANCED_SEARCH_POSITION; static int SORT_FILTER_POSITION; static int LIBRARY_POSITION; static int ME_POSITION; }### Answer: @Test public void testOnCreateOptionsMenu() { BottomNavigationView bottomNavigationView = activity.findViewById(R.id.bottom_navigation); activity = spy(activity); assertTrue(activity.onCreateOptionsMenu(bottomNavigationView.getMenu())); verify(activity).onCreateOptionsMenu(any()); verifyNoMoreInteractions(activity); }
### Question: BaseRegisterActivity extends SecuredNativeSmartRegisterActivity implements BaseRegisterContract.View { @Override public void onBackPressed() { Fragment fragment = findFragmentByPosition(currentPage); if (fragment instanceof BaseRegisterFragment) { setSelectedBottomBarMenuItem(R.id.action_clients); BaseRegisterFragment registerFragment = (BaseRegisterFragment) fragment; if (registerFragment.onBackPressed()) { return; } } if (currentPage == 0) { super.onBackPressed(); } else { switchToBaseFragment(); setSelectedBottomBarMenuItem(R.id.action_clients); } } @Override boolean onCreateOptionsMenu(Menu menu); @Override void onBackPressed(); @Override void displaySyncNotification(); @Override void displayToast(int resourceId); @Override void displayToast(String message); @Override void displayShortToast(int resourceId); @Override abstract void startFormActivity(String formName, String entityId, Map<String, String> metaData); @Override abstract void startFormActivity(JSONObject form); void refreshList(final FetchStatus fetchStatus); @Override void onResume(); @Override void showProgressDialog(int titleIdentifier); @Override void hideProgressDialog(); Fragment findFragmentByPosition(int position); abstract List<String> getViewIdentifiers(); @Override Context getContext(); void startQrCodeScanner(); @Override void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults); void switchToFragment(final int position); @Override void updateInitialsText(String initials); void switchToBaseFragment(); void setSelectedBottomBarMenuItem(int itemId); void setSearchTerm(String searchTerm); static int BASE_REG_POSITION; static int ADVANCED_SEARCH_POSITION; static int SORT_FILTER_POSITION; static int LIBRARY_POSITION; static int ME_POSITION; }### Answer: @Test public void testOnBackPressedSwitchesToBaseFragment() { SyncStatusBroadcastReceiver.init(activity); Whitebox.setInternalState(activity, "currentPage", 1); Whitebox.setInternalState(activity, "mPager", mPager); activity = controller.visible().get(); activity.onBackPressed(); verify(mPager, atLeastOnce()).setCurrentItem(BASE_REG_POSITION, false); }
### Question: BaseRegisterActivity extends SecuredNativeSmartRegisterActivity implements BaseRegisterContract.View { @Override public void displaySyncNotification() { Snackbar syncStatusSnackbar = Snackbar.make(this.getWindow().getDecorView(), R.string.manual_sync_triggered, Snackbar.LENGTH_LONG); syncStatusSnackbar.show(); } @Override boolean onCreateOptionsMenu(Menu menu); @Override void onBackPressed(); @Override void displaySyncNotification(); @Override void displayToast(int resourceId); @Override void displayToast(String message); @Override void displayShortToast(int resourceId); @Override abstract void startFormActivity(String formName, String entityId, Map<String, String> metaData); @Override abstract void startFormActivity(JSONObject form); void refreshList(final FetchStatus fetchStatus); @Override void onResume(); @Override void showProgressDialog(int titleIdentifier); @Override void hideProgressDialog(); Fragment findFragmentByPosition(int position); abstract List<String> getViewIdentifiers(); @Override Context getContext(); void startQrCodeScanner(); @Override void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults); void switchToFragment(final int position); @Override void updateInitialsText(String initials); void switchToBaseFragment(); void setSelectedBottomBarMenuItem(int itemId); void setSearchTerm(String searchTerm); static int BASE_REG_POSITION; static int ADVANCED_SEARCH_POSITION; static int SORT_FILTER_POSITION; static int LIBRARY_POSITION; static int ME_POSITION; }### Answer: @Test @Config(shadows = {ShadowSnackBar.class}) public void testDisplaySyncNotification() { activity.displaySyncNotification(); Snackbar snackbar = ShadowSnackBar.getLatestSnackbar(); Snackbar.SnackbarLayout layout = (Snackbar.SnackbarLayout) snackbar.getView(); assertEquals(((TextView) ((SnackbarContentLayout) layout.getChildAt(0)).getChildAt(0)).getText(), activity.getString(R.string.manual_sync_triggered)); assertEquals(Snackbar.LENGTH_LONG, snackbar.getDuration()); assertTrue(snackbar.isShown()); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.