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: JsonIsochronesRequestProcessor extends AbstractHttpRequestProcessor { public static BBox constructIsochroneBBox(Envelope env){ BBox bbox = new BBox(0,0,0,0); if (Double.isFinite(env.getMinX())) bbox.minLon = env.getMinX(); if (Double.isFinite(env.getMinY())) bbox.minLat = env.getMinY(); if (Double.isFinite(env.getMaxX())) bbox.maxLon = env.getMaxX(); if (Double.isFinite(env.getMaxY())) bbox.maxLat = env.getMaxY(); if (!bbox.isValid()) bbox = new BBox(0, 0, 0, 0); return bbox; } JsonIsochronesRequestProcessor(HttpServletRequest request); @Override void process(HttpServletResponse response); static BBox constructIsochroneBBox(Envelope env); }### Answer: @Test public void constructNegativeIsochroneBBoxTest() { BBox bbox = JsonIsochronesRequestProcessor.constructIsochroneBBox(negativeEnv); BBox expectedBBox = new BBox(-77.033874, -77.025082, -12.127332, -12.120505); Assert.assertTrue(bbox.isValid()); Assert.assertEquals(expectedBBox.maxLat, bbox.maxLat, 0.0); Assert.assertEquals(expectedBBox.maxLon, bbox.maxLon, 0.0); Assert.assertEquals(expectedBBox.minLat, bbox.minLat, 0.0); Assert.assertEquals(expectedBBox.minLon, bbox.minLon, 0.0); Assert.assertEquals(Double.NaN, bbox.minEle, 0.0); Assert.assertEquals(Double.NaN, bbox.maxEle, 0.0); } @Test public void constructPositiveIsochroneBBoxTest() { BBox bbox = JsonIsochronesRequestProcessor.constructIsochroneBBox(positiveEnv); BBox expectedBBox = new BBox(2.288033, 2.304801, 48.854886, 48.864247); Assert.assertTrue(bbox.isValid()); Assert.assertEquals(expectedBBox.maxLat, bbox.maxLat, 0.0); Assert.assertEquals(expectedBBox.maxLon, bbox.maxLon, 0.0); Assert.assertEquals(expectedBBox.minLat, bbox.minLat, 0.0); Assert.assertEquals(expectedBBox.minLon, bbox.minLon, 0.0); Assert.assertEquals(Double.NaN, bbox.minEle, 0.0); Assert.assertEquals(Double.NaN, bbox.maxEle, 0.0); } @Test public void constructMixedIsochroneBBoxTest() { BBox bbox = JsonIsochronesRequestProcessor.constructIsochroneBBox(mixedEnv); BBox expectedBBox = new BBox(18.395489, 18.409940, -33.909040, -33.897771); Assert.assertTrue(bbox.isValid()); Assert.assertEquals(expectedBBox.maxLat, bbox.maxLat, 0.0); Assert.assertEquals(expectedBBox.maxLon, bbox.maxLon, 0.0); Assert.assertEquals(expectedBBox.minLat, bbox.minLat, 0.0); Assert.assertEquals(expectedBBox.minLon, bbox.minLon, 0.0); Assert.assertEquals(Double.NaN, bbox.minEle, 0.0); Assert.assertEquals(Double.NaN, bbox.maxEle, 0.0); }
### Question: SystemMessage { public static String getSystemMessage(Object requestObj) { if (messages == null) { loadMessages(); } if (messages.isEmpty()) { return ""; } if (requestObj == null) { requestObj = ""; } RequestParams params = new RequestParams(); if (requestObj.getClass() == RoutingRequest.class) { extractParams((RoutingRequest)requestObj, params); } else if (requestObj.getClass() == org.heigit.ors.matrix.MatrixRequest.class) { extractParams((org.heigit.ors.matrix.MatrixRequest)requestObj, params); } else if (requestObj.getClass() == org.heigit.ors.isochrones.IsochroneRequest.class) { extractParams((org.heigit.ors.isochrones.IsochroneRequest)requestObj, params); } else if (requestObj.getClass() == RouteRequest.class) { extractParams((RouteRequest)requestObj, params); } else if (requestObj.getClass() == MatrixRequest.class) { extractParams((MatrixRequest)requestObj, params); } else if (requestObj.getClass() == IsochronesRequest.class) { extractParams((IsochronesRequest)requestObj, params); } return selectMessage(params); } private SystemMessage(); static String getSystemMessage(Object requestObj); }### Answer: @Test public void testGetSystemMessage() throws ParameterValueException { System.setProperty("ors_app_config", "target/test-classes/app.config.test"); RoutingRequest v1RouteRequest = new RoutingRequest(); Assert.assertEquals("This message would be sent with every request on API v1 from January 2020 until June 2050", SystemMessage.getSystemMessage(v1RouteRequest)); RouteRequest routeRequest = new RouteRequest(new Double[][] {new Double[] {1.0,1.0}, new Double[] {2.0,2.0}}); routeRequest.setProfile(APIEnums.Profile.CYCLING_REGULAR); routeRequest.setRoutePreference(APIEnums.RoutePreference.FASTEST); Assert.assertEquals("This message would be sent with every routing bike fastest request", SystemMessage.getSystemMessage(routeRequest)); IsochronesRequest isochronesRequest = new IsochronesRequest(); Assert.assertEquals("This message would be sent with every request for geojson response", SystemMessage.getSystemMessage(isochronesRequest)); MatrixRequest matrixRequest = new MatrixRequest(new ArrayList<>()); Assert.assertEquals("This message would be sent with every request", SystemMessage.getSystemMessage(matrixRequest)); Assert.assertEquals("This message would be sent with every request", SystemMessage.getSystemMessage(null)); Assert.assertEquals("This message would be sent with every request", SystemMessage.getSystemMessage("not a valid request parameter object")); }
### Question: MatrixResponse { public MatrixResponseInfo getResponseInformation() { return responseInformation; } MatrixResponse(MatrixResult result, MatrixRequest request); MatrixResponseInfo getResponseInformation(); MatrixResult getMatrixResult(); MatrixRequest getMatrixRequest(); }### Answer: @Test public void getResponseInformation() { Assert.assertEquals(MatrixResponseInfo.class, bareMatrixResponse.responseInformation.getClass()); Assert.assertNotNull(bareMatrixResponse.responseInformation); }
### Question: JSONBasedIndividualMatrixResponse { List<JSON2DDestinations> constructDestinations(MatrixResult matrixResult) { List<JSON2DDestinations> destinations = new ArrayList<>(); for (ResolvedLocation location : matrixResult.getDestinations()) { if (location != null) destinations.add(new JSON2DDestinations(location, includeResolveLocations)); else destinations.add(null); } return destinations; } JSONBasedIndividualMatrixResponse(MatrixRequest request); }### Answer: @Test public void constructDestinations() { List<JSON2DDestinations> json2DDestinations = jsonBasedIndividualMatrixResponse.constructDestinations(matrixResult); Assert.assertEquals(1, json2DDestinations.size()); Assert.assertEquals("foo", json2DDestinations.get(0).name); Assert.assertEquals(new Coordinate(8.681495, 49.41461, Double.NaN), json2DDestinations.get(0).location); Double[] location = json2DDestinations.get(0).getLocation(); Assert.assertEquals(2, location.length); Assert.assertEquals(0, location[0].compareTo(8.681495)); Assert.assertEquals(0, location[1].compareTo(49.41461)); }
### Question: JSONBasedIndividualMatrixResponse { List<JSON2DSources> constructSources(MatrixResult matrixResult) { List<JSON2DSources> sources = new ArrayList<>(); for (ResolvedLocation location : matrixResult.getSources()) { if (location != null) sources.add(new JSON2DSources(location, includeResolveLocations)); else sources.add(null); } return sources; } JSONBasedIndividualMatrixResponse(MatrixRequest request); }### Answer: @Test public void constructSources() { List<JSON2DSources> json2DSources = jsonBasedIndividualMatrixResponse.constructSources(matrixResult); Assert.assertEquals(1, json2DSources.size()); Assert.assertEquals("foo", json2DSources.get(0).name); Assert.assertEquals(new Coordinate(8.681495, 49.41461, Double.NaN), json2DSources.get(0).location); Double[] location = json2DSources.get(0).getLocation(); Assert.assertEquals(2, location.length); Assert.assertEquals(0, location[0].compareTo(8.681495)); Assert.assertEquals(0, location[1].compareTo(49.41461)); }
### Question: JSONMatrixResponse extends MatrixResponse { @JsonProperty("matrix") @JsonUnwrapped public JSONIndividualMatrixResponse getMatrix() { return new JSONIndividualMatrixResponse(matrixResult, matrixRequest); } JSONMatrixResponse(MatrixResult result, MatrixRequest request); @JsonProperty("matrix") @JsonUnwrapped JSONIndividualMatrixResponse getMatrix(); @JsonProperty("metadata") @ApiModelProperty("Information about the service and request") MatrixResponseInfo getInfo(); }### Answer: @Test public void getMatrix() { JSONIndividualMatrixResponse durationMatrix = jsonMatrixDurationsResponse.getMatrix(); Assert.assertNotNull(durationMatrix.getDurations()); Assert.assertNull(durationMatrix.getDistances()); Assert.assertEquals(3, durationMatrix.getDestinations().size()); Assert.assertEquals(3, durationMatrix.getSources().size()); Assert.assertEquals(8.681495, durationMatrix.getSources().get(0).location.x, 0); Assert.assertEquals(49.41461, durationMatrix.getSources().get(0).location.y, 0); Assert.assertEquals(Double.NaN, durationMatrix.getSources().get(0).location.z, 0); Assert.assertNotNull(durationMatrix.getSources().get(0).name); Assert.assertEquals(0.0, durationMatrix.getSources().get(0).getSnappedDistance(), 0); JSONIndividualMatrixResponse distanceMatrix = jsonMatrixDistancesResponse.getMatrix(); Assert.assertNotNull(distanceMatrix.getDistances()); Assert.assertNull(distanceMatrix.getDurations()); Assert.assertEquals(3, distanceMatrix.getDestinations().size()); Assert.assertEquals(3, distanceMatrix.getSources().size()); Assert.assertEquals(8.681495, distanceMatrix.getSources().get(0).location.x, 0); Assert.assertEquals(49.41461, distanceMatrix.getSources().get(0).location.y, 0); Assert.assertEquals(Double.NaN, distanceMatrix.getSources().get(0).location.z, 0); Assert.assertNull(distanceMatrix.getSources().get(0).name); Assert.assertEquals(0.0, distanceMatrix.getSources().get(0).getSnappedDistance(), 0); JSONIndividualMatrixResponse combinedMatrix = jsonMatrixCombinedResponse.getMatrix(); Assert.assertNotNull(combinedMatrix.getDistances()); Assert.assertNotNull(combinedMatrix.getDurations()); Assert.assertEquals(3, combinedMatrix.getDestinations().size()); Assert.assertEquals(3, combinedMatrix.getSources().size()); Assert.assertEquals(8.681495, combinedMatrix.getSources().get(0).location.x, 0); Assert.assertEquals(49.41461, combinedMatrix.getSources().get(0).location.y, 0); Assert.assertEquals(Double.NaN, combinedMatrix.getSources().get(0).location.z, 0); Assert.assertNotNull(combinedMatrix.getSources().get(0).name); Assert.assertEquals(0.0, combinedMatrix.getSources().get(0).getSnappedDistance(), 0); }
### Question: JSONMatrixResponse extends MatrixResponse { @JsonProperty("metadata") @ApiModelProperty("Information about the service and request") public MatrixResponseInfo getInfo() { return responseInformation; } JSONMatrixResponse(MatrixResult result, MatrixRequest request); @JsonProperty("matrix") @JsonUnwrapped JSONIndividualMatrixResponse getMatrix(); @JsonProperty("metadata") @ApiModelProperty("Information about the service and request") MatrixResponseInfo getInfo(); }### Answer: @Test public void getInfo() { Assert.assertEquals(MatrixResponseInfo.class, jsonMatrixDurationsResponse.getInfo().getClass()); Assert.assertNotNull(jsonMatrixDurationsResponse.getInfo().getEngineInfo()); Assert.assertNotNull(jsonMatrixDurationsResponse.getInfo().getAttribution()); Assert.assertNotNull(jsonMatrixDurationsResponse.getInfo().getRequest()); Assert.assertNotNull(jsonMatrixDurationsResponse.getInfo().getService()); Assert.assertTrue(jsonMatrixDurationsResponse.getInfo().getTimeStamp() > 0); }
### Question: JSONLocation { public Double getSnappedDistance() { return FormatUtility.roundToDecimals(snappedDistance, SNAPPED_DISTANCE_DECIMAL_PLACES); } JSONLocation(ResolvedLocation location, boolean includeResolveLocations); Double getSnappedDistance(); Double[] getLocation(); }### Answer: @Test public void getSnapped_distance() { Assert.assertEquals("foo", jsonLocationWithLocation.name); Assert.assertEquals(new Double(0.0), jsonLocationWithLocation.getSnappedDistance()); }
### Question: JSONLocation { public Double[] getLocation() { return new Double[0]; } JSONLocation(ResolvedLocation location, boolean includeResolveLocations); Double getSnappedDistance(); Double[] getLocation(); }### Answer: @Test public void getLocation() { Assert.assertEquals(new Coordinate(8.681495, 49.41461, Double.NaN), jsonLocationWithLocation.location); Assert.assertArrayEquals(new Double[0], jsonLocationWithLocation.getLocation()); }
### Question: JSONIndividualMatrixResponse extends JSONBasedIndividualMatrixResponse { public Double[][] getDistances() { return distances; } JSONIndividualMatrixResponse(MatrixResult result, MatrixRequest request); Double[][] getDurations(); List<JSON2DDestinations> getDestinations(); List<JSON2DSources> getSources(); Double[][] getDistances(); void setDistances(Double[][] distances); void setDurations(Double[][] durations); void setDestinations(List<JSON2DDestinations> destinations); void setSources(List<JSON2DSources> sources); }### Answer: @Test public void getDistances() { Assert.assertNull(durationsMatrixResponse.getDistances()); Assert.assertArrayEquals(new Double[]{0.0, 1.0, 2.0}, distancesMatrixResponse.getDistances()[0]); Assert.assertArrayEquals(new Double[]{3.0,4.0,5.0}, combinedMatrixResponse.getDistances()[1]); }
### Question: JSONIndividualMatrixResponse extends JSONBasedIndividualMatrixResponse { public void setDistances(Double[][] distances) { this.distances = distances; } JSONIndividualMatrixResponse(MatrixResult result, MatrixRequest request); Double[][] getDurations(); List<JSON2DDestinations> getDestinations(); List<JSON2DSources> getSources(); Double[][] getDistances(); void setDistances(Double[][] distances); void setDurations(Double[][] durations); void setDestinations(List<JSON2DDestinations> destinations); void setSources(List<JSON2DSources> sources); }### Answer: @Test public void setDistances() { distancesMatrixResponse.setDistances(new Double[][]{{1.0, 2.0, 3.0},{1.0, 2.0, 3.0},{1.0, 2.0, 3.0}}); Assert.assertEquals(3, distancesMatrixResponse.getDistances().length); Assert.assertArrayEquals(new Double[]{1.0, 2.0, 3.0}, distancesMatrixResponse.getDistances()[0]); Assert.assertNull(durationsMatrixResponse.getDistances()); }
### Question: JSONIndividualMatrixResponse extends JSONBasedIndividualMatrixResponse { public Double[][] getDurations() { return durations; } JSONIndividualMatrixResponse(MatrixResult result, MatrixRequest request); Double[][] getDurations(); List<JSON2DDestinations> getDestinations(); List<JSON2DSources> getSources(); Double[][] getDistances(); void setDistances(Double[][] distances); void setDurations(Double[][] durations); void setDestinations(List<JSON2DDestinations> destinations); void setSources(List<JSON2DSources> sources); }### Answer: @Test public void getDurations() { Assert.assertEquals(3, durationsMatrixResponse.getDurations().length); Assert.assertArrayEquals(new Double[]{0.0, 1.0, 2.0}, durationsMatrixResponse.getDurations()[0]); Assert.assertNull(distancesMatrixResponse.getDurations()); Assert.assertArrayEquals(new Double[]{3.0,4.0,5.0}, combinedMatrixResponse.getDurations()[1]); }
### Question: JSONIndividualMatrixResponse extends JSONBasedIndividualMatrixResponse { public void setDurations(Double[][] durations) { this.durations = durations; } JSONIndividualMatrixResponse(MatrixResult result, MatrixRequest request); Double[][] getDurations(); List<JSON2DDestinations> getDestinations(); List<JSON2DSources> getSources(); Double[][] getDistances(); void setDistances(Double[][] distances); void setDurations(Double[][] durations); void setDestinations(List<JSON2DDestinations> destinations); void setSources(List<JSON2DSources> sources); }### Answer: @Test public void setDurations() { durationsMatrixResponse.setDurations(new Double[][]{{1.0, 2.0, 3.0},{1.0, 2.0, 3.0},{1.0, 2.0, 3.0}}); Assert.assertEquals(3, durationsMatrixResponse.getDurations().length); Assert.assertArrayEquals(new Double[]{1.0, 2.0, 3.0}, durationsMatrixResponse.getDurations()[0]); Assert.assertNull(distancesMatrixResponse.getDurations()); }
### Question: JSONIndividualMatrixResponse extends JSONBasedIndividualMatrixResponse { public List<JSON2DDestinations> getDestinations() { return destinations; } JSONIndividualMatrixResponse(MatrixResult result, MatrixRequest request); Double[][] getDurations(); List<JSON2DDestinations> getDestinations(); List<JSON2DSources> getSources(); Double[][] getDistances(); void setDistances(Double[][] distances); void setDurations(Double[][] durations); void setDestinations(List<JSON2DDestinations> destinations); void setSources(List<JSON2DSources> sources); }### Answer: @Test public void getDestinations() { Assert.assertEquals(3, distancesMatrixResponse.getDestinations().size()); Assert.assertArrayEquals(new Double[]{8.681495, 49.41461}, distancesMatrixResponse.getDestinations().get(0).getLocation()); }
### Question: JSONIndividualMatrixResponse extends JSONBasedIndividualMatrixResponse { public void setDestinations(List<JSON2DDestinations> destinations) { this.destinations = destinations; } JSONIndividualMatrixResponse(MatrixResult result, MatrixRequest request); Double[][] getDurations(); List<JSON2DDestinations> getDestinations(); List<JSON2DSources> getSources(); Double[][] getDistances(); void setDistances(Double[][] distances); void setDurations(Double[][] durations); void setDestinations(List<JSON2DDestinations> destinations); void setSources(List<JSON2DSources> sources); }### Answer: @Test public void setDestinations() { Coordinate coordinate = new Coordinate(9.681495, 50.41461); ResolvedLocation resolvedLocation = new ResolvedLocation(coordinate, "foo", 0.0); List<JSON2DDestinations> json2DDestinations = new ArrayList<>(); JSON2DDestinations json2DDestination = new JSON2DDestinations(resolvedLocation, false); json2DDestinations.add(json2DDestination); durationsMatrixResponse.setDestinations(json2DDestinations); distancesMatrixResponse.setDestinations(json2DDestinations); Assert.assertEquals(1, durationsMatrixResponse.getDestinations().size()); Assert.assertArrayEquals(new Double[]{9.681495, 50.41461}, durationsMatrixResponse.getDestinations().get(0).getLocation()); Assert.assertEquals(1, distancesMatrixResponse.getDestinations().size()); Assert.assertArrayEquals(new Double[]{9.681495, 50.41461}, distancesMatrixResponse.getDestinations().get(0).getLocation()); }
### Question: JSONIndividualMatrixResponse extends JSONBasedIndividualMatrixResponse { public List<JSON2DSources> getSources() { return sources; } JSONIndividualMatrixResponse(MatrixResult result, MatrixRequest request); Double[][] getDurations(); List<JSON2DDestinations> getDestinations(); List<JSON2DSources> getSources(); Double[][] getDistances(); void setDistances(Double[][] distances); void setDurations(Double[][] durations); void setDestinations(List<JSON2DDestinations> destinations); void setSources(List<JSON2DSources> sources); }### Answer: @Test public void getSources() { Assert.assertEquals(3, durationsMatrixResponse.getSources().size()); Assert.assertArrayEquals(new Double[]{8.681495, 49.41461}, durationsMatrixResponse.getSources().get(0).getLocation()); }
### Question: JSONIndividualMatrixResponse extends JSONBasedIndividualMatrixResponse { public void setSources(List<JSON2DSources> sources) { this.sources = sources; } JSONIndividualMatrixResponse(MatrixResult result, MatrixRequest request); Double[][] getDurations(); List<JSON2DDestinations> getDestinations(); List<JSON2DSources> getSources(); Double[][] getDistances(); void setDistances(Double[][] distances); void setDurations(Double[][] durations); void setDestinations(List<JSON2DDestinations> destinations); void setSources(List<JSON2DSources> sources); }### Answer: @Test public void setSources() { Coordinate coordinate = new Coordinate(9.681495, 50.41461); ResolvedLocation resolvedLocation = new ResolvedLocation(coordinate, "foo", 0.0); List<JSON2DSources> json2DSources = new ArrayList<>(); JSON2DSources json2DSource = new JSON2DSources(resolvedLocation, false); json2DSources.add(json2DSource); durationsMatrixResponse.setSources(json2DSources); distancesMatrixResponse.setSources(json2DSources); Assert.assertEquals(1, durationsMatrixResponse.getSources().size()); Assert.assertArrayEquals(new Double[]{9.681495, 50.41461}, durationsMatrixResponse.getSources().get(0).getLocation()); Assert.assertEquals(1, distancesMatrixResponse.getSources().size()); Assert.assertArrayEquals(new Double[]{9.681495, 50.41461}, distancesMatrixResponse.getSources().get(0).getLocation()); }
### Question: JSON2DDestinations extends JSONLocation { @Override public Double[] getLocation() { Double[] location2D = new Double[2]; location2D[0] = FormatUtility.roundToDecimals(location.x, COORDINATE_DECIMAL_PLACES); location2D[1] = FormatUtility.roundToDecimals(location.y, COORDINATE_DECIMAL_PLACES); return location2D; } JSON2DDestinations(ResolvedLocation destination, boolean includeResolveLocations); @Override Double[] getLocation(); }### Answer: @Test public void getLocation() { JSON2DDestinations json2DDestinationsWithLocation = new JSON2DDestinations(resolvedLocation, true); JSON2DDestinations json2DDestinationsWoLocation = new JSON2DDestinations(resolvedLocation, false); Assert.assertArrayEquals(new Double[]{8.681495, 49.41461}, json2DDestinationsWithLocation.getLocation()); Assert.assertArrayEquals(new Double[]{8.681495, 49.41461}, json2DDestinationsWoLocation.getLocation()); }
### Question: JSON2DSources extends JSONLocation { @Override public Double[] getLocation() { Double[] location2D = new Double[2]; location2D[0] = FormatUtility.roundToDecimals(location.x, COORDINATE_DECIMAL_PLACES); location2D[1] = FormatUtility.roundToDecimals(location.y, COORDINATE_DECIMAL_PLACES); return location2D; } JSON2DSources(ResolvedLocation source, boolean includeResolveLocations); @Override Double[] getLocation(); }### Answer: @Test public void getLocation() { JSON2DSources json2DSourcesWithLocation = new JSON2DSources(resolvedLocation, true); JSON2DSources json2DSourcesWoLocation = new JSON2DSources(resolvedLocation, false); Assert.assertArrayEquals(new Double[]{8.681495, 49.41461}, json2DSourcesWithLocation.getLocation()); Assert.assertArrayEquals(new Double[]{8.681495, 49.41461}, json2DSourcesWoLocation.getLocation()); }
### Question: MatrixResponseInfo { public String getAttribution() { return attribution; } MatrixResponseInfo(MatrixRequest request); void setGraphDate(String graphDate); String getAttribution(); String getOsmFileMD5Hash(); String getService(); long getTimeStamp(); MatrixRequest getRequest(); EngineInfo getEngineInfo(); }### Answer: @Test public void getAttributionTest() { Assert.assertEquals(MatrixResponseInfo.class, responseInformation.getClass()); Assert.assertEquals(String.class, responseInformation.getAttribution().getClass()); }
### Question: MatrixResponseInfo { public String getService() { return service; } MatrixResponseInfo(MatrixRequest request); void setGraphDate(String graphDate); String getAttribution(); String getOsmFileMD5Hash(); String getService(); long getTimeStamp(); MatrixRequest getRequest(); EngineInfo getEngineInfo(); }### Answer: @Test public void getServiceTest() { Assert.assertEquals("matrix", responseInformation.getService()); }
### Question: MatrixResponseInfo { public long getTimeStamp() { return timeStamp; } MatrixResponseInfo(MatrixRequest request); void setGraphDate(String graphDate); String getAttribution(); String getOsmFileMD5Hash(); String getService(); long getTimeStamp(); MatrixRequest getRequest(); EngineInfo getEngineInfo(); }### Answer: @Test public void getTimeStampTest() { Assert.assertTrue(Long.toString(responseInformation.getTimeStamp()).length() > 0); }
### Question: MatrixResponseInfo { public MatrixRequest getRequest() { return request; } MatrixResponseInfo(MatrixRequest request); void setGraphDate(String graphDate); String getAttribution(); String getOsmFileMD5Hash(); String getService(); long getTimeStamp(); MatrixRequest getRequest(); EngineInfo getEngineInfo(); }### Answer: @Test public void getRequestTest() { Assert.assertEquals(bareMatrixRequest, responseInformation.getRequest()); }
### Question: MatrixResponseInfo { public EngineInfo getEngineInfo() { return engineInfo; } MatrixResponseInfo(MatrixRequest request); void setGraphDate(String graphDate); String getAttribution(); String getOsmFileMD5Hash(); String getService(); long getTimeStamp(); MatrixRequest getRequest(); EngineInfo getEngineInfo(); }### Answer: @Test public void getEngineInfoTest() { Assert.assertNotNull(responseInformation.getEngineInfo()); }
### Question: IsochronesResponse { public IsochronesResponseInfo getResponseInformation() { return responseInformation; } IsochronesResponse(IsochronesRequest request); IsochronesResponseInfo getResponseInformation(); BoundingBox getBbox(); }### Answer: @Test public void getResponseInformation() { }
### Question: ResolverQueryOrderBy implements OrderByResolver<Query, Query> { @Override public Query resolve(OrderByClause orderByClause, Query target) { switch (orderByClause.getOrderByMode()) { case ORDER_BY_CHILD: if (orderByClause.getArgument() == null) { throw new IllegalArgumentException(MISSING_ARGUMENT); } return target.orderByChild(orderByClause.getArgument()); case ORDER_BY_KEY: return target.orderByKey(); case ORDER_BY_VALUE: return target.orderByValue(); default: throw new IllegalStateException(); } } @Override Query resolve(OrderByClause orderByClause, Query target); }### Answer: @Test public void resolve_orderByChild() { OrderByClause orderByClause = new OrderByClause(); orderByClause.setOrderByMode(OrderByMode.ORDER_BY_CHILD); orderByClause.setArgument("test_argument"); Query query = PowerMockito.mock(Query.class); ResolverQueryOrderBy resolver = new ResolverQueryOrderBy(); resolver.resolve(orderByClause, query); Mockito.verify(query, VerificationModeFactory.times(1)).orderByChild(Mockito.eq("test_argument")); } @Test(expected = IllegalArgumentException.class) public void resolve_orderByChild_withoutArgument() { OrderByClause orderByClause = new OrderByClause(); orderByClause.setOrderByMode(OrderByMode.ORDER_BY_CHILD); Query query = PowerMockito.mock(Query.class); ResolverQueryOrderBy resolver = new ResolverQueryOrderBy(); resolver.resolve(orderByClause, query); Mockito.verify(query, VerificationModeFactory.times(1)).orderByChild(Mockito.eq("test_argument")); } @Test public void resolve_orderByKey() { OrderByClause orderByClause = new OrderByClause(); orderByClause.setOrderByMode(OrderByMode.ORDER_BY_KEY); Query query = PowerMockito.mock(Query.class); ResolverQueryOrderBy resolver = new ResolverQueryOrderBy(); resolver.resolve(orderByClause, query); Mockito.verify(query, VerificationModeFactory.times(1)).orderByKey(); } @Test public void resolve_orderByValue() { OrderByClause orderByClause = new OrderByClause(); orderByClause.setOrderByMode(OrderByMode.ORDER_BY_VALUE); Query query = PowerMockito.mock(Query.class); ResolverQueryOrderBy resolver = new ResolverQueryOrderBy(); resolver.resolve(orderByClause, query); Mockito.verify(query, VerificationModeFactory.times(1)).orderByValue(); }
### Question: Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithToken(String token) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithCustomToken(token))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); }### Answer: @Test public void signInWithToken() { Auth auth = new Auth(); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.doReturn(task).when(firebaseAuth).signInWithCustomToken(Mockito.anyString()); auth.signInWithToken("token") .then(consumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(2)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signInWithCustomToken(Mockito.eq("token")); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).getCurrentUser(); Mockito.verify(task, VerificationModeFactory.times(1)).addOnCompleteListener(Mockito.any(OnCompleteListener.class)); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any(GdxFirebaseUser.class)); } @Test public void signInWithToken_fail() { Auth auth = new Auth(); BiConsumer biConsumer = Mockito.mock(BiConsumer.class); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(task.getException()).thenReturn(new Exception()); Mockito.doReturn(task).when(firebaseAuth).signInWithCustomToken(Mockito.anyString()); auth.signInWithToken("token") .fail(biConsumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signInWithCustomToken(Mockito.eq("token")); Mockito.verify(task, VerificationModeFactory.times(1)).addOnCompleteListener(Mockito.any(OnCompleteListener.class)); Mockito.verify(biConsumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.any(Exception.class)); }
### Question: Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInAnonymously() { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInAnonymously())); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); }### Answer: @Test public void signInAnonymously() { Auth auth = new Auth(); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.doReturn(task).when(firebaseAuth).signInAnonymously(); auth.signInAnonymously() .then(consumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(2)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signInAnonymously(); Mockito.verify(task, VerificationModeFactory.times(1)).addOnCompleteListener(Mockito.any(OnCompleteListener.class)); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any(GdxFirebaseUser.class)); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).getCurrentUser(); } @Test public void signInAnonymously_fail() { Auth auth = new Auth(); BiConsumer biConsumer = Mockito.mock(BiConsumer.class); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(task.getException()).thenReturn(new Exception()); Mockito.doReturn(task).when(firebaseAuth).signInAnonymously(); auth.signInAnonymously() .fail(biConsumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signInAnonymously(); Mockito.verify(task, VerificationModeFactory.times(1)).addOnCompleteListener(Mockito.any(OnCompleteListener.class)); Mockito.verify(biConsumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.any(Exception.class)); }
### Question: Auth implements AuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(FuturePromise<Void> promise) { try { FirebaseAuth.getInstance().signOut(); promise.doComplete(null); } catch (Exception e) { promise.doFail(e); } } }); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); }### Answer: @Test public void signOut() { Auth auth = new Auth(); Consumer consumer = Mockito.mock(Consumer.class); auth.signOut().then(consumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signOut(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } @Test public void signOut_fail() { Auth auth = new Auth(); BiConsumer biConsumer = Mockito.mock(BiConsumer.class); Mockito.doThrow(new RuntimeException()).when(firebaseAuth).signOut(); auth.signOut().fail(biConsumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signOut(); Mockito.verify(biConsumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.any(Exception.class)); }
### Question: Auth implements AuthDistribution { @Override public Promise<Void> sendPasswordResetEmail(final String email) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> promise) { FirebaseAuth.getInstance().sendPasswordResetEmail(email) .addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { promise.doComplete(null); } else { promise.doFail(task.getException()); } } }); } }); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); }### Answer: @Test public void sendPasswordResetEmail() { Auth auth = new Auth(); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.doReturn(task).when(firebaseAuth).sendPasswordResetEmail(Mockito.anyString()); String arg1 = "email"; auth.sendPasswordResetEmail(arg1).then(consumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).sendPasswordResetEmail(Mockito.eq(arg1)); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } @Test public void sendPasswordResetEmail_fail() { Auth auth = new Auth(); BiConsumer biConsumer = Mockito.mock(BiConsumer.class); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(task.getException()).thenReturn(new Exception()); Mockito.doReturn(task).when(firebaseAuth).sendPasswordResetEmail(Mockito.anyString()); String arg1 = "email"; auth.sendPasswordResetEmail(arg1).fail(biConsumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).sendPasswordResetEmail(Mockito.eq(arg1)); Mockito.verify(biConsumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.any(Exception.class)); }
### Question: ProviderQueryFiltering extends SortingFilteringProvider<Query, ResolverQueryFilter, ResolverQueryOrderBy> { @Override public ResolverQueryFilter createFilterResolver() { return new ResolverQueryFilter(); } @Override ResolverQueryFilter createFilterResolver(); @Override ResolverQueryOrderBy createOrderByResolver(); }### Answer: @Test public void createFilterResolver() { ProviderQueryFiltering provider = new ProviderQueryFiltering(); Object result = provider.createFilterResolver(); Assert.assertNotNull(result); }
### Question: ProviderQueryFiltering extends SortingFilteringProvider<Query, ResolverQueryFilter, ResolverQueryOrderBy> { @Override public ResolverQueryOrderBy createOrderByResolver() { return new ResolverQueryOrderBy(); } @Override ResolverQueryFilter createFilterResolver(); @Override ResolverQueryOrderBy createOrderByResolver(); }### Answer: @Test public void createOrderByResolver() { ProviderQueryFiltering provider = new ProviderQueryFiltering(); Object result = provider.createOrderByResolver(); Assert.assertNotNull(result); }
### Question: QueryCompletionListener implements DatabaseReference.CompletionListener { @Override public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) { if (promise == null) return; if (databaseError != null) { promise.doFail(databaseError.toException()); } else { promise.doComplete(null); } } QueryCompletionListener(FuturePromise promise); @Override void onComplete(DatabaseError databaseError, DatabaseReference databaseReference); }### Answer: @Test public void onComplete_withoutError() { DatabaseError databaseError = null; DatabaseReference databaseReference = Mockito.mock(DatabaseReference.class); FuturePromise promise = Mockito.spy(FuturePromise.class); QueryCompletionListener listener = new QueryCompletionListener(promise); listener.onComplete(databaseError, databaseReference); Mockito.verify(promise, VerificationModeFactory.times(1)).doComplete(Mockito.any()); } @Test public void onComplete_error() { DatabaseError databaseError = Mockito.mock(DatabaseError.class); DatabaseReference databaseReference = Mockito.mock(DatabaseReference.class); FuturePromise promise = Mockito.spy(FuturePromise.class); promise.silentFail(); QueryCompletionListener listener = new QueryCompletionListener(promise); listener.onComplete(databaseError, databaseReference); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.nullable(Exception.class)); }
### Question: ResolverDataSnapshotList { @SuppressWarnings("unchecked") static List resolve(DataSnapshot dataSnapshot) { if (dataSnapshot.getValue() == null) { throw new IllegalStateException(); } List result = new ArrayList<>(); Iterable<DataSnapshot> dataSnapshots; for (Object o : dataSnapshot.getChildren()) { if (o instanceof DataSnapshot) { result.add(((DataSnapshot) o).getValue()); } else { result.add(o); } } return result; } private ResolverDataSnapshotList(); }### Answer: @Test public void resolve() { DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); DataSnapshot dataSnapshot2 = Mockito.mock(DataSnapshot.class); DataSnapshot dataSnapshot3 = Mockito.mock(DataSnapshot.class); ArrayList list = new ArrayList(); list.add(dataSnapshot2); list.add(dataSnapshot3); Mockito.when(dataSnapshot.getChildren()).thenReturn(list); Mockito.when(dataSnapshot.getValue()).thenReturn(list); List result = ResolverDataSnapshotList.resolve(dataSnapshot); Assert.assertEquals(2, result.size()); Mockito.verify(dataSnapshot2, VerificationModeFactory.times(1)).getValue(); Mockito.verify(dataSnapshot3, VerificationModeFactory.times(1)).getValue(); }
### Question: ResolverDataSnapshotList { static boolean shouldResolveOrderBy(Class<?> dataType, DataSnapshot dataSnapshot) { return (ClassReflection.isAssignableFrom(List.class, dataType) \|\| ClassReflection.isAssignableFrom(Map.class, dataType)) && dataSnapshot.getChildrenCount() > 0; } private ResolverDataSnapshotList(); }### Answer: @Test public void shouldResolveOrderBy() { Class dataType = List.class; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); Mockito.when(dataSnapshot.getChildrenCount()).thenReturn(1L); boolean should = ResolverDataSnapshotList.shouldResolveOrderBy(dataType, dataSnapshot); Assert.assertTrue(should); } @Test public void shouldResolveOrderBy3() { Class dataType = String.class; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); Mockito.when(dataSnapshot.getChildrenCount()).thenReturn(1L); boolean should = ResolverDataSnapshotList.shouldResolveOrderBy(dataType, dataSnapshot); Assert.assertFalse(should); } @Test public void shouldResolveOrderBy4() { Class dataType = String.class; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); Mockito.when(dataSnapshot.getChildrenCount()).thenReturn(0L); boolean should = ResolverDataSnapshotList.shouldResolveOrderBy(dataType, dataSnapshot); Assert.assertFalse(should); }
### Question: QueryOnDataChange extends AndroidDatabaseQuery<R> { @Override protected ArgumentsValidator createArgumentsValidator() { return new OnDataValidator(); } QueryOnDataChange(Database databaseDistribution, String databasePath); }### Answer: @Test public void createArgumentsValidator() { Database databaseDistribution = Mockito.mock(Database.class); QueryOnDataChange queryOnDataChange = new QueryOnDataChange(databaseDistribution, "/test"); ArgumentsValidator argumentsValidator = queryOnDataChange.createArgumentsValidator(); Assert.assertNotNull(argumentsValidator); Assert.assertTrue(argumentsValidator instanceof OnDataValidator); }
### Question: QueryOnDataChange extends AndroidDatabaseQuery<R> { @Override @SuppressWarnings("unchecked") protected R run() { SnapshotValueListener dataChangeListener = new SnapshotValueListener((Class) arguments.get(0), (ConverterPromise) promise); filtersProvider.applyFiltering().addValueEventListener(dataChangeListener); ((FutureListenerPromise) promise).onCancel(new CancelListenerAction(dataChangeListener, query)); return null; } QueryOnDataChange(Database databaseDistribution, String databasePath); }### Answer: @Test public void run() { final Database databaseDistribution = Mockito.spy(Database.class); final DatabaseReference databaseReference = Mockito.mock(DatabaseReference.class); Mockito.when(firebaseDatabase.getReference(Mockito.anyString())).thenReturn(databaseReference); Mockito.when(databaseDistribution.inReference(Mockito.anyString())).thenCallRealMethod(); final QueryOnDataChange queryOnDataChange = new QueryOnDataChange(databaseDistribution, "/test"); final ConverterPromise promise = Mockito.spy(ConverterPromise.class); databaseDistribution.inReference("/test"); queryOnDataChange.with(promise).withArgs(Map.class).execute(); Mockito.verify(databaseReference, VerificationModeFactory.times(1)).addValueEventListener(Mockito.any(ValueEventListener.class)); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public ListenerPromise<ConnectionStatus> onConnect() { return FutureListenerPromise.whenListener(new Consumer<FutureListenerPromise<ConnectionStatus>>() { @Override public void accept(FutureListenerPromise<ConnectionStatus> promise) { new QueryConnectionStatus(Database.this, getDatabasePath()) .with(promise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void onConnect() throws Exception { PowerMockito.mockStatic(QueryConnectionStatus.class); Database database = new Database(); QueryConnectionStatus query = Mockito.spy(new QueryConnectionStatus(database, "/test")); PowerMockito.whenNew(QueryConnectionStatus.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); database.onConnect().subscribe(); PowerMockito.verifyNew(QueryConnectionStatus.class); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution inReference(String databasePath) { databaseReference = FirebaseDatabase.getInstance().getReference(databasePath); this.databasePath = databasePath; return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void inReference() { Database database = Mockito.spy(new Database()); database.inReference("test"); DatabaseReference reference = Whitebox.getInternalState(database, "databaseReference"); String path = Whitebox.getInternalState(database, "databasePath"); Assert.assertEquals("test", path); Assert.assertNotNull(reference); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> setValue(final Object value) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QuerySetValue(Database.this, getDatabasePath()) .withArgs(value) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void setValue() throws Exception { PowerMockito.mockStatic(QuerySetValue.class); Database database = new Database(); QuerySetValue query = PowerMockito.spy(new QuerySetValue(database, "/test")); PowerMockito.whenNew(QuerySetValue.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); Promise promise = Mockito.spy(database.inReference("/test").setValue("").subscribe()); PowerMockito.verifyNew(QuerySetValue.class); } @Test(expected = DatabaseReferenceNotSetException.class) public void databaseReference2() { Database database = new Database(); database.setValue("test"); Assert.fail(); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, E extends T> Promise<E> readValue(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, E>>(this) { @Override public void accept(ConverterPromise<T, E> teConverterPromise) { teConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryReadValue(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .withArgs(dataType) .with(teConverterPromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void readValue() throws Exception { PowerMockito.mockStatic(QueryReadValue.class); Database database = new Database(); QueryReadValue query = Mockito.spy(new QueryReadValue(database, "/test")); PowerMockito.whenNew(QueryReadValue.class).withAnyArguments().thenReturn(query); database.inReference("/test").readValue(String.class).subscribe(); PowerMockito.verifyNew(QueryReadValue.class); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> ListenerPromise<R> onDataChange(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, R>>(this) { @Override public void accept(ConverterPromise<T, R> trConverterPromise) { trConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryOnDataChange(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .with(trConverterPromise) .withArgs(dataType) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void onDataChange() throws Exception { PowerMockito.mockStatic(QueryOnDataChange.class); QueryOnDataChange query = PowerMockito.mock(QueryOnDataChange.class); PowerMockito.whenNew(QueryOnDataChange.class).withAnyArguments().thenReturn(query); when(query.with(Mockito.nullable(Array.class))).thenReturn(query); when(query.with(Mockito.nullable(OrderByClause.class))).thenReturn(query); when(query.withArgs(Mockito.any(), Mockito.any())).thenReturn(query); Database database = new Database(); database.inReference("/test").onDataChange(Map.class).subscribe(); PowerMockito.verifyNew(QueryOnDataChange.class); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <V> DatabaseDistribution filter(FilterType filterType, V... filterArguments) { filters.add(new Filter(filterType, filterArguments)); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void filter() { Database database = new Database(); database.filter(FilterType.LIMIT_FIRST, 2) .filter(FilterType.EQUAL_TO, 3); Assert.assertEquals(FilterType.LIMIT_FIRST, ((Array<Filter>) Whitebox.getInternalState(database, "filters")).get(0).getFilterType()); Assert.assertEquals(FilterType.EQUAL_TO, ((Array<Filter>) Whitebox.getInternalState(database, "filters")).get(1).getFilterType()); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution orderBy(OrderByMode orderByMode, String argument) { orderByClause = new OrderByClause(orderByMode, argument); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void orderBy() { Database database = new Database(); database.orderBy(OrderByMode.ORDER_BY_KEY, "test"); Assert.assertEquals(OrderByMode.ORDER_BY_KEY, ((OrderByClause) Whitebox.getInternalState(database, "orderByClause")).getOrderByMode()); Assert.assertEquals("test", ((OrderByClause) Whitebox.getInternalState(database, "orderByClause")).getArgument()); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution push() { databaseReference = databaseReference().push(); databasePath = databasePath + "/" + databaseReference.getKey(); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void push() { Database database = new Database(); when(databaseReference.push()).thenReturn(databaseReference); database.inReference("/test").push(); Mockito.verify(databaseReference, VerificationModeFactory.times(1)).push(); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> removeValue() { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRemoveValue(Database.this, getDatabasePath()) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void removeValue() throws Exception { PowerMockito.mockStatic(QueryRemoveValue.class); Database database = new Database(); QueryRemoveValue query = PowerMockito.mock(QueryRemoveValue.class); PowerMockito.whenNew(QueryRemoveValue.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); Promise promise = Mockito.spy(database.inReference("/test").removeValue()); PowerMockito.verifyNew(QueryRemoveValue.class); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> updateChildren(final Map<String, Object> data) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryUpdateChildren(Database.this, getDatabasePath()) .withArgs(data) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void updateChildren() throws Exception { PowerMockito.mockStatic(QueryUpdateChildren.class); Database database = new Database(); QueryUpdateChildren query = PowerMockito.spy(new QueryUpdateChildren(database, "/test")); PowerMockito.whenNew(QueryUpdateChildren.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); Map data = Mockito.mock(Map.class); database.inReference("/test").updateChildren(data); PowerMockito.verifyNew(QueryUpdateChildren.class); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRunTransaction(Database.this, getDatabasePath()) .withArgs(dataType, transaction) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void transaction() throws Exception { PowerMockito.mockStatic(QueryRunTransaction.class); Database database = new Database(); QueryRunTransaction query = PowerMockito.mock(QueryRunTransaction.class); PowerMockito.whenNew(QueryRunTransaction.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); Function transactionFunction = Mockito.mock(Function.class); Class dataType = String.class; database.inReference("/test").transaction(dataType, transactionFunction); PowerMockito.verifyNew(QueryRunTransaction.class); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public void setPersistenceEnabled(boolean enabled) { FirebaseDatabase.getInstance().setPersistenceEnabled(enabled); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void setPersistenceEnabled() { Database database = new Database(); database.setPersistenceEnabled(true); Mockito.verify(firebaseDatabase, VerificationModeFactory.times(1)).setPersistenceEnabled(Mockito.eq(true)); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public void keepSynced(boolean synced) { databaseReference().keepSynced(synced); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void keepSynced() { Database database = new Database(); database.inReference("/test").keepSynced(true); Mockito.verify(databaseReference, VerificationModeFactory.times(1)).keepSynced(Mockito.eq(true)); }
### Question: Database implements DatabaseDistribution, QueryProvider { DatabaseReference databaseReference() { checkDatabaseReference(); return databaseReference; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test(expected = DatabaseReferenceNotSetException.class) public void databaseReference() { Database database = new Database(); database.keepSynced(true); Assert.fail(); }
### Question: Database implements DatabaseDistribution, QueryProvider { @Override public void terminateOperation() { databaseReference = null; databasePath = null; orderByClause = null; filters.clear(); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); }### Answer: @Test public void terminateOperation() { Database database = new Database(); database.inReference("test").filter(FilterType.LIMIT_FIRST, 2).orderBy(OrderByMode.ORDER_BY_KEY, "test"); database.terminateOperation(); Assert.assertNull(Whitebox.getInternalState(database, "databaseReference")); Assert.assertNull(Whitebox.getInternalState(database, "databasePath")); Assert.assertNull(Whitebox.getInternalState(database, "orderByClause")); Assert.assertEquals(0, ((Array) Whitebox.getInternalState(database, "filters")).size); }
### Question: TransactionHandler implements Transaction.Handler { @Override @SuppressWarnings("unchecked") public Transaction.Result doTransaction(MutableData mutableData) { try { if (mutableData.getValue() == null) { mutableData.setValue(transactionFunction.apply((R) DefaultTypeRecognizer.getDefaultValue(dataType))); return Transaction.success(mutableData); } MapConversion mapConversionAnnotation = null; R transactionData; if (promise.getThenConsumer() != null) { mapConversionAnnotation = AnnotationFinder.getMethodAnnotation(MapConversion.class, promise.getThenConsumer()); } if (mapConversionAnnotation != null) { transactionData = (R) mutableData.getValue(mapConversionAnnotation.value()); } else { transactionData = (R) mutableData.getValue(); } mutableData.setValue(transactionFunction.apply(transactionData)); return Transaction.success(mutableData); } catch (Exception e) { GdxFIRLogger.error(TRANSACTION_ERROR, e); return Transaction.abort(); } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); }### Answer: @Test public void doTransaction() { Function transactionFunction = Mockito.mock(Function.class); FuturePromise promise = Mockito.mock(FuturePromise.class); TransactionHandler transactionHandler = new TransactionHandler(Long.class, transactionFunction, promise); MutableData mutableData = Mockito.mock(MutableData.class); Mockito.when(mutableData.getValue()).thenReturn("test_value"); transactionHandler.doTransaction(mutableData); PowerMockito.verifyStatic(Transaction.class, VerificationModeFactory.times(1)); Transaction.success(Mockito.nullable(MutableData.class)); }
### Question: App implements AppDistribution { @Override public void configure() { } @Override void configure(); }### Answer: @Test public void configure() { GdxFIRApp.instance().configure(); }
### Question: Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); }### Answer: @Test public void logEvent() { Analytics analytics = new Analytics(); analytics.logEvent("test", new HashMap<String, String>()); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)).logEvent(Mockito.eq("test"), Mockito.any(Bundle.class)); Mockito.verifyNoMoreInteractions(firebaseAnalytics); } @Test public void logEvent_withParams() { Analytics analytics = new Analytics(); Map<String, String> params = new HashMap<>(); params.put("param_string", "lorem ipsum"); params.put("param_string_starting_with_number", "12:00 hour"); params.put("param_number_int", "15"); params.put("param_number_float", "15.54"); analytics.logEvent("test", params); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)).logEvent(Mockito.eq("test"), Mockito.any(Bundle.class)); Mockito.verifyNoMoreInteractions(firebaseAnalytics); }
### Question: Analytics implements AnalyticsDistribution { @Override public void setScreen(final String name, final Class<?> screenClass) { ((AndroidApplication) Gdx.app).runOnUiThread(new Runnable() { @Override public void run() { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setCurrentScreen((AndroidApplication) Gdx.app, name, screenClass.getSimpleName()); } }); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); }### Answer: @Test public void setScreen() { Analytics analytics = new Analytics(); Mockito.doAnswer(new Answer() { @Override public Object answer(InvocationOnMock invocation) { ((Runnable) invocation.getArgument(0)).run(); return null; } }).when(((AndroidApplication) Gdx.app)).runOnUiThread(Mockito.any(Runnable.class)); analytics.setScreen("test", AnalyticsTest.class); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)) .setCurrentScreen(Mockito.eq((Activity) Gdx.app), Mockito.eq("test"), Mockito.eq(AnalyticsTest.class.getSimpleName())); Mockito.verifyNoMoreInteractions(firebaseAnalytics); }
### Question: Analytics implements AnalyticsDistribution { @Override public void setUserProperty(String name, String value) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserProperty(name, value); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); }### Answer: @Test public void setUserProperty() { Analytics analytics = new Analytics(); analytics.setUserProperty("test_name", "test_value"); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)) .setUserProperty(Mockito.eq("test_name"), Mockito.eq("test_value")); Mockito.verifyNoMoreInteractions(firebaseAnalytics); }
### Question: Analytics implements AnalyticsDistribution { @Override public void setUserId(String id) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserId(id); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); }### Answer: @Test public void setUserId() { Analytics analytics = new Analytics(); analytics.setUserId("test"); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)) .setUserId(Mockito.eq("test")); Mockito.verifyNoMoreInteractions(firebaseAnalytics); }
### Question: BundleHelper { static void putNumberParam(Bundle bundle, String key, String number) { String[] types = {"int", "long", "double", "float"}; boolean found = false; for (String type : types) { try { if (type.equals("int") && !number.toLowerCase().endsWith("l")) { int value = Integer.parseInt(number); bundle.putInt(key, value); found = true; break; } else if (type.equals("long")) { if (number.toLowerCase().endsWith("l")) { number = number.substring(0, number.length() - 1); } long value = Long.parseLong(number); bundle.putLong(key, value); found = true; break; } else if (type.equals("float")) { float value = Float.parseFloat(number); bundle.putFloat(key, value); found = true; break; } else if (type.equals("double") && !number.toLowerCase().endsWith("f")) { double value = Double.parseDouble(number); bundle.putDouble(key, value); found = true; break; } } catch (NumberFormatException e) { } } if (!found) { throw new IllegalArgumentException(); } } private BundleHelper(); }### Answer: @Test public void putNumberParam() { Bundle bundle = new Bundle(); String intKey = "int"; String intValue = "3"; String longKey = "long"; String longValue = "8L"; String longKey2 = "long2"; String longValue2 = "" + Long.MAX_VALUE; String doubleKey = "double"; String doubleValue = "4.0"; String floatKey = "float"; String floatValue = "2f"; BundleHelper.putNumberParam(bundle, intKey, intValue); BundleHelper.putNumberParam(bundle, longKey, longValue); BundleHelper.putNumberParam(bundle, longKey2, longValue2); BundleHelper.putNumberParam(bundle, floatKey, floatValue); BundleHelper.putNumberParam(bundle, doubleKey, doubleValue); Assert.assertTrue("Integer value should be 3, not " + bundle.getInt(intKey), bundle.getInt(intKey) == 3); Assert.assertTrue("Long value should be 8L, not " + bundle.getLong(longKey), bundle.getLong(longKey) == 8L); Assert.assertTrue("Long value should be " + Long.MAX_VALUE + ", not " + bundle.getLong(longKey2), bundle.getLong(longKey2) == Long.MAX_VALUE); Assert.assertTrue("Float value should be 2f, not " + bundle.getFloat(floatKey), bundle.getFloat(floatKey) == 2f); Assert.assertTrue("Double value should be 4.0, not " + bundle.getDouble(doubleKey), bundle.getDouble(doubleKey) == 4.0); }
### Question: Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); }### Answer: @Test public void upload() { Storage storage = new Storage(); FileHandle fileHandle = Mockito.mock(FileHandle.class); File file = Mockito.mock(File.class); when(fileHandle.file()).thenReturn(file); final UploadTask uploadTask = Mockito.mock(UploadTask.class); final Task task = Mockito.mock(Task.class); final UploadTask.TaskSnapshot taskSnapshot = Mockito.mock(UploadTask.TaskSnapshot.class); StorageMetadata storageMetadata = Mockito.mock(StorageMetadata.class); when(taskSnapshot.getMetadata()).thenReturn(storageMetadata); when(storageMetadata.getPath()).thenReturn("test"); when(storageReference.putFile(Mockito.any(Uri.class))).thenReturn(uploadTask); when(storageReference.getDownloadUrl()).thenReturn(task); when(task.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(Mockito.mock(Uri.class)); return null; } }); when(uploadTask.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(uploadTask); when(uploadTask.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(taskSnapshot); return uploadTask; } }); storage.upload("test", fileHandle).subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).putFile(Mockito.any(Uri.class)); Mockito.verify(uploadTask, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(uploadTask, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } @Test public void upload1() { Storage storage = new Storage(); byte[] data = new byte[]{0, 0, 0, 1, 1, 1}; final UploadTask uploadTask = Mockito.mock(UploadTask.class); when(storageReference.putBytes(Mockito.any(byte[].class))).thenReturn(uploadTask); when(uploadTask.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(uploadTask); when(uploadTask.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(Mockito.mock(UploadTask.TaskSnapshot.class)); return uploadTask; } }); storage.upload("test", data).subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).putBytes(Mockito.any(byte[].class)); Mockito.verify(uploadTask, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(uploadTask, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); }
### Question: TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); }### Answer: @Test public void onComplete_withErrorAndCallback() { Function transactionFunction = Mockito.mock(Function.class); FuturePromise promise = Mockito.mock(FuturePromise.class); TransactionHandler transactionHandler = new TransactionHandler(Long.class, transactionFunction, promise); DatabaseError databaseError = Mockito.mock(DatabaseError.class); DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); boolean status = true; transactionHandler.onComplete(databaseError, status, dataSnapshot); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.nullable(Exception.class)); } @Test public void onComplete_withoutErrorAndWithCallback_statusOk() { Function transactionFunction = Mockito.mock(Function.class); FuturePromise promise = Mockito.mock(FuturePromise.class); TransactionHandler transactionHandler = new TransactionHandler(Long.class, transactionFunction, promise); DatabaseError databaseError = null; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); boolean status = true; transactionHandler.onComplete(databaseError, status, dataSnapshot); Mockito.verify(promise, VerificationModeFactory.times(1)).doComplete(Mockito.nullable(Void.class)); } @Test public void onComplete_withoutErrorAndWithCallback_statusError() { Function transactionFunction = Mockito.mock(Function.class); FuturePromise promise = Mockito.mock(FuturePromise.class); TransactionHandler transactionHandler = new TransactionHandler(Long.class, transactionFunction, promise); DatabaseError databaseError = null; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); boolean status = false; transactionHandler.onComplete(databaseError, status, dataSnapshot); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.anyString(), Mockito.nullable(Throwable.class)); }
### Question: Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); }### Answer: @Test public void delete() { Storage storage = new Storage(); final Task task = Mockito.mock(Task.class); when(storageReference.delete()).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(task); when(task.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(null); return task; } }); long byteLimit = 1000; storage.delete("test").subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).delete(); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } @Test public void delete_failure() { Storage storage = new Storage(); final Task task = Mockito.mock(Task.class); when(storageReference.delete()).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnFailureListener) invocation.getArgument(0)).onFailure(new Exception()); return task; } }); long byteLimit = 1000; storage.delete("test").silentFail().subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).delete(); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); }
### Question: Storage implements StorageDistribution { @Override public StorageDistribution inBucket(String url) { firebaseStorage = FirebaseStorage.getInstance(url); return this; } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); }### Answer: @Test public void inBucket() { Storage storage = new Storage(); storage.inBucket("test"); PowerMockito.verifyStatic(FirebaseStorage.class, VerificationModeFactory.times(1)); FirebaseStorage.getInstance(Mockito.eq("test")); }
### Question: Crash implements CrashDistribution { @Override public void initialize() { initializeOnce(); } @Override void log(String message); @Override void initialize(); }### Answer: @Test public void initialize() { PowerMockito.mockStatic(Crashlytics.class); PowerMockito.mockStatic(Fabric.class); Crash crash = new Crash(); crash.initialize(); crash.initialize(); crash.initialize(); PowerMockito.verifyStatic(Fabric.class, VerificationModeFactory.times(1)); Fabric.with(Mockito.any(AndroidApplication.class), Mockito.any(Crashlytics.class)); PowerMockito.verifyNoMoreInteractions(Fabric.class); }
### Question: Crash implements CrashDistribution { @Override public void log(String message) { initializeOnce(); Crashlytics.log(message); } @Override void log(String message); @Override void initialize(); }### Answer: @Test public void log() { PowerMockito.mockStatic(Crashlytics.class); PowerMockito.mockStatic(Fabric.class); Crash crash = new Crash(); crash.log("abc"); PowerMockito.verifyStatic(Crashlytics.class, VerificationModeFactory.times(1)); Crashlytics.log("abc"); PowerMockito.verifyNoMoreInteractions(Crashlytics.class); }
### Question: User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); }### Answer: @Test(expected = IllegalStateException.class) public void updateEmail_noUser() { User user = new User(); user.updateEmail("test"); Assert.fail(); } @Test public void updateEmail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.updateEmail(Mockito.anyString())).thenReturn(task); String arg1 = "newEmail"; user.updateEmail(arg1).then(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).updateEmail(arg1); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } @Test public void updateEmail_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); BiConsumer consumer = Mockito.mock(BiConsumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.updateEmail(Mockito.anyString())).thenReturn(task); String arg1 = "newEmail"; user.updateEmail(arg1).fail(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).updateEmail(arg1); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); }
### Question: User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); }### Answer: @Test(expected = IllegalStateException.class) public void sendEmailVerification_noUser() { User user = new User(); user.sendEmailVerification(); Assert.fail(); } @Test public void sendEmailVerification() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.sendEmailVerification()).thenReturn(task); user.sendEmailVerification().then(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).sendEmailVerification(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } @Test public void sendEmailVerification_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); BiConsumer consumer = Mockito.mock(BiConsumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.sendEmailVerification()).thenReturn(task); user.sendEmailVerification().fail(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).sendEmailVerification(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); }
### Question: User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); }### Answer: @Test(expected = IllegalStateException.class) public void updatePassword_noUser() { User user = new User(); user.updatePassword(new char[]{'a', 'b'}); Assert.fail(); } @Test public void updatePassword() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.updatePassword(Mockito.anyString())).thenReturn(task); char[] arg1 = {'a', 'b', 'c'}; user.updatePassword(arg1).then(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).updatePassword(Mockito.eq(new String(arg1))); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } @Test public void updatePassword_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); BiConsumer consumer = Mockito.mock(BiConsumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.updatePassword(Mockito.anyString())).thenReturn(task); char[] arg1 = {'a', 'b', 'c'}; user.updatePassword(arg1).fail(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).updatePassword(Mockito.eq(new String(arg1))); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); }
### Question: User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); }### Answer: @Test(expected = IllegalStateException.class) public void delete_noUser() { User user = new User(); user.delete(); Assert.fail(); } @Test public void delete() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.delete()).thenReturn(task); user.delete().then(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).delete(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } @Test public void delete_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); BiConsumer consumer = Mockito.mock(BiConsumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.delete()).thenReturn(task); user.delete().fail(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).delete(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); }
### Question: User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); }### Answer: @Test public void reload() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.reload()).thenReturn(task); user.reload(); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).reload(); } @Test public void reload_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.reload()).thenReturn(task); user.reload(); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).reload(); }
### Question: AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } AuthPromiseConsumer(Task<T> task); @Override void accept(final FuturePromise<GdxFirebaseUser> promise); }### Answer: @Test public void accept() { Mockito.when(task.isSuccessful()).thenReturn(true); FuturePromise promise = Mockito.spy(FuturePromise.empty()); promise.then(Mockito.mock(Consumer.class)).silentFail(); AuthPromiseConsumer authPromiseConsumer = new AuthPromiseConsumer(task); authPromiseConsumer.accept(promise); Mockito.verify(promise, VerificationModeFactory.atLeast(1)).doComplete(Mockito.any()); } @Test public void accept_fail() { Mockito.when(task.isSuccessful()).thenReturn(false); FuturePromise promise = Mockito.spy(FuturePromise.empty()); promise.then(Mockito.mock(Consumer.class)).silentFail(); AuthPromiseConsumer authPromiseConsumer = new AuthPromiseConsumer(task); authPromiseConsumer.accept(promise); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); }
### Question: GoogleAuth implements GoogleAuthDistribution { @Override public Promise<GdxFirebaseUser> signIn() { return FuturePromise.when(new Consumer<FuturePromise<GdxFirebaseUser>>() { @Override public void accept(FuturePromise<GdxFirebaseUser> gdxFirebaseUserFuturePromise) { GoogleSignInOptions gso = GoogleSignInOptionsFactory.factory(); ((AndroidApplication) Gdx.app).addAndroidEventListener(new GoogleSignInListener(gdxFirebaseUserFuturePromise)); ((AndroidApplication) Gdx.app).startActivityForResult( GoogleSignIn.getClient((AndroidApplication) Gdx.app, gso).getSignInIntent(), Const.GOOGLE_SIGN_IN); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); }### Answer: @Test public void signIn() { GoogleAuth googleAuth = new GoogleAuth(); googleAuth.signIn().subscribe(); Mockito.verify(((AndroidApplication) Gdx.app), VerificationModeFactory.times(1)).startActivityForResult(Mockito.nullable(Intent.class), Mockito.anyInt()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); }
### Question: GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); }### Answer: @Test public void signOut_ok() { GoogleAuth googleAuth = new GoogleAuth(); Task task = Mockito.mock(Task.class); final Task task2 = Mockito.mock(Task.class); Mockito.when(task2.isSuccessful()).thenReturn(true); Mockito.when(googleSignInClient.signOut()).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(0)).onComplete(task2); return null; } }); FuturePromise promise = (FuturePromise) spy(googleAuth.signOut().subscribe()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); Mockito.verify(googleSignInClient, VerificationModeFactory.times(1)).signOut(); } @Test public void signOut_fail() { GoogleAuth googleAuth = new GoogleAuth(); Task task = Mockito.mock(Task.class); final Task task2 = Mockito.mock(Task.class); Mockito.when(task2.isSuccessful()).thenReturn(false); Mockito.when(googleSignInClient.signOut()).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(0)).onComplete(task2); return null; } }); FuturePromise promise = (FuturePromise) PowerMockito.spy(googleAuth.signOut().silentFail().subscribe()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); Mockito.verify(googleSignInClient, VerificationModeFactory.times(1)).signOut(); }
### Question: GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); }### Answer: @Test public void revokeAccess_ok() { GoogleAuth googleAuth = new GoogleAuth(); Task task = Mockito.mock(Task.class); final Task task2 = Mockito.mock(Task.class); Mockito.when(task2.isSuccessful()).thenReturn(true); Mockito.when(googleSignInClient.revokeAccess()).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(0)).onComplete(task2); return null; } }); FuturePromise promise = (FuturePromise) spy(googleAuth.revokeAccess().subscribe()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); Mockito.verify(googleSignInClient, VerificationModeFactory.times(1)).revokeAccess(); } @Test public void revokeAccess_fail() { GoogleAuth googleAuth = new GoogleAuth(); Task task = Mockito.mock(Task.class); final Task task2 = Mockito.mock(Task.class); Mockito.when(task2.isSuccessful()).thenReturn(false); Mockito.when(googleSignInClient.revokeAccess()).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(0)).onComplete(task2); return null; } }); FuturePromise promise = (FuturePromise) spy(googleAuth.revokeAccess().silentFail().subscribe()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); Mockito.verify(googleSignInClient, VerificationModeFactory.times(1)).revokeAccess(); }
### Question: StringResource { static String getStringResourceByName(String name) { int id = ((AndroidApplication) Gdx.app).getResources().getIdentifier(name, "string", ((AndroidApplication) Gdx.app).getPackageName()); return ((AndroidApplication) Gdx.app).getResources().getString(id); } private StringResource(); }### Answer: @Test public void getStringResourceByName() { Resources resources = Mockito.mock(Resources.class); String name = "test"; Mockito.when(((AndroidApplication) Gdx.app).getResources()).thenReturn(resources); Mockito.when(resources.getString(Mockito.anyInt())).thenReturn("test_return"); String result = StringResource.getStringResourceByName(name); Assert.assertEquals("test_return", result); }
### Question: Auth implements AuthDistribution { @Override public GdxFirebaseUser getCurrentUser() { FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser(); if (user == null) return null; UserInfo.Builder builder = new UserInfo.Builder(); builder.setDisplayName(user.getDisplayName()) .setPhotoUrl(user.getPhotoUrl() != null ? user.getPhotoUrl().getPath() : null) .setProviderId(user.getProviderId()) .setUid(user.getUid()) .setIsEmailVerified(user.isEmailVerified()) .setIsAnonymous(user.isAnonymous()) .setEmail(user.getEmail()); return GdxFirebaseUser.create(builder.build()); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); }### Answer: @Test public void getCurrentUser() { Auth auth = new Auth(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Mockito.when(firebaseUser.getDisplayName()).thenReturn("display_name"); Mockito.when(firebaseUser.getEmail()).thenReturn("email"); Mockito.when(firebaseUser.getUid()).thenReturn("uid"); Mockito.when(firebaseUser.getProviderId()).thenReturn("provider_id"); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); GdxFirebaseUser user = auth.getCurrentUser(); Assert.assertNotNull(user.getUserInfo()); Assert.assertEquals(user.getUserInfo().getDisplayName(), firebaseUser.getDisplayName()); Assert.assertEquals(user.getUserInfo().getEmail(), firebaseUser.getEmail()); Assert.assertEquals(user.getUserInfo().getUid(), firebaseUser.getUid()); Assert.assertEquals(user.getUserInfo().getProviderId(), firebaseUser.getProviderId()); }
### Question: Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); }### Answer: @Test public void createUserWithEmailAndPassword() { Auth auth = new Auth(); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.doReturn(task).when(firebaseAuth).createUserWithEmailAndPassword(Mockito.anyString(), Mockito.anyString()); Promise promise = auth.createUserWithEmailAndPassword("user", "password".toCharArray()) .then(consumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(2)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).createUserWithEmailAndPassword(Mockito.eq("user"), Mockito.eq("password")); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any(GdxFirebaseUser.class)); } @Test public void createUserWithEmailAndPassword_fail() { Auth auth = new Auth(); BiConsumer biConsumer = Mockito.mock(BiConsumer.class); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(task.getException()).thenReturn(new Exception()); Mockito.doReturn(task).when(firebaseAuth).createUserWithEmailAndPassword(Mockito.anyString(), Mockito.anyString()); auth.createUserWithEmailAndPassword("user", "password".toCharArray()) .fail(biConsumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).createUserWithEmailAndPassword(Mockito.eq("user"), Mockito.eq("password")); Mockito.verify(biConsumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.any(Exception.class)); }
### Question: Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); }### Answer: @Test public void signInWithEmailAndPassword() { Auth auth = new Auth(); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.doReturn(task).when(firebaseAuth).signInWithEmailAndPassword(Mockito.anyString(), Mockito.anyString()); auth.signInWithEmailAndPassword("user", "password".toCharArray()) .then(consumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(2)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signInWithEmailAndPassword(Mockito.eq("user"), Mockito.eq("password")); Mockito.verify(task, VerificationModeFactory.times(1)).addOnCompleteListener(Mockito.any(OnCompleteListener.class)); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).getCurrentUser(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any(GdxFirebaseUser.class)); } @Test public void signInWithEmailAndPassword_fail() { Auth auth = new Auth(); BiConsumer biConsumer = Mockito.mock(BiConsumer.class); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(task.getException()).thenReturn(new Exception()); Mockito.doReturn(task).when(firebaseAuth).signInWithEmailAndPassword(Mockito.anyString(), Mockito.anyString()); auth.signInWithEmailAndPassword("user", "password".toCharArray()) .fail(biConsumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signInWithEmailAndPassword(Mockito.eq("user"), Mockito.eq("password")); Mockito.verify(task, VerificationModeFactory.times(1)).addOnCompleteListener(Mockito.any(OnCompleteListener.class)); Mockito.verify(biConsumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.any(Exception.class)); }
### Question: ProtoFileHandler { public void handle(FileDescriptorProto protoFile) throws IOException { String javaPackage = inferJavaPackage(protoFile); boolean multipleFiles = protoFile.getOptions().getJavaMultipleFiles(); String outerClassName = null; if (!multipleFiles) { if (protoFile.getOptions().hasJavaOuterClassname()) { outerClassName = protoFile.getOptions().getJavaOuterClassname(); } else { outerClassName = inferOuterClassName(protoFile); } } ProtoServiceHandler serviceHandler = new ProtoServiceHandler(javaPackage, types, multipleFiles, outerClassName, protoFile.getPackage(), output); for (ServiceDescriptorProto service : protoFile.getServiceList()) { serviceHandler.handle(service); } } ProtoFileHandler(TypeMap types, OutputStream output); void handle(FileDescriptorProto protoFile); }### Answer: @Test public void testHandle() throws IOException { Descriptors.Descriptor personDescriptor = Person.getDescriptor(); FileDescriptorProto protoFile = personDescriptor.getFile().toProto(); TypeMap types = TypeMap.of(protoFile); ProtoFileHandler fileHandler = new ProtoFileHandler(types, new ByteArrayOutputStream()); fileHandler.handle(protoFile); }
### Question: JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } JavaType(@Nullable String javaPackage, @Nullable String enclosingClass, String className); @Override String toString(); }### Answer: @Test public void testNullPackage() { JavaType type = new JavaType(null, "B", "C"); Assert.assertEquals("B.C", type.toString()); } @Test public void testNullEnclosingClass() { JavaType type = new JavaType("a", null, "C"); Assert.assertEquals("a.C", type.toString()); }
### Question: LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); }### Answer: @Test public void isLogined_LoginedStatusTest() { KeyManager.clear(); KeyManager.putToken(TEST_LOGIN_KEY); Assert.assertEquals( true, presenter.isLogined() ); } @Test public void isLogined_NotLoginedStatusTest() { KeyManager.clear(); Assert.assertEquals( false, presenter.isLogined() ); }
### Question: LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); }### Answer: @Test public void onLoginButtonClick_EmptyIdTest() { presenter.onLoginButtonClicked( null, TEST_ACCOUNT_PW ); verify(view).showInputInvaildToast(); } @Test public void onLoginButtonClick_EmptyPwTest() { presenter.onLoginButtonClicked( TEST_ACCOUNT_ID, null ); verify(view).showInputInvaildToast(); } @Test public void onLoginButtonClick_EmptyIdPwTest() { presenter.onLoginButtonClicked( null, null ); verify(view).showInputInvaildToast(); } @Test public void onLoginButtonClick_DismatchIdPwTest() { presenter.onLoginButtonClicked( TEST_ACCOUNT_ID, TEST_ACCOUNT_PW ); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }
### Question: ResourceBundleService extends TranslationService { @Override public String translate(String key) { return rb.getString(key); } ResourceBundleService(ResourceBundle rb); void changeLocale(ResourceBundle newValue); @Override String translate(String key); }### Answer: @Test public void translateTest() { ResourceBundleService rbs = new ResourceBundleService(rbEN); Assert.assertEquals("Test Form", rbs.translate("form_title")); try { rbs.translate("non_existing"); fail(); } catch (MissingResourceException ignored) {} }
### Question: IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator between(int min, int max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new IntegerRangeValidator(min, max, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); }### Answer: @Test public void betweenTest() { IntegerRangeValidator i = IntegerRangeValidator.between(10, 20, "test"); Assert.assertTrue(i.validate(14).getResult()); Assert.assertFalse(i.validate(21).getResult()); Assert.assertTrue(i.validate(20).getResult()); Assert.assertTrue(i.validate(10).getResult()); try { IntegerRangeValidator i2 = IntegerRangeValidator.between(20, 10, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { IntegerRangeValidator i2 = IntegerRangeValidator.between(10, 10, "test"); } catch (IllegalArgumentException ignored) { fail(); } }
### Question: IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator atLeast(int min, String errorMessage) { return new IntegerRangeValidator(min, Integer.MAX_VALUE, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); }### Answer: @Test public void atLeastTest() { IntegerRangeValidator i = IntegerRangeValidator.atLeast(10, "test"); Assert.assertTrue(i.validate(14).getResult()); Assert.assertFalse(i.validate(-139).getResult()); Assert.assertTrue(i.validate(10).getResult()); Assert.assertFalse(i.validate(9).getResult()); Assert.assertTrue(i.validate(Integer.MAX_VALUE).getResult()); }
### Question: IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator upTo(int max, String errorMessage) { return new IntegerRangeValidator(Integer.MIN_VALUE, max, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); }### Answer: @Test public void upToTest() { IntegerRangeValidator i = IntegerRangeValidator.upTo(10, "test"); Assert.assertFalse(i.validate(14).getResult()); Assert.assertFalse(i.validate(21).getResult()); Assert.assertTrue(i.validate(10).getResult()); Assert.assertFalse(i.validate(11).getResult()); Assert.assertTrue(i.validate(Integer.MIN_VALUE).getResult()); }
### Question: IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator exactly(int value, String errorMessage) { return new IntegerRangeValidator(value, value, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); }### Answer: @Test public void exactlyTest() { IntegerRangeValidator i = IntegerRangeValidator.exactly(10, "test"); Assert.assertFalse(i.validate(11).getResult()); Assert.assertFalse(i.validate(9).getResult()); Assert.assertTrue(i.validate(10).getResult()); Assert.assertFalse(i.validate(Integer.MIN_VALUE).getResult()); }
### Question: StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator between(int min, int max, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } else if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new StringLengthValidator(min, max, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); }### Answer: @Test public void betweenTest() { StringLengthValidator s = StringLengthValidator.between(10, 20, "test"); Assert.assertTrue(s.validate("abcdefghijklmno").getResult()); Assert.assertFalse(s.validate("abcde").getResult()); Assert.assertTrue(s.validate(" ").getResult()); Assert.assertTrue(s.validate("æ¢¢äöä1ö3ä±æ#¢æ±“{").getResult()); try { StringLengthValidator s2 = StringLengthValidator.between(-10, 2, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { StringLengthValidator s3 = StringLengthValidator.between(0, 0, "test"); } catch (IllegalArgumentException e) { fail(); } try { StringLengthValidator s4 = StringLengthValidator.between(10, 1, "test"); fail(); } catch (IllegalArgumentException ignored) {} }
### Question: StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator atLeast(int min, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } return new StringLengthValidator(min, Integer.MAX_VALUE, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); }### Answer: @Test public void atLeastTest() { StringLengthValidator s = StringLengthValidator.atLeast(5, "test"); Assert.assertTrue(s.validate("gosjrgohgsr").getResult()); Assert.assertFalse(s.validate(" ").getResult()); Assert.assertFalse(s.validate("ae").getResult()); Assert.assertTrue(s.validate("¶æ¢¶ππ§±#").getResult()); try { StringLengthValidator s2 = StringLengthValidator.atLeast(-10, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { StringLengthValidator s3 = StringLengthValidator.atLeast(0, "test"); } catch (IllegalArgumentException e) { fail(); } }
### Question: StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator upTo(int max, String errorMessage) { return new StringLengthValidator(0, max, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); }### Answer: @Test public void upToTest() { StringLengthValidator s = StringLengthValidator.upTo(5, "test"); Assert.assertFalse(s.validate("gosjrgohgsr").getResult()); Assert.assertTrue(s.validate(" ").getResult()); Assert.assertTrue(s.validate("ae").getResult()); Assert.assertFalse(s.validate("¶æ¢¶ππ§±#").getResult()); }
### Question: StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator exactly(int value, String errorMessage) { return new StringLengthValidator(value, value, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); }### Answer: @Test public void exactlyTest() { StringLengthValidator s = StringLengthValidator.exactly(3, "test"); Assert.assertFalse(s.validate("gfyf").getResult()); Assert.assertTrue(s.validate(" ").getResult()); Assert.assertTrue(s.validate("aee").getResult()); Assert.assertFalse(s.validate("ee").getResult()); }
### Question: Field extends Element<F> implements FormElement { public static <T> SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection) { return new SingleSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); }### Answer: @Test public void singleSelectionTest() { SingleSelectionField<String> s = Field.ofSingleSelectionType(Arrays.asList("Test", "Test 1", "Test 2"), 0); Assert.assertEquals("Test", s.getSelection()); s.select(2); Assert.assertEquals("Test 2", s.getSelection()); s.select(4); Assert.assertEquals("Test 2", s.getSelection()); s.deselect(); Assert.assertEquals(null, s.getSelection()); s.select(2); Assert.assertEquals("Test 2", s.getSelection()); s.select(-1); Assert.assertEquals(null, s.getSelection()); }
### Question: Field extends Element<F> implements FormElement { public static <T> MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection) { return new MultiSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); }### Answer: @Test public void multiSelectionTest() { MultiSelectionField<String> s = Field.ofMultiSelectionType(Arrays.asList("Test", "Test 1", "Test 2"), Arrays.asList(0, 3)); Assert.assertEquals(1, s.getSelection().size()); s.select(2); Assert.assertEquals(2, s.getSelection().size()); s.select(4); Assert.assertEquals(2, s.getSelection().size()); s.deselect(1); Assert.assertEquals(2, s.getSelection().size()); s.deselect(0); Assert.assertEquals(1, s.getSelection().size()); }
### Question: ResourceBundleService extends TranslationService { public void changeLocale(ResourceBundle newValue) { if (newValue.equals(rb)) { return; } rb = newValue; notifyListeners(); } ResourceBundleService(ResourceBundle rb); void changeLocale(ResourceBundle newValue); @Override String translate(String key); }### Answer: @Test public void changeLocaleTest() { ResourceBundleService rbs = new ResourceBundleService(rbEN); final int[] calls = new int[] { 0 }; Runnable r = () -> calls[0] += 1; rbs.addListener(r); rbs.changeLocale(rbDE); Assert.assertEquals(1, calls[0]); rbs.changeLocale(rbDE); Assert.assertEquals(1, calls[0]); rbs.removeListener(r); }
### Question: Field extends Element<F> implements FormElement { public static StringField ofStringType(String defaultValue) { return new StringField(new SimpleStringProperty(defaultValue), new SimpleStringProperty(defaultValue)); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); }### Answer: @Test public void multilineTest() { StringField s = Field.ofStringType("test").multiline(true); Assert.assertTrue(s.isMultiline()); s.multiline(false); Assert.assertFalse(s.multilineProperty().getValue()); }
### Question: Section extends Group { public Section collapse(boolean newValue) { collapsed.setValue(newValue); return this; } private Section(Element... elements); static Section of(Element... elements); Section title(String newValue); Section collapse(boolean newValue); BooleanProperty collapsedProperty(); boolean isCollapsed(); String getTitle(); StringProperty titleProperty(); Section collapsible(boolean newValue); boolean isCollapsible(); BooleanProperty collapsibleProperty(); }### Answer: @Test public void collapseTest() { Section s = Section.of(); final int[] changes = { 0 }; s.collapsedProperty().addListener((observable, oldValue, newValue) -> changes[0] += 1); s.collapse(true); s.collapse(false); Assert.assertEquals(2, changes[0]); Assert.assertFalse(s.isCollapsed()); }
### Question: SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } void setField(F field); @Override void initializeParts(); @Override void layoutParts(); void setupBindings(); @Override void setupValueChangedListeners(); void addStyleClass(String name); void removeStyleClass(String name); }### Answer: @Test public void itemsTest() { MultiSelectionField<Integer> mf = Field.ofMultiSelectionType(Arrays.asList(1, 2, 3), Arrays.asList(1, 2)); SingleSelectionField<Integer> sf = Field.ofSingleSelectionType(Arrays.asList(1, 2, 3), 1); SimpleCheckBoxControl<Integer> cb = new SimpleCheckBoxControl<>(); cb.setField(mf); SimpleListViewControl<Integer> lv = new SimpleListViewControl<>(); lv.setField(mf); SimpleRadioButtonControl<Integer> rb = new SimpleRadioButtonControl<>(); rb.setField(sf); SimpleComboBoxControl<Integer> cmb = new SimpleComboBoxControl<>(); cmb.setField(sf); Assert.assertEquals(3, ((VBox) cb.getChildren().get(1)).getChildren().size()); Assert.assertTrue(((CheckBox) ((VBox) cb.getChildren().get(1)).getChildren().get(1)).isSelected()); Assert.assertEquals(3, ((ListView) lv.getChildren().get(1)).getItems().size()); Assert.assertTrue(((ListView) lv.getChildren().get(1)).getSelectionModel().isSelected(1)); Assert.assertEquals(3, ((VBox) rb.getChildren().get(1)).getChildren().size()); Assert.assertTrue(((RadioButton) ((VBox) rb.getChildren().get(1)).getChildren().get(1)).isSelected()); Assert.assertEquals(3, ((ComboBox) ((StackPane) cmb.getChildren().get(1)).getChildren().get(0)).getItems().size()); Assert.assertTrue(((ComboBox) ((StackPane) cmb.getChildren().get(1)).getChildren().get(0)).getSelectionModel().isSelected(1)); mf.items(Arrays.asList(1, 2, 3, 4, 5), Arrays.asList(0, 3)); sf.items(Arrays.asList(1, 2, 3, 4, 5), 3); Assert.assertEquals(5, ((VBox) cb.getChildren().get(1)).getChildren().size()); Assert.assertTrue(((CheckBox) ((VBox) cb.getChildren().get(1)).getChildren().get(0)).isSelected()); Assert.assertEquals(5, ((ListView) lv.getChildren().get(1)).getItems().size()); Assert.assertTrue(((ListView) lv.getChildren().get(1)).getSelectionModel().isSelected(0)); Assert.assertEquals(5, ((VBox) rb.getChildren().get(1)).getChildren().size()); Assert.assertTrue(((RadioButton) ((VBox) rb.getChildren().get(1)).getChildren().get(3)).isSelected()); Assert.assertEquals(5, ((ComboBox) ((StackPane) cmb.getChildren().get(1)).getChildren().get(0)).getItems().size()); Assert.assertTrue(((ComboBox) ((StackPane) cmb.getChildren().get(1)).getChildren().get(0)).getSelectionModel().isSelected(3)); } @Test public void styleTest() { StringField s = Field.ofStringType("test").styleClass("test"); SimpleTextControl t = new SimpleTextControl(); t.setField(s); Assert.assertEquals(3, t.getStyleClass().size()); s.styleClass("hello", "world"); Assert.assertEquals(4, t.getStyleClass().size()); s.styleClass("hi", "world"); Assert.assertEquals(4, t.getStyleClass().size()); Assert.assertEquals("world", t.getStyleClass().get(3)); }
### Question: DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator between(double min, double max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new DoubleRangeValidator(min, max, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); }### Answer: @Test public void betweenTest() { DoubleRangeValidator i = DoubleRangeValidator.between(3.5, 12.1351, "test"); Assert.assertTrue(i.validate(11.5).getResult()); Assert.assertTrue(i.validate(3.50000001).getResult()); Assert.assertFalse(i.validate(12.13511).getResult()); Assert.assertFalse(i.validate(3.4999999).getResult()); try { DoubleRangeValidator i2 = DoubleRangeValidator.between(10.0, 5.3, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { DoubleRangeValidator i2 = DoubleRangeValidator.between(5.5, 5.5, "test"); } catch (IllegalArgumentException ignored) { fail(); } }
### Question: DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator atLeast(double min, String errorMessage) { return new DoubleRangeValidator(min, Double.MAX_VALUE, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); }### Answer: @Test public void atLeastTest() { DoubleRangeValidator i = DoubleRangeValidator.atLeast(5.12351, "test"); Assert.assertTrue(i.validate(6234.1).getResult()); Assert.assertFalse(i.validate(1.31).getResult()); Assert.assertTrue(i.validate(5.12351).getResult()); Assert.assertFalse(i.validate(5.1235).getResult()); Assert.assertTrue(i.validate(Double.MAX_VALUE).getResult()); }
### Question: DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator upTo(double max, String errorMessage) { return new DoubleRangeValidator(Double.MIN_VALUE, max, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); }### Answer: @Test public void upToTest() { DoubleRangeValidator i = DoubleRangeValidator.upTo(3.14, "test"); Assert.assertFalse(i.validate(-1.14).getResult()); Assert.assertFalse(i.validate(5.13).getResult()); Assert.assertTrue(i.validate(3.14).getResult()); Assert.assertFalse(i.validate(3.141).getResult()); Assert.assertTrue(i.validate(Double.MIN_VALUE).getResult()); }

Subsets and Splits

No saved queries yet

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