src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); } | @Test void validateShouldReturnSixErrorsWithoutOptionFile() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/ping.yaml"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); sixErrorsAssertions(errorList); }
@Test void validateShouldReturnSixErrorsWithEmptyOptionFile() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/ping.yaml", "-o", "src/test/resources/empty.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); sixErrorsAssertions(errorList); }
@Test void validateShouldReturnSixErrorsWithDefaultOptionFile() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/ping.yaml", "-o", "src/test/resources/default.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); sixErrorsAssertions(errorList); }
@Test void validateShouldReturnNoErrorsWithCustomOptionFile() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/ping.yaml", "-o", "src/test/resources/custom.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); assertEquals(0, errorList.size()); }
@Test void validateWithoutOptionFileShouldReturnNamingErrors() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); namingErrorsAssertions(errorList, "camelCase", "camelCase", "hyphen-case"); }
@Test void validateWithAlternativeNamingOptionTestShouldReturnNamingErrors() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/alternative.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); namingErrorsAssertions(errorList, "hyphen-case", "hyphen-case", "camelCase"); }
@Test void validateWithUnderscoreNamingOptionTestShouldReturnNoError() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/underscore.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); assertEquals(0, errorList.size()); }
@Test void validateWithAlternativeLegacyNamingOptionTestShouldReturnNamingErrors() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/alternativeLegacy.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); namingErrorsAssertions(errorList, "hyphen-case", "hyphen-case", "camelCase"); }
@Test void validateWithAlternativeAndLegacyNamingOptionTestShouldReturnNamingErrors() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/alternativeAndLegacy.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); namingErrorsAssertions(errorList, "hyphen-case", "hyphen-case", "camelCase"); }
@Test void validateWithUnderscoreLegacyNamingOptionTestShouldReturnNoError() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/underscoreLegacy.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); assertEquals(0, errorList.size()); } |
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } } | @Test void goodUnderscoreCaseShouldReturnTrue() { String goodUnderscoreCase1 = "my_variable"; String goodUnderscoreCase2 = "variable"; String goodUnderscoreCase3 = "my_super_variable"; boolean actual1 = validator.isNamingValid(goodUnderscoreCase1, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual2 = validator.isNamingValid(goodUnderscoreCase2, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual3 = validator.isNamingValid(goodUnderscoreCase3, ValidatorParameters.NamingConvention.UnderscoreCase); Assertions.assertAll( () -> assertTrue(actual1), () -> assertTrue(actual2), () -> assertTrue(actual3) ); }
@Test void badUnderscoreCaseShouldReturnFalse() { String badUnderscoreCase1 = "myVariable"; String badUnderscoreCase2 = "my-variable"; String badUnderscoreCase3 = "my-Variable"; String badUnderscoreCase4 = "my__variable_lol"; String badUnderscoreCase5 = "_my_variable"; String badUnderscoreCase6 = "my_variable_"; boolean actual1 = validator.isNamingValid(badUnderscoreCase1, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual2 = validator.isNamingValid(badUnderscoreCase2, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual3 = validator.isNamingValid(badUnderscoreCase3, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual4 = validator.isNamingValid(badUnderscoreCase4, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual5 = validator.isNamingValid(badUnderscoreCase5, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual6 = validator.isNamingValid(badUnderscoreCase6, ValidatorParameters.NamingConvention.UnderscoreCase); Assertions.assertAll( () -> assertFalse(actual1), () -> assertFalse(actual2), () -> assertFalse(actual3), () -> assertFalse(actual4), () -> assertFalse(actual5), () -> assertFalse(actual6) ); }
@Test void goodCamelCaseShouldReturnTrue() { String goodCamelCase1 = "myVariable"; String goodCamelCase2 = "variable"; String goodCamelCase3 = "mySuperVariable"; String goodCamelCase4 = "mySuperVariableIsAFunnyOne"; String goodCamelCase5 = "zone2Delete"; String goodCamelCase6 = "address1"; boolean actual1 = validator.isNamingValid(goodCamelCase1, ValidatorParameters.NamingConvention.CamelCase); boolean actual2 = validator.isNamingValid(goodCamelCase2, ValidatorParameters.NamingConvention.CamelCase); boolean actual3 = validator.isNamingValid(goodCamelCase3, ValidatorParameters.NamingConvention.CamelCase); boolean actual4 = validator.isNamingValid(goodCamelCase4, ValidatorParameters.NamingConvention.CamelCase); boolean actual5 = validator.isNamingValid(goodCamelCase5, ValidatorParameters.NamingConvention.CamelCase); boolean actual6 = validator.isNamingValid(goodCamelCase6, ValidatorParameters.NamingConvention.CamelCase); Assertions.assertAll( () -> assertTrue(actual1), () -> assertTrue(actual2), () -> assertTrue(actual3), () -> assertTrue(actual4), () -> assertTrue(actual5), () -> assertTrue(actual6) ); }
@Test void badCamelCaseShouldReturnFalse() { String badCamelCase1 = "my_variable"; String badCamelCase2 = "my-variable"; String badCamelCase3 = "my-Variable"; String badCamelCase4 = "Variable"; String badCamelCase5 = "my variable"; boolean actual1 = validator.isNamingValid(badCamelCase1, ValidatorParameters.NamingConvention.CamelCase); boolean actual2 = validator.isNamingValid(badCamelCase2, ValidatorParameters.NamingConvention.CamelCase); boolean actual3 = validator.isNamingValid(badCamelCase3, ValidatorParameters.NamingConvention.CamelCase); boolean actual4 = validator.isNamingValid(badCamelCase4, ValidatorParameters.NamingConvention.CamelCase); boolean actual5 = validator.isNamingValid(badCamelCase5, ValidatorParameters.NamingConvention.CamelCase); Assertions.assertAll( () -> assertFalse(actual1), () -> assertFalse(actual2), () -> assertFalse(actual3), () -> assertFalse(actual4), () -> assertFalse(actual5) ); }
@Test void goodHyphenCaseShouldReturnTrue() { String goodHyphenCase1 = "my-variable"; String goodHyphenCase2 = "variable"; String goodHyphenCase3 = "my-super-variable"; boolean actual1 = validator.isNamingValid(goodHyphenCase1, ValidatorParameters.NamingConvention.HyphenCase); boolean actual2 = validator.isNamingValid(goodHyphenCase2, ValidatorParameters.NamingConvention.HyphenCase); boolean actual3 = validator.isNamingValid(goodHyphenCase3, ValidatorParameters.NamingConvention.HyphenCase); Assertions.assertAll( () -> assertTrue(actual1), () -> assertTrue(actual2), () -> assertTrue(actual3) ); }
@Test void badHyphenCaseShouldReturnFalse() { String badHyphenCase1 = "my_variable"; String badHyphenCase2 = "myVariable"; String badHyphenCase3 = "my_Variable"; String badHyphenCase4 = "my__Variable_is_important"; String badHyphenCase5 = "_my_variable"; String badHyphenCase6 = "my_variable_"; boolean actual1 = validator.isNamingValid(badHyphenCase1, ValidatorParameters.NamingConvention.HyphenCase); boolean actual2 = validator.isNamingValid(badHyphenCase2, ValidatorParameters.NamingConvention.HyphenCase); boolean actual3 = validator.isNamingValid(badHyphenCase3, ValidatorParameters.NamingConvention.HyphenCase); boolean actual4 = validator.isNamingValid(badHyphenCase4, ValidatorParameters.NamingConvention.HyphenCase); boolean actual5 = validator.isNamingValid(badHyphenCase5, ValidatorParameters.NamingConvention.HyphenCase); boolean actual6 = validator.isNamingValid(badHyphenCase6, ValidatorParameters.NamingConvention.HyphenCase); Assertions.assertAll( () -> assertFalse(actual1), () -> assertFalse(actual2), () -> assertFalse(actual3), () -> assertFalse(actual4), () -> assertFalse(actual5), () -> assertFalse(actual6) ); } |
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); List<StyleError> validate(ValidatorParameters parameters); static final String INPUT_FILE; } | @Test void validatePingOpenAPI() { OpenAPI openAPI = createPingOpenAPI(); OpenApiSpecStyleValidator validator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = new ValidatorParameters(); List<StyleError> errors = validator.validate(parameters); assertTrue(errors.size() == 1); assertEquals("*ERROR* in Model 'Myobject', property 'name', field 'example' -> This field should be present and not empty", errors.get(0).toString()); }
@Test void validatePingOpenAPI_without_ValidateModelPropertiesExample() { OpenAPI openAPI = createPingOpenAPI(); OpenApiSpecStyleValidator validator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = new ValidatorParameters(); parameters.setValidateModelPropertiesExample(false); List<StyleError> errors = validator.validate(parameters); assertTrue(errors.size() == 0); }
@Test void validatePingOpenAPI_WithoutSchema_and_components() { OpenAPI openAPI = createSimplePingOpenAPI(); OpenApiSpecStyleValidator validator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = new ValidatorParameters(); List<StyleError> errors = validator.validate(parameters); assertTrue(errors.size() == 0); } |
KmlUtil { public static String substituteProperties(String template, KmlPlacemark placemark) { StringBuffer sb = new StringBuffer(); Pattern pattern = Pattern.compile("\\$\\[(.+?)]"); Matcher matcher = pattern.matcher(template); while (matcher.find()) { String property = matcher.group(1); String value = placemark.getProperty(property); if (value != null) { matcher.appendReplacement(sb, value); } } matcher.appendTail(sb); return sb.toString(); } static String substituteProperties(String template, KmlPlacemark placemark); } | @Test public void testSubstituteProperties() { Map<String, String> properties = new HashMap<>(); properties.put("name", "Bruce Wayne"); properties.put("description", "Batman"); properties.put("Snippet", "I am the night"); KmlPlacemark placemark = new KmlPlacemark(null, null, null, properties); String result1 = KmlUtil.substituteProperties("$[name] is my name", placemark); assertEquals("Bruce Wayne is my name", result1); String result2 = KmlUtil.substituteProperties("Also known as $[description]", placemark); assertEquals("Also known as Batman", result2); String result3 = KmlUtil.substituteProperties("I say \"$[Snippet]\" often", placemark); assertEquals("I say \"I am the night\" often", result3); String result4 = KmlUtil.substituteProperties("My address is $[address]", placemark); assertEquals("When property doesn't exist, placeholder is left in place", "My address is $[address]", result4); } |
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } } | @Test public void testCreateContainerProperty() throws Exception { XmlPullParser xmlPullParser = createParser("amu_basic_folder.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertTrue(kmlContainer.hasProperties()); assertEquals("Basic Folder", kmlContainer.getProperty("name")); xmlPullParser = createParser("amu_unknown_folder.kml"); kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertTrue(kmlContainer.hasProperty("name")); }
@Test public void testCreateContainerPlacemark() throws Exception { XmlPullParser xmlPullParser = createParser("amu_basic_folder.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertTrue(kmlContainer.hasPlacemarks()); assertEquals(1, kmlContainer.getPlacemarksHashMap().size()); xmlPullParser = createParser("amu_multiple_placemarks.kml"); kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertTrue(kmlContainer.hasPlacemarks()); assertEquals(2, kmlContainer.getPlacemarksHashMap().size()); }
@Test public void testCreateContainerGroundOverlay() throws Exception { XmlPullParser xmlPullParser = createParser("amu_ground_overlay.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertEquals(2, kmlContainer.getGroundOverlayHashMap().size()); }
@Test public void testCreateContainerObjects() throws Exception { XmlPullParser xmlPullParser = createParser("amu_nested_folders.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertNotNull(kmlContainer.getContainers()); int numberOfNestedContainers = 0; for (KmlContainer container : kmlContainer.getContainers()) { numberOfNestedContainers++; } assertEquals(2, numberOfNestedContainers); }
@Test public void testCDataEntity() throws Exception { XmlPullParser xmlPullParser = createParser("amu_cdata.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertEquals("TELEPORT", kmlContainer.getProperty("description")); } |
KmlLineString extends LineString { public ArrayList<LatLng> getGeometryObject() { List<LatLng> coordinatesList = super.getGeometryObject(); return new ArrayList<>(coordinatesList); } KmlLineString(ArrayList<LatLng> coordinates); KmlLineString(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes); ArrayList<Double> getAltitudes(); ArrayList<LatLng> getGeometryObject(); } | @Test public void testGetKmlGeometryObject() { KmlLineString kmlLineString = createSimpleLineString(); assertNotNull(kmlLineString); assertNotNull(kmlLineString.getGeometryObject()); assertEquals(3, kmlLineString.getGeometryObject().size()); assertEquals(0.0, kmlLineString.getGeometryObject().get(0).latitude, 0); assertEquals(50.0, kmlLineString.getGeometryObject().get(1).latitude, 0); assertEquals(90.0, kmlLineString.getGeometryObject().get(2).latitude, 0); kmlLineString = createLoopedLineString(); assertNotNull(kmlLineString); assertNotNull(kmlLineString.getGeometryObject()); assertEquals(3, kmlLineString.getGeometryObject().size()); assertEquals(0.0, kmlLineString.getGeometryObject().get(0).latitude, 0); assertEquals(50.0, kmlLineString.getGeometryObject().get(1).latitude, 0); assertEquals(0.0, kmlLineString.getGeometryObject().get(2).latitude, 0); } |
KmlLineString extends LineString { public ArrayList<Double> getAltitudes() { return mAltitudes; } KmlLineString(ArrayList<LatLng> coordinates); KmlLineString(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes); ArrayList<Double> getAltitudes(); ArrayList<LatLng> getGeometryObject(); } | @Test public void testLineStringAltitudes() { KmlLineString kmlLineString = createSimpleLineString(); assertNotNull(kmlLineString); assertNull(kmlLineString.getAltitudes()); kmlLineString = createSimpleLineStringWithAltitudes(); assertNotNull(kmlLineString); assertNotNull(kmlLineString.getAltitudes()); assertEquals(100.0, kmlLineString.getAltitudes().get(0), 0); assertEquals(200.0, kmlLineString.getAltitudes().get(1), 0); assertEquals(300.0, kmlLineString.getAltitudes().get(2), 0); } |
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } } | @Test public void testPolygon() throws Exception { XmlPullParser xmlPullParser = createParser("amu_basic_placemark.kml"); KmlPlacemark placemark = KmlFeatureParser.createPlacemark(xmlPullParser); assertNotNull(placemark); assertEquals(placemark.getGeometry().getGeometryType(), "Polygon"); KmlPolygon polygon = ((KmlPolygon) placemark.getGeometry()); assertEquals(polygon.getInnerBoundaryCoordinates().size(), 2); assertEquals(polygon.getOuterBoundaryCoordinates().size(), 5); }
@Test public void testMultiGeometry() throws Exception { XmlPullParser xmlPullParser = createParser("amu_multigeometry_placemarks.kml"); KmlPlacemark placemark = KmlFeatureParser.createPlacemark(xmlPullParser); assertNotNull(placemark); assertEquals(placemark.getGeometry().getGeometryType(), "MultiGeometry"); KmlMultiGeometry multiGeometry = ((KmlMultiGeometry) placemark.getGeometry()); assertEquals(multiGeometry.getGeometryObject().size(), 3); }
@Test public void testProperties() throws Exception { XmlPullParser xmlPullParser = createParser("amu_multigeometry_placemarks.kml"); KmlPlacemark placemark = KmlFeatureParser.createPlacemark(xmlPullParser); assertTrue(placemark.hasProperties()); assertEquals(placemark.getProperty("name"), "Placemark Test"); assertNull(placemark.getProperty("description")); }
@Test public void testExtendedData() throws Exception { XmlPullParser xmlPullParser = createParser("amu_multiple_placemarks.kml"); KmlPlacemark placemark = KmlFeatureParser.createPlacemark(xmlPullParser); assertNotNull(placemark.getProperty("holeNumber")); }
@Test public void testMultiGeometries() throws Exception { XmlPullParser xmlPullParser = createParser("amu_nested_multigeometry.kml"); KmlPlacemark feature = KmlFeatureParser.createPlacemark(xmlPullParser); assertEquals(feature.getProperty("name"), "multiPointLine"); assertEquals(feature.getProperty("description"), "Nested MultiGeometry structure"); assertEquals(feature.getGeometry().getGeometryType(), "MultiGeometry"); List<Geometry> objects = (ArrayList<Geometry>) feature.getGeometry().getGeometryObject(); assertEquals(objects.get(0).getGeometryType(), "Point"); assertEquals(objects.get(1).getGeometryType(), "LineString"); assertEquals(objects.get(2).getGeometryType(), "MultiGeometry"); List<Geometry> subObjects = (ArrayList<Geometry>) objects.get(2).getGeometryObject(); assertEquals(subObjects.get(0).getGeometryType(), "Point"); assertEquals(subObjects.get(1).getGeometryType(), "LineString"); } |
KmlTrack extends KmlLineString { public ArrayList<Long> getTimestamps() { return mTimestamps; } KmlTrack(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes, ArrayList<Long> timestamps, HashMap<String, String> properties); ArrayList<Long> getTimestamps(); HashMap<String, String> getProperties(); } | @Test public void testTimestamps() { KmlTrack kmlTrack = createSimpleTrack(); assertNotNull(kmlTrack); assertNotNull(kmlTrack.getTimestamps()); assertEquals(kmlTrack.getTimestamps().size(), 3); assertEquals(kmlTrack.getTimestamps().get(0), Long.valueOf(1000L)); assertEquals(kmlTrack.getTimestamps().get(1), Long.valueOf(2000L)); assertEquals(kmlTrack.getTimestamps().get(2), Long.valueOf(3000L)); } |
MultiGeometry implements Geometry { public String getGeometryType() { return geometryType; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); } | @Test public void testGetGeometryType() { List<LineString> lineStrings = new ArrayList<>(); lineStrings.add( new LineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50))))); lineStrings.add( new LineString( new ArrayList<>(Arrays.asList(new LatLng(56, 65), new LatLng(23, 23))))); mg = new MultiGeometry(lineStrings); assertEquals("MultiGeometry", mg.getGeometryType()); List<GeoJsonPolygon> polygons = new ArrayList<>(); List<ArrayList<LatLng>> polygon = new ArrayList<>(); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); polygons.add(new GeoJsonPolygon(polygon)); polygon = new ArrayList<>(); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(50, 80), new LatLng(10, 15), new LatLng(0, 0)))); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); polygons.add(new GeoJsonPolygon(polygon)); mg = new MultiGeometry(polygons); assertEquals("MultiGeometry", mg.getGeometryType()); } |
MultiGeometry implements Geometry { public void setGeometryType(String type) { geometryType = type; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); } | @Test public void testSetGeometryType() { List<LineString> lineStrings = new ArrayList<>(); lineStrings.add( new LineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50))))); lineStrings.add( new LineString( new ArrayList<>(Arrays.asList(new LatLng(56, 65), new LatLng(23, 23))))); mg = new MultiGeometry(lineStrings); assertEquals("MultiGeometry", mg.getGeometryType()); mg.setGeometryType("MultiLineString"); assertEquals("MultiLineString", mg.getGeometryType()); } |
MultiGeometry implements Geometry { public List<Geometry> getGeometryObject() { return mGeometries; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); } | @Test public void testGetGeometryObject() { List<Point> points = new ArrayList<>(); points.add(new Point(new LatLng(0, 0))); points.add(new Point(new LatLng(5, 5))); points.add(new Point(new LatLng(10, 10))); mg = new MultiGeometry(points); assertEquals(points, mg.getGeometryObject()); points = new ArrayList<>(); mg = new MultiGeometry(points); assertEquals(new ArrayList<Point>(), mg.getGeometryObject()); try { mg = new MultiGeometry(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Geometries cannot be null", e.getMessage()); } } |
LineString implements Geometry<List<LatLng>> { public String getGeometryType() { return GEOMETRY_TYPE; } LineString(List<LatLng> coordinates); String getGeometryType(); List<LatLng> getGeometryObject(); @Override String toString(); } | @Test public void testGetType() { LineString lineString = createSimpleLineString(); assertNotNull(lineString); assertNotNull(lineString.getGeometryType()); assertEquals("LineString", lineString.getGeometryType()); lineString = createLoopedLineString(); assertNotNull(lineString); assertNotNull(lineString.getGeometryType()); assertEquals("LineString", lineString.getGeometryType()); } |
LineString implements Geometry<List<LatLng>> { public List<LatLng> getGeometryObject() { return mCoordinates; } LineString(List<LatLng> coordinates); String getGeometryType(); List<LatLng> getGeometryObject(); @Override String toString(); } | @Test public void testGetGeometryObject() { LineString lineString = createSimpleLineString(); assertNotNull(lineString); assertNotNull(lineString.getGeometryObject()); assertEquals(lineString.getGeometryObject().size(), 6); assertEquals(lineString.getGeometryObject().get(0).latitude, 90.0, 0); assertEquals(lineString.getGeometryObject().get(1).latitude, 90.0, 0); assertEquals(lineString.getGeometryObject().get(2).latitude, 90.0, 0); assertEquals(lineString.getGeometryObject().get(3).longitude, 53.0, 0); assertEquals(lineString.getGeometryObject().get(4).longitude, 54.0, 0); lineString = createLoopedLineString(); assertNotNull(lineString); assertNotNull(lineString.getGeometryObject()); assertEquals(lineString.getGeometryObject().size(), 4); assertEquals(lineString.getGeometryObject().get(0).latitude, 90.0, 0); assertEquals(lineString.getGeometryObject().get(1).latitude, 89.0, 0); assertEquals(lineString.getGeometryObject().get(2).longitude, 62.0, 0); assertEquals(lineString.getGeometryObject().get(3).longitude, 66.0, 0); } |
GeoJsonPointStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonPointStyle(); @Override String[] getGeometryType(); float getAlpha(); void setAlpha(float alpha); float getAnchorU(); float getAnchorV(); void setAnchor(float anchorU, float anchorV); boolean isDraggable(); void setDraggable(boolean draggable); boolean isFlat(); void setFlat(boolean flat); BitmapDescriptor getIcon(); void setIcon(BitmapDescriptor bitmap); float getInfoWindowAnchorU(); float getInfoWindowAnchorV(); void setInfoWindowAnchor(float infoWindowAnchorU, float infoWindowAnchorV); float getRotation(); void setRotation(float rotation); String getSnippet(); void setSnippet(String snippet); String getTitle(); void setTitle(String title); @Override boolean isVisible(); @Override void setVisible(boolean visible); MarkerOptions toMarkerOptions(); @Override String toString(); float getZIndex(); void setZIndex(float zIndex); } | @Test public void testGetGeometryType() { assertTrue(Arrays.asList(pointStyle.getGeometryType()).contains("Point")); assertTrue(Arrays.asList(pointStyle.getGeometryType()).contains("MultiPoint")); assertTrue(Arrays.asList(pointStyle.getGeometryType()).contains("GeometryCollection")); assertEquals(3, pointStyle.getGeometryType().length); } |
GeoJsonLayer extends Layer { public Iterable<GeoJsonFeature> getFeatures() { return (Iterable<GeoJsonFeature>) super.getFeatures(); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); } | @Test public void testGetFeatures() { int featureCount = 0; for (Feature ignored : mLayer.getFeatures()) { featureCount++; } assertEquals(3, featureCount); } |
GeoJsonLayer extends Layer { public void addFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.addFeature(feature); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); } | @Test public void testAddFeature() { int featureCount = 0; mLayer.addFeature(new GeoJsonFeature(null, null, null, null)); for (Feature ignored : mLayer.getFeatures()) { featureCount++; } assertEquals(4, featureCount); } |
GeoJsonLayer extends Layer { public void removeFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.removeFeature(feature); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); } | @Test public void testRemoveFeature() { int featureCount = 0; for (Feature ignored : mLayer.getFeatures()) { featureCount++; } assertEquals(3, featureCount); } |
KmlTrack extends KmlLineString { public HashMap<String, String> getProperties() { return mProperties; } KmlTrack(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes, ArrayList<Long> timestamps, HashMap<String, String> properties); ArrayList<Long> getTimestamps(); HashMap<String, String> getProperties(); } | @Test public void testProperties() { KmlTrack kmlTrack = createSimpleTrack(); assertNotNull(kmlTrack); assertNotNull(kmlTrack.getProperties()); assertEquals(kmlTrack.getProperties().size(), 1); assertEquals(kmlTrack.getProperties().get("key"), "value"); assertNull(kmlTrack.getProperties().get("missingKey")); } |
GeoJsonLayer extends Layer { public LatLngBounds getBoundingBox() { return mBoundingBox; } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); } | @Test public void testGetBoundingBox() { assertEquals( new LatLngBounds(new LatLng(-80, -150), new LatLng(80, 150)), mLayer.getBoundingBox()); } |
GeoJsonLineStringStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonLineStringStyle(); @Override String[] getGeometryType(); int getColor(); void setColor(int color); boolean isClickable(); void setClickable(boolean clickable); boolean isGeodesic(); void setGeodesic(boolean geodesic); float getWidth(); void setWidth(float width); float getZIndex(); void setZIndex(float zIndex); @Override boolean isVisible(); @Override void setVisible(boolean visible); PolylineOptions toPolylineOptions(); @Override String toString(); List<PatternItem> getPattern(); void setPattern(List<PatternItem> pattern); } | @Test public void testGetGeometryType() { assertTrue(Arrays.asList(lineStringStyle.getGeometryType()).contains("LineString")); assertTrue(Arrays.asList(lineStringStyle.getGeometryType()).contains("MultiLineString")); assertTrue(Arrays.asList(lineStringStyle.getGeometryType()).contains("GeometryCollection")); assertEquals(3, lineStringStyle.getGeometryType().length); } |
GeoJsonParser { private void parseGeoJson() { try { GeoJsonFeature feature; String type = mGeoJsonFile.getString("type"); if (type.equals(FEATURE)) { feature = parseFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else if (type.equals(FEATURE_COLLECTION)) { mGeoJsonFeatures.addAll(parseFeatureCollection(mGeoJsonFile)); } else if (isGeometry(type)) { feature = parseGeometryToFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } catch (JSONException e) { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } GeoJsonParser(JSONObject geoJsonFile); static Geometry parseGeometry(JSONObject geoJsonGeometry); } | @Test public void testParseGeoJson() throws Exception { JSONObject validGeoJsonObject = new JSONObject( "{ \"type\": \"MultiLineString\",\n" + " \"coordinates\": [\n" + " [ [100.0, 0.0], [101.0, 1.0] ],\n" + " [ [102.0, 2.0], [103.0, 3.0] ]\n" + " ]\n" + " }"); GeoJsonParser parser = new GeoJsonParser(validGeoJsonObject); GeoJsonLineString ls1 = new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(0, 100), new LatLng(1, 101)))); GeoJsonLineString ls2 = new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(2, 102), new LatLng(3, 103)))); GeoJsonMultiLineString geoJsonMultiLineString = new GeoJsonMultiLineString(new ArrayList<>(Arrays.asList(ls1, ls2))); GeoJsonFeature geoJsonFeature = new GeoJsonFeature(geoJsonMultiLineString, null, null, null); List<GeoJsonFeature> geoJsonFeatures = new ArrayList<>(Arrays.asList(geoJsonFeature)); assertEquals(geoJsonFeatures.get(0).getId(), parser.getFeatures().get(0).getId()); } |
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } GeoJsonParser(JSONObject geoJsonFile); static Geometry parseGeometry(JSONObject geoJsonGeometry); } | @Test public void testParseGeometryCollection() throws Exception { GeoJsonParser parser = new GeoJsonParser(validGeometryCollection()); assertEquals(1, parser.getFeatures().size()); for (GeoJsonFeature feature : parser.getFeatures()) { assertEquals("GeometryCollection", feature.getGeometry().getGeometryType()); int size = 0; for (String property : feature.getPropertyKeys()) { size++; } assertEquals(2, size); assertEquals("Popsicles", feature.getId()); GeoJsonGeometryCollection geometry = ((GeoJsonGeometryCollection) feature.getGeometry()); assertEquals(1, geometry.getGeometries().size()); for (Geometry geoJsonGeometry : geometry.getGeometries()) { assertEquals("GeometryCollection", geoJsonGeometry.getGeometryType()); } } }
@Test public void testParseMultiPolygon() throws Exception { GeoJsonParser parser = new GeoJsonParser(validMultiPolygon()); assertEquals(1, parser.getFeatures().size()); GeoJsonFeature feature = parser.getFeatures().get(0); GeoJsonMultiPolygon polygon = ((GeoJsonMultiPolygon) feature.getGeometry()); assertEquals(2, polygon.getPolygons().size()); assertEquals(1, polygon.getPolygons().get(0).getCoordinates().size()); List<List<LatLng>> p1 = new ArrayList<>(); p1.add( new ArrayList<>( Arrays.asList( new LatLng(2, 102), new LatLng(2, 103), new LatLng(3, 103), new LatLng(3, 102), new LatLng(2, 102)))); assertEquals(p1, polygon.getPolygons().get(0).getCoordinates()); assertEquals(2, polygon.getPolygons().get(1).getCoordinates().size()); List<List<LatLng>> p2 = new ArrayList<>(); p2.add( new ArrayList<>( Arrays.asList( new LatLng(0, 100), new LatLng(0, 101), new LatLng(1, 101), new LatLng(1, 100), new LatLng(0, 100)))); p2.add( new ArrayList<>( Arrays.asList( new LatLng(0.2, 100.2), new LatLng(0.2, 100.8), new LatLng(0.8, 100.8), new LatLng(0.8, 100.2), new LatLng(0.2, 100.2)))); assertEquals(p2, polygon.getPolygons().get(1).getCoordinates()); } |
GeoJsonMultiLineString extends MultiGeometry { public String getType() { return getGeometryType(); } GeoJsonMultiLineString(List<GeoJsonLineString> geoJsonLineStrings); String getType(); List<GeoJsonLineString> getLineStrings(); } | @Test public void testGetType() { List<GeoJsonLineString> lineStrings = new ArrayList<>(); lineStrings.add( new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50))))); lineStrings.add( new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(80, 10), new LatLng(-54, 12.7))))); mls = new GeoJsonMultiLineString(lineStrings); assertEquals("MultiLineString", mls.getType()); } |
GeoJsonMultiLineString extends MultiGeometry { public List<GeoJsonLineString> getLineStrings() { List<Geometry> geometryList = getGeometryObject(); ArrayList<GeoJsonLineString> geoJsonLineStrings = new ArrayList<GeoJsonLineString>(); for (Geometry geometry : geometryList) { GeoJsonLineString lineString = (GeoJsonLineString) geometry; geoJsonLineStrings.add(lineString); } return geoJsonLineStrings; } GeoJsonMultiLineString(List<GeoJsonLineString> geoJsonLineStrings); String getType(); List<GeoJsonLineString> getLineStrings(); } | @Test public void testGetLineStrings() { List<GeoJsonLineString> lineStrings = new ArrayList<>(); lineStrings.add( new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50))))); lineStrings.add( new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(80, 10), new LatLng(-54, 12.7))))); mls = new GeoJsonMultiLineString(lineStrings); assertEquals(lineStrings, mls.getLineStrings()); lineStrings = new ArrayList<>(); mls = new GeoJsonMultiLineString(lineStrings); assertEquals(new ArrayList<GeoJsonLineString>(), mls.getLineStrings()); try { mls = new GeoJsonMultiLineString(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Geometries cannot be null", e.getMessage()); } } |
GeoJsonFeature extends Feature implements Observer { public void setGeometry(Geometry geometry) { super.setGeometry(geometry); setChanged(); notifyObservers(); } GeoJsonFeature(Geometry geometry, String id,
HashMap<String, String> properties, LatLngBounds boundingBox); String setProperty(String property, String propertyValue); String removeProperty(String property); GeoJsonPointStyle getPointStyle(); void setPointStyle(GeoJsonPointStyle pointStyle); GeoJsonLineStringStyle getLineStringStyle(); void setLineStringStyle(GeoJsonLineStringStyle lineStringStyle); GeoJsonPolygonStyle getPolygonStyle(); void setPolygonStyle(GeoJsonPolygonStyle polygonStyle); PolygonOptions getPolygonOptions(); MarkerOptions getMarkerOptions(); PolylineOptions getPolylineOptions(); void setGeometry(Geometry geometry); LatLngBounds getBoundingBox(); @Override String toString(); @Override void update(Observable observable, Object data); } | @Test public void testGeometry() { GeoJsonFeature feature = new GeoJsonFeature(null, null, null, null); assertNull(feature.getGeometry()); GeoJsonPoint point = new GeoJsonPoint(new LatLng(0, 0)); feature.setGeometry(point); assertEquals(point, feature.getGeometry()); feature.setGeometry(null); assertNull(feature.getGeometry()); GeoJsonLineString lineString = new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50)))); feature = new GeoJsonFeature(lineString, null, null, null); assertEquals(lineString, feature.getGeometry()); feature.setGeometry(point); assertEquals(point, feature.getGeometry()); feature.setGeometry(null); assertNull(feature.getGeometry()); feature.setGeometry(lineString); assertEquals(lineString, feature.getGeometry()); } |
GeoJsonFeature extends Feature implements Observer { public LatLngBounds getBoundingBox() { return mBoundingBox; } GeoJsonFeature(Geometry geometry, String id,
HashMap<String, String> properties, LatLngBounds boundingBox); String setProperty(String property, String propertyValue); String removeProperty(String property); GeoJsonPointStyle getPointStyle(); void setPointStyle(GeoJsonPointStyle pointStyle); GeoJsonLineStringStyle getLineStringStyle(); void setLineStringStyle(GeoJsonLineStringStyle lineStringStyle); GeoJsonPolygonStyle getPolygonStyle(); void setPolygonStyle(GeoJsonPolygonStyle polygonStyle); PolygonOptions getPolygonOptions(); MarkerOptions getMarkerOptions(); PolylineOptions getPolylineOptions(); void setGeometry(Geometry geometry); LatLngBounds getBoundingBox(); @Override String toString(); @Override void update(Observable observable, Object data); } | @Test public void testGetBoundingBox() { GeoJsonFeature feature = new GeoJsonFeature(null, null, null, null); assertNull(feature.getBoundingBox()); LatLngBounds boundingBox = new LatLngBounds(new LatLng(-20, -20), new LatLng(50, 50)); feature = new GeoJsonFeature(null, null, null, boundingBox); assertEquals(boundingBox, feature.getBoundingBox()); } |
GeoJsonLineString extends LineString { public String getType() { return getGeometryType(); } GeoJsonLineString(List<LatLng> coordinates); GeoJsonLineString(List<LatLng> coordinates, List<Double> altitudes); String getType(); List<LatLng> getCoordinates(); List<Double> getAltitudes(); } | @Test public void testGetType() { List<LatLng> coordinates = new ArrayList<>(); coordinates.add(new LatLng(0, 0)); coordinates.add(new LatLng(50, 50)); coordinates.add(new LatLng(100, 100)); ls = new GeoJsonLineString(coordinates); assertEquals("LineString", ls.getType()); } |
KmlMultiGeometry extends MultiGeometry { public ArrayList<Geometry> getGeometryObject() { List<Geometry> geometriesList = super.getGeometryObject(); return new ArrayList<>(geometriesList); } KmlMultiGeometry(ArrayList<Geometry> geometries); ArrayList<Geometry> getGeometryObject(); @Override String toString(); } | @Test public void testGetGeometry() { KmlMultiGeometry kmlMultiGeometry = createMultiGeometry(); Assert.assertNotNull(kmlMultiGeometry); Assert.assertEquals(1, kmlMultiGeometry.getGeometryObject().size()); KmlLineString lineString = ((KmlLineString) kmlMultiGeometry.getGeometryObject().get(0)); Assert.assertNotNull(lineString); } |
GeoJsonLineString extends LineString { public List<LatLng> getCoordinates() { return getGeometryObject(); } GeoJsonLineString(List<LatLng> coordinates); GeoJsonLineString(List<LatLng> coordinates, List<Double> altitudes); String getType(); List<LatLng> getCoordinates(); List<Double> getAltitudes(); } | @Test public void testGetCoordinates() { List<LatLng> coordinates = new ArrayList<>(); coordinates.add(new LatLng(0, 0)); coordinates.add(new LatLng(50, 50)); coordinates.add(new LatLng(100, 100)); ls = new GeoJsonLineString(coordinates); assertEquals(coordinates, ls.getCoordinates()); try { ls = new GeoJsonLineString(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Coordinates cannot be null", e.getMessage()); } } |
GeoJsonLineString extends LineString { public List<Double> getAltitudes() { return mAltitudes; } GeoJsonLineString(List<LatLng> coordinates); GeoJsonLineString(List<LatLng> coordinates, List<Double> altitudes); String getType(); List<LatLng> getCoordinates(); List<Double> getAltitudes(); } | @Test public void testGetAltitudes() { List<LatLng> coordinates = new ArrayList<>(); coordinates.add(new LatLng(0, 0)); coordinates.add(new LatLng(50, 50)); coordinates.add(new LatLng(100, 100)); List<Double> altitudes = new ArrayList<>(); altitudes.add(100d); altitudes.add(200d); altitudes.add(300d); ls = new GeoJsonLineString(coordinates, altitudes); assertEquals(altitudes, ls.getAltitudes()); assertEquals(ls.getAltitudes().get(0), 100.0, 0); assertEquals(ls.getAltitudes().get(1), 200.0, 0); assertEquals(ls.getAltitudes().get(2), 300.0, 0); } |
GeoJsonPoint extends Point { public String getType() { return getGeometryType(); } GeoJsonPoint(LatLng coordinates); GeoJsonPoint(LatLng coordinates, Double altitude); String getType(); LatLng getCoordinates(); Double getAltitude(); } | @Test public void testGetType() { GeoJsonPoint p = new GeoJsonPoint(new LatLng(0, 0)); assertEquals("Point", p.getType()); } |
GeoJsonPoint extends Point { public LatLng getCoordinates() { return getGeometryObject(); } GeoJsonPoint(LatLng coordinates); GeoJsonPoint(LatLng coordinates, Double altitude); String getType(); LatLng getCoordinates(); Double getAltitude(); } | @Test public void testGetCoordinates() { GeoJsonPoint p = new GeoJsonPoint(new LatLng(0, 0)); assertEquals(new LatLng(0, 0), p.getCoordinates()); try { new GeoJsonPoint(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Coordinates cannot be null", e.getMessage()); } } |
GeoJsonPoint extends Point { public Double getAltitude() { return mAltitude; } GeoJsonPoint(LatLng coordinates); GeoJsonPoint(LatLng coordinates, Double altitude); String getType(); LatLng getCoordinates(); Double getAltitude(); } | @Test public void testGetAltitude() { GeoJsonPoint p = new GeoJsonPoint(new LatLng(0, 0), 100d); assertEquals(new Double(100), p.getAltitude()); } |
GeoJsonMultiPoint extends MultiGeometry { public String getType() { return getGeometryType(); } GeoJsonMultiPoint(List<GeoJsonPoint> geoJsonPoints); String getType(); List<GeoJsonPoint> getPoints(); } | @Test public void testGetType() { List<GeoJsonPoint> points = new ArrayList<>(); points.add(new GeoJsonPoint(new LatLng(0, 0))); points.add(new GeoJsonPoint(new LatLng(5, 5))); points.add(new GeoJsonPoint(new LatLng(10, 10))); mp = new GeoJsonMultiPoint(points); assertEquals("MultiPoint", mp.getType()); } |
GeoJsonMultiPoint extends MultiGeometry { public List<GeoJsonPoint> getPoints() { List<Geometry> geometryList = getGeometryObject(); ArrayList<GeoJsonPoint> geoJsonPoints = new ArrayList<GeoJsonPoint>(); for (Geometry geometry : geometryList) { GeoJsonPoint point = (GeoJsonPoint) geometry; geoJsonPoints.add(point); } return geoJsonPoints; } GeoJsonMultiPoint(List<GeoJsonPoint> geoJsonPoints); String getType(); List<GeoJsonPoint> getPoints(); } | @Test public void testGetPoints() { List<GeoJsonPoint> points = new ArrayList<>(); points.add(new GeoJsonPoint(new LatLng(0, 0))); points.add(new GeoJsonPoint(new LatLng(5, 5))); points.add(new GeoJsonPoint(new LatLng(10, 10))); mp = new GeoJsonMultiPoint(points); assertEquals(points, mp.getPoints()); points = new ArrayList<>(); mp = new GeoJsonMultiPoint(points); assertEquals(new ArrayList<GeoJsonPoint>(), mp.getPoints()); try { mp = new GeoJsonMultiPoint(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Geometries cannot be null", e.getMessage()); } } |
GeoJsonPolygon implements DataPolygon { public String getType() { return GEOMETRY_TYPE; } GeoJsonPolygon(
List<? extends List<LatLng>> coordinates); String getType(); List<? extends List<LatLng>> getCoordinates(); List<? extends List<LatLng>> getGeometryObject(); String getGeometryType(); ArrayList<LatLng> getOuterBoundaryCoordinates(); ArrayList<ArrayList<LatLng>> getInnerBoundaryCoordinates(); @Override String toString(); } | @Test public void testGetType() { List<List<LatLng>> coordinates = new ArrayList<>(); coordinates.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); p = new GeoJsonPolygon(coordinates); assertEquals("Polygon", p.getType()); } |
GeoJsonPolygon implements DataPolygon { public List<? extends List<LatLng>> getCoordinates() { return mCoordinates; } GeoJsonPolygon(
List<? extends List<LatLng>> coordinates); String getType(); List<? extends List<LatLng>> getCoordinates(); List<? extends List<LatLng>> getGeometryObject(); String getGeometryType(); ArrayList<LatLng> getOuterBoundaryCoordinates(); ArrayList<ArrayList<LatLng>> getInnerBoundaryCoordinates(); @Override String toString(); } | @Test public void testGetCoordinates() { List<List<LatLng>> coordinates = new ArrayList<>(); coordinates.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); p = new GeoJsonPolygon(coordinates); assertEquals(coordinates, p.getCoordinates()); coordinates.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); p = new GeoJsonPolygon(coordinates); try { p = new GeoJsonPolygon(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Coordinates cannot be null", e.getMessage()); } } |
GeoJsonRenderer extends Renderer implements Observer { public void setMap(GoogleMap map) { super.setMap(map); for (Feature feature : super.getFeatures()) { redrawFeatureToMap((GeoJsonFeature) feature, map); } } GeoJsonRenderer(GoogleMap map, HashMap<GeoJsonFeature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); void setMap(GoogleMap map); void addLayerToMap(); void addFeature(GeoJsonFeature feature); void removeLayerFromMap(); void removeFeature(GeoJsonFeature feature); void update(Observable observable, Object data); } | @Test public void testSetMap() throws Exception { mLayer = new GeoJsonLayer(mMap1, createFeatureCollection()); mMap1 = mLayer.getMap(); mRenderer.setMap(mMap1); assertEquals(mMap1, mRenderer.getMap()); mRenderer.setMap(null); assertNull(mRenderer.getMap()); } |
KmlPoint extends Point { public Double getAltitude() { return mAltitude; } KmlPoint(LatLng coordinates); KmlPoint(LatLng coordinates, Double altitude); Double getAltitude(); } | @Test public void testPointAltitude() { KmlPoint kmlPoint = createSimplePoint(); assertNotNull(kmlPoint); assertNull(kmlPoint.getAltitude()); kmlPoint = createSimplePointWithAltitudes(); assertNotNull(kmlPoint); assertNotNull(kmlPoint.getAltitude()); assertEquals(100.0, kmlPoint.getAltitude(), 0); } |
GeoJsonRenderer extends Renderer implements Observer { public void addFeature(GeoJsonFeature feature) { super.addFeature(feature); if (isLayerOnMap()) { feature.addObserver(this); } } GeoJsonRenderer(GoogleMap map, HashMap<GeoJsonFeature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); void setMap(GoogleMap map); void addLayerToMap(); void addFeature(GeoJsonFeature feature); void removeLayerFromMap(); void removeFeature(GeoJsonFeature feature); void update(Observable observable, Object data); } | @Test public void testAddFeature() { mRenderer.addFeature(mGeoJsonFeature); assertTrue(mRenderer.getFeatures().contains(mGeoJsonFeature)); } |
GeoJsonRenderer extends Renderer implements Observer { public void removeLayerFromMap() { if (isLayerOnMap()) { for (Feature feature : super.getFeatures()) { removeFromMap(super.getAllFeatures().get(feature)); feature.deleteObserver(this); } setLayerVisibility(false); } } GeoJsonRenderer(GoogleMap map, HashMap<GeoJsonFeature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); void setMap(GoogleMap map); void addLayerToMap(); void addFeature(GeoJsonFeature feature); void removeLayerFromMap(); void removeFeature(GeoJsonFeature feature); void update(Observable observable, Object data); } | @Test public void testRemoveLayerFromMap() throws Exception { mLayer = new GeoJsonLayer(mMap1, createFeatureCollection()); mRenderer.removeLayerFromMap(); assertEquals(mMap1, mRenderer.getMap()); } |
GeoJsonRenderer extends Renderer implements Observer { public void removeFeature(GeoJsonFeature feature) { super.removeFeature(feature); if (super.getFeatures().contains(feature)) { feature.deleteObserver(this); } } GeoJsonRenderer(GoogleMap map, HashMap<GeoJsonFeature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); void setMap(GoogleMap map); void addLayerToMap(); void addFeature(GeoJsonFeature feature); void removeLayerFromMap(); void removeFeature(GeoJsonFeature feature); void update(Observable observable, Object data); } | @Test public void testRemoveFeature() { mRenderer.addFeature(mGeoJsonFeature); mRenderer.removeFeature(mGeoJsonFeature); assertFalse(mRenderer.getFeatures().contains(mGeoJsonFeature)); } |
GeoJsonMultiPolygon extends MultiGeometry { public String getType() { return getGeometryType(); } GeoJsonMultiPolygon(List<GeoJsonPolygon> geoJsonPolygons); String getType(); List<GeoJsonPolygon> getPolygons(); } | @Test public void testGetType() { List<GeoJsonPolygon> polygons = new ArrayList<>(); List<ArrayList<LatLng>> polygon = new ArrayList<>(); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); polygons.add(new GeoJsonPolygon(polygon)); polygon = new ArrayList<>(); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(50, 80), new LatLng(10, 15), new LatLng(0, 0)))); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); polygons.add(new GeoJsonPolygon(polygon)); mp = new GeoJsonMultiPolygon(polygons); assertEquals("MultiPolygon", mp.getType()); } |
GeoJsonMultiPolygon extends MultiGeometry { public List<GeoJsonPolygon> getPolygons() { List<Geometry> geometryList = getGeometryObject(); ArrayList<GeoJsonPolygon> geoJsonPolygon = new ArrayList<GeoJsonPolygon>(); for (Geometry geometry : geometryList) { GeoJsonPolygon polygon = (GeoJsonPolygon) geometry; geoJsonPolygon.add(polygon); } return geoJsonPolygon; } GeoJsonMultiPolygon(List<GeoJsonPolygon> geoJsonPolygons); String getType(); List<GeoJsonPolygon> getPolygons(); } | @Test public void testGetPolygons() { List<GeoJsonPolygon> polygons = new ArrayList<>(); List<ArrayList<LatLng>> polygon = new ArrayList<>(); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); polygons.add(new GeoJsonPolygon(polygon)); polygon = new ArrayList<>(); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(50, 80), new LatLng(10, 15), new LatLng(0, 0)))); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); polygons.add(new GeoJsonPolygon(polygon)); mp = new GeoJsonMultiPolygon(polygons); assertEquals(polygons, mp.getPolygons()); polygons = new ArrayList<>(); mp = new GeoJsonMultiPolygon(polygons); assertEquals(new ArrayList<GeoJsonPolygon>(), mp.getPolygons()); try { mp = new GeoJsonMultiPolygon(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Geometries cannot be null", e.getMessage()); } } |
GeoJsonPolygonStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonPolygonStyle(); @Override String[] getGeometryType(); int getFillColor(); void setFillColor(int fillColor); boolean isGeodesic(); void setGeodesic(boolean geodesic); int getStrokeColor(); void setStrokeColor(int strokeColor); int getStrokeJointType(); void setStrokeJointType(int strokeJointType); List<PatternItem> getStrokePattern(); void setStrokePattern(List<PatternItem> strokePattern); float getStrokeWidth(); void setStrokeWidth(float strokeWidth); float getZIndex(); void setZIndex(float zIndex); @Override boolean isVisible(); @Override void setVisible(boolean visible); PolygonOptions toPolygonOptions(); @Override String toString(); void setClickable(boolean clickable); boolean isClickable(); } | @Test public void testGetGeometryType() { assertTrue(Arrays.asList(polygonStyle.getGeometryType()).contains("Polygon")); assertTrue(Arrays.asList(polygonStyle.getGeometryType()).contains("MultiPolygon")); assertTrue(Arrays.asList(polygonStyle.getGeometryType()).contains("GeometryCollection")); assertEquals(3, polygonStyle.getGeometryType().length); } |
Renderer { public GoogleMap getMap() { return mMap; } Renderer(GoogleMap map,
Context context,
MarkerManager markerManager,
PolygonManager polygonManager,
PolylineManager polylineManager,
GroundOverlayManager groundOverlayManager,
@Nullable ImagesCache imagesCache); Renderer(GoogleMap map, HashMap<? extends Feature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); private Renderer(GoogleMap map,
Set<String> markerIconUrls,
GeoJsonPointStyle defaultPointStyle,
GeoJsonLineStringStyle defaultLineStringStyle,
GeoJsonPolygonStyle defaultPolygonStyle,
BiMultiMap<Feature> containerFeatures,
MarkerManager markerManager,
PolygonManager polygonManager,
PolylineManager polylineManager,
GroundOverlayManager groundOverlayManager); boolean isLayerOnMap(); GoogleMap getMap(); void setMap(GoogleMap map); Set<Feature> getFeatures(); Collection<Object> getValues(); HashMap<KmlGroundOverlay, GroundOverlay> getGroundOverlayMap(); void assignStyleMap(HashMap<String, String> styleMap,
HashMap<String, KmlStyle> styles); } | @Test public void testGetMap() { assertEquals(mMap1, mRenderer.getMap()); } |
Renderer { public Set<Feature> getFeatures() { return mFeatures.keySet(); } Renderer(GoogleMap map,
Context context,
MarkerManager markerManager,
PolygonManager polygonManager,
PolylineManager polylineManager,
GroundOverlayManager groundOverlayManager,
@Nullable ImagesCache imagesCache); Renderer(GoogleMap map, HashMap<? extends Feature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); private Renderer(GoogleMap map,
Set<String> markerIconUrls,
GeoJsonPointStyle defaultPointStyle,
GeoJsonLineStringStyle defaultLineStringStyle,
GeoJsonPolygonStyle defaultPolygonStyle,
BiMultiMap<Feature> containerFeatures,
MarkerManager markerManager,
PolygonManager polygonManager,
PolylineManager polylineManager,
GroundOverlayManager groundOverlayManager); boolean isLayerOnMap(); GoogleMap getMap(); void setMap(GoogleMap map); Set<Feature> getFeatures(); Collection<Object> getValues(); HashMap<KmlGroundOverlay, GroundOverlay> getGroundOverlayMap(); void assignStyleMap(HashMap<String, String> styleMap,
HashMap<String, KmlStyle> styles); } | @Test public void testGetFeatures() { assertEquals(featureSet, mRenderer.getFeatures()); } |
Renderer { protected void addFeature(Feature feature) { Object mapObject = FEATURE_NOT_ON_MAP; if (feature instanceof GeoJsonFeature) { setFeatureDefaultStyles((GeoJsonFeature) feature); } if (mLayerOnMap) { if (mFeatures.containsKey(feature)) { removeFromMap(mFeatures.get(feature)); } if (feature.hasGeometry()) { if (feature instanceof KmlPlacemark) { boolean isPlacemarkVisible = getPlacemarkVisibility(feature); String placemarkId = feature.getId(); Geometry geometry = feature.getGeometry(); KmlStyle style = getPlacemarkStyle(placemarkId); KmlStyle inlineStyle = ((KmlPlacemark) feature).getInlineStyle(); mapObject = addKmlPlacemarkToMap((KmlPlacemark) feature, geometry, style, inlineStyle, isPlacemarkVisible); } else { mapObject = addGeoJsonFeatureToMap(feature, feature.getGeometry()); } } } mFeatures.put(feature, mapObject); } Renderer(GoogleMap map,
Context context,
MarkerManager markerManager,
PolygonManager polygonManager,
PolylineManager polylineManager,
GroundOverlayManager groundOverlayManager,
@Nullable ImagesCache imagesCache); Renderer(GoogleMap map, HashMap<? extends Feature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); private Renderer(GoogleMap map,
Set<String> markerIconUrls,
GeoJsonPointStyle defaultPointStyle,
GeoJsonLineStringStyle defaultLineStringStyle,
GeoJsonPolygonStyle defaultPolygonStyle,
BiMultiMap<Feature> containerFeatures,
MarkerManager markerManager,
PolygonManager polygonManager,
PolylineManager polylineManager,
GroundOverlayManager groundOverlayManager); boolean isLayerOnMap(); GoogleMap getMap(); void setMap(GoogleMap map); Set<Feature> getFeatures(); Collection<Object> getValues(); HashMap<KmlGroundOverlay, GroundOverlay> getGroundOverlayMap(); void assignStyleMap(HashMap<String, String> styleMap,
HashMap<String, KmlStyle> styles); } | @Test public void testAddFeature() { Point p = new Point(new LatLng(30, 50)); Feature feature1 = new Feature(p, null, null); mRenderer.addFeature(feature1); assertTrue(mRenderer.getFeatures().contains(feature1)); } |
Renderer { protected void removeFeature(Feature feature) { if (mFeatures.containsKey(feature)) { removeFromMap(mFeatures.remove(feature)); } } Renderer(GoogleMap map,
Context context,
MarkerManager markerManager,
PolygonManager polygonManager,
PolylineManager polylineManager,
GroundOverlayManager groundOverlayManager,
@Nullable ImagesCache imagesCache); Renderer(GoogleMap map, HashMap<? extends Feature, Object> features, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); private Renderer(GoogleMap map,
Set<String> markerIconUrls,
GeoJsonPointStyle defaultPointStyle,
GeoJsonLineStringStyle defaultLineStringStyle,
GeoJsonPolygonStyle defaultPolygonStyle,
BiMultiMap<Feature> containerFeatures,
MarkerManager markerManager,
PolygonManager polygonManager,
PolylineManager polylineManager,
GroundOverlayManager groundOverlayManager); boolean isLayerOnMap(); GoogleMap getMap(); void setMap(GoogleMap map); Set<Feature> getFeatures(); Collection<Object> getValues(); HashMap<KmlGroundOverlay, GroundOverlay> getGroundOverlayMap(); void assignStyleMap(HashMap<String, String> styleMap,
HashMap<String, KmlStyle> styles); } | @Test public void testRemoveFeature() { Point p = new Point(new LatLng(40, 50)); Feature feature1 = new Feature(p, null, null); mRenderer.addFeature(feature1); mRenderer.removeFeature(feature1); assertFalse(mRenderer.getFeatures().contains(feature1)); } |
KmlPolygon implements DataPolygon<ArrayList<ArrayList<LatLng>>> { public String getGeometryType() { return GEOMETRY_TYPE; } KmlPolygon(List<LatLng> outerBoundaryCoordinates,
List<List<LatLng>> innerBoundaryCoordinates); String getGeometryType(); List<List<LatLng>> getGeometryObject(); List<LatLng> getOuterBoundaryCoordinates(); List<List<LatLng>> getInnerBoundaryCoordinates(); @Override String toString(); static final String GEOMETRY_TYPE; } | @Test public void testGetType() { KmlPolygon kmlPolygon = createRegularPolygon(); assertNotNull(kmlPolygon); assertNotNull(kmlPolygon.getGeometryType()); assertEquals("Polygon", kmlPolygon.getGeometryType()); } |
Point implements Geometry { public String getGeometryType() { return GEOMETRY_TYPE; } Point(LatLng coordinates); String getGeometryType(); LatLng getGeometryObject(); @Override String toString(); } | @Test public void testGetGeometryType() { Point p = new Point(new LatLng(0, 50)); assertEquals("Point", p.getGeometryType()); } |
Point implements Geometry { public LatLng getGeometryObject() { return mCoordinates; } Point(LatLng coordinates); String getGeometryType(); LatLng getGeometryObject(); @Override String toString(); } | @Test public void testGetGeometryObject() { Point p = new Point(new LatLng(0, 50)); assertEquals(new LatLng(0, 50), p.getGeometryObject()); try { new Point(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Coordinates cannot be null", e.getMessage()); } } |
Feature extends Observable { public String getId() { return mId; } Feature(Geometry featureGeometry, String id,
Map<String, String> properties); Iterable<String> getPropertyKeys(); Iterable getProperties(); String getProperty(String property); String getId(); boolean hasProperty(String property); Geometry getGeometry(); boolean hasProperties(); boolean hasGeometry(); } | @Test public void testGetId() { Feature feature = new Feature(null, "Pirate", null); assertNotNull(feature.getId()); assertEquals("Pirate", feature.getId()); feature = new Feature(null, null, null); assertNull(feature.getId()); } |
Gradient { static int interpolateColor(int color1, int color2, float ratio) { int alpha = (int) ((Color.alpha(color2) - Color.alpha(color1)) * ratio + Color.alpha(color1)); float[] hsv1 = new float[3]; Color.RGBToHSV(Color.red(color1), Color.green(color1), Color.blue(color1), hsv1); float[] hsv2 = new float[3]; Color.RGBToHSV(Color.red(color2), Color.green(color2), Color.blue(color2), hsv2); if (hsv1[0] - hsv2[0] > 180) { hsv2[0] += 360; } else if (hsv2[0] - hsv1[0] > 180) { hsv1[0] += 360; } float[] result = new float[3]; for (int i = 0; i < 3; i++) { result[i] = (hsv2[i] - hsv1[i]) * (ratio) + hsv1[i]; } return Color.HSVToColor(alpha, result); } Gradient(int[] colors, float[] startPoints); Gradient(int[] colors, float[] startPoints, int colorMapSize); final int mColorMapSize; public int[] mColors; public float[] mStartPoints; } | @Test public void testInterpolateColor() { assertEquals(RED, Gradient.interpolateColor(RED, RED, 0.5f)); assertEquals(BLUE, Gradient.interpolateColor(BLUE, BLUE, 0.5f)); assertEquals(GREEN, Gradient.interpolateColor(GREEN, GREEN, 0.5f)); int result = Gradient.interpolateColor(RED, BLUE, 0); assertEquals(RED, result); result = Gradient.interpolateColor(RED, BLUE, 1); assertEquals(BLUE, result); assertEquals( Gradient.interpolateColor(BLUE, RED, 0.5f), Gradient.interpolateColor(RED, BLUE, 0.5f)); assertEquals( Gradient.interpolateColor(BLUE, RED, 0.8f), Gradient.interpolateColor(RED, BLUE, 0.2f)); assertEquals( Gradient.interpolateColor(BLUE, RED, 0.2f), Gradient.interpolateColor(RED, BLUE, 0.8f)); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { assertEquals(-65434, Gradient.interpolateColor(RED, BLUE, 0.2f)); assertEquals(Color.MAGENTA, Gradient.interpolateColor(RED, BLUE, 0.5f)); assertEquals(-10092289, Gradient.interpolateColor(RED, BLUE, 0.8f)); assertEquals(Color.YELLOW, Gradient.interpolateColor(RED, GREEN, 0.5f)); assertEquals(Color.CYAN, Gradient.interpolateColor(BLUE, GREEN, 0.5f)); } } |
Gradient { int[] generateColorMap(double opacity) { HashMap<Integer, ColorInterval> colorIntervals = generateColorIntervals(); int[] colorMap = new int[mColorMapSize]; ColorInterval interval = colorIntervals.get(0); int start = 0; for (int i = 0; i < mColorMapSize; i++) { if (colorIntervals.containsKey(i)) { interval = colorIntervals.get(i); start = i; } float ratio = (i - start) / interval.duration; colorMap[i] = interpolateColor(interval.color1, interval.color2, ratio); } if (opacity != 1) { for (int i = 0; i < mColorMapSize; i++) { int c = colorMap[i]; colorMap[i] = Color.argb((int) (Color.alpha(c) * opacity), Color.red(c), Color.green(c), Color.blue(c)); } } return colorMap; } Gradient(int[] colors, float[] startPoints); Gradient(int[] colors, float[] startPoints, int colorMapSize); final int mColorMapSize; public int[] mColors; public float[] mStartPoints; } | @Test public void testMoreColorsThanColorMap() { int[] colors = {Color.argb(0, 0, 255, 0), GREEN, RED, BLUE}; float[] startPoints = {0f, 0.2f, 0.5f, 1f}; Gradient g = new Gradient(colors, startPoints, 2); int[] colorMap = g.generateColorMap(1.0); assertEquals(GREEN, colorMap[0]); assertEquals(RED, colorMap[1]); } |
PointQuadTree { public void clear() { mChildren = null; if (mItems != null) { mItems.clear(); } } PointQuadTree(double minX, double maxX, double minY, double maxY); PointQuadTree(Bounds bounds); private PointQuadTree(double minX, double maxX, double minY, double maxY, int depth); private PointQuadTree(Bounds bounds, int depth); void add(T item); boolean remove(T item); void clear(); Collection<T> search(Bounds searchBounds); } | @Test public void testClear() { mTree.add(new Item(.1, .1)); mTree.add(new Item(.2, .2)); mTree.add(new Item(.3, .3)); mTree.clear(); Assert.assertEquals(0, searchAll().size()); } |
PointQuadTree { public Collection<T> search(Bounds searchBounds) { final List<T> results = new ArrayList<T>(); search(searchBounds, results); return results; } PointQuadTree(double minX, double maxX, double minY, double maxY); PointQuadTree(Bounds bounds); private PointQuadTree(double minX, double maxX, double minY, double maxY, int depth); private PointQuadTree(Bounds bounds, int depth); void add(T item); boolean remove(T item); void clear(); Collection<T> search(Bounds searchBounds); } | @Test public void testSearch() { System.gc(); for (int i = 0; i < 10000; i++) { mTree.add(new Item(i / 20000.0, i / 20000.0)); } Assert.assertEquals(10000, searchAll().size()); Assert.assertEquals( 1, mTree.search(new Bounds((double) 0, 0.00001, (double) 0, 0.00001)).size()); Assert.assertEquals(0, mTree.search(new Bounds(.7, .8, .7, .8)).size()); mTree.clear(); System.gc(); } |
SphericalUtil { static double computeAngleBetween(LatLng from, LatLng to) { return distanceRadians(toRadians(from.latitude), toRadians(from.longitude), toRadians(to.latitude), toRadians(to.longitude)); } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testAngles() { assertEquals(SphericalUtil.computeAngleBetween(up, up), 0, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(down, down), 0, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(left, left), 0, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(right, right), 0, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(front, front), 0, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(back, back), 0, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(up, front), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(up, right), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(up, back), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(up, left), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(down, front), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(down, right), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(down, back), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(down, left), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(back, up), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(back, right), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(back, down), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(back, left), Math.PI / 2, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(up, down), Math.PI, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(front, back), Math.PI, 1e-6); assertEquals(SphericalUtil.computeAngleBetween(left, right), Math.PI, 1e-6); } |
SphericalUtil { public static double computeDistanceBetween(LatLng from, LatLng to) { return computeAngleBetween(from, to) * EARTH_RADIUS; } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testDistances() { assertEquals(SphericalUtil.computeDistanceBetween(up, down), Math.PI * EARTH_RADIUS, 1e-6); } |
SphericalUtil { public static double computeHeading(LatLng from, LatLng to) { double fromLat = toRadians(from.latitude); double fromLng = toRadians(from.longitude); double toLat = toRadians(to.latitude); double toLng = toRadians(to.longitude); double dLng = toLng - fromLng; double heading = atan2( sin(dLng) * cos(toLat), cos(fromLat) * sin(toLat) - sin(fromLat) * cos(toLat) * cos(dLng)); return wrap(toDegrees(heading), -180, 180); } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testHeadings() { assertEquals(SphericalUtil.computeHeading(up, down), -180, 1e-6); assertEquals(SphericalUtil.computeHeading(down, up), 0, 1e-6); assertEquals(SphericalUtil.computeHeading(front, up), 0, 1e-6); assertEquals(SphericalUtil.computeHeading(right, up), 0, 1e-6); assertEquals(SphericalUtil.computeHeading(back, up), 0, 1e-6); assertEquals(SphericalUtil.computeHeading(down, up), 0, 1e-6); assertEquals(SphericalUtil.computeHeading(front, down), -180, 1e-6); assertEquals(SphericalUtil.computeHeading(right, down), -180, 1e-6); assertEquals(SphericalUtil.computeHeading(back, down), -180, 1e-6); assertEquals(SphericalUtil.computeHeading(left, down), -180, 1e-6); assertEquals(SphericalUtil.computeHeading(right, front), -90, 1e-6); assertEquals(SphericalUtil.computeHeading(left, front), 90, 1e-6); assertEquals(SphericalUtil.computeHeading(front, right), 90, 1e-6); assertEquals(SphericalUtil.computeHeading(back, right), -90, 1e-6); } |
KmlPolygon implements DataPolygon<ArrayList<ArrayList<LatLng>>> { public List<LatLng> getOuterBoundaryCoordinates() { return mOuterBoundaryCoordinates; } KmlPolygon(List<LatLng> outerBoundaryCoordinates,
List<List<LatLng>> innerBoundaryCoordinates); String getGeometryType(); List<List<LatLng>> getGeometryObject(); List<LatLng> getOuterBoundaryCoordinates(); List<List<LatLng>> getInnerBoundaryCoordinates(); @Override String toString(); static final String GEOMETRY_TYPE; } | @Test public void testGetOuterBoundaryCoordinates() { KmlPolygon kmlPolygon = createRegularPolygon(); assertNotNull(kmlPolygon); assertNotNull(kmlPolygon.getOuterBoundaryCoordinates()); kmlPolygon = createOuterPolygon(); assertNotNull(kmlPolygon); assertNotNull(kmlPolygon.getOuterBoundaryCoordinates()); } |
SphericalUtil { public static LatLng computeOffset(LatLng from, double distance, double heading) { distance /= EARTH_RADIUS; heading = toRadians(heading); double fromLat = toRadians(from.latitude); double fromLng = toRadians(from.longitude); double cosDistance = cos(distance); double sinDistance = sin(distance); double sinFromLat = sin(fromLat); double cosFromLat = cos(fromLat); double sinLat = cosDistance * sinFromLat + sinDistance * cosFromLat * cos(heading); double dLng = atan2( sinDistance * cosFromLat * sin(heading), cosDistance - sinFromLat * sinLat); return new LatLng(toDegrees(asin(sinLat)), toDegrees(fromLng + dLng)); } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testComputeOffset() { expectLatLngApproxEquals(front, SphericalUtil.computeOffset(front, 0, 0)); expectLatLngApproxEquals( up, SphericalUtil.computeOffset(front, Math.PI * EARTH_RADIUS / 2, 0)); expectLatLngApproxEquals( down, SphericalUtil.computeOffset(front, Math.PI * EARTH_RADIUS / 2, 180)); expectLatLngApproxEquals( left, SphericalUtil.computeOffset(front, Math.PI * EARTH_RADIUS / 2, -90)); expectLatLngApproxEquals( right, SphericalUtil.computeOffset(front, Math.PI * EARTH_RADIUS / 2, 90)); expectLatLngApproxEquals( back, SphericalUtil.computeOffset(front, Math.PI * EARTH_RADIUS, 0)); expectLatLngApproxEquals( back, SphericalUtil.computeOffset(front, Math.PI * EARTH_RADIUS, 90)); expectLatLngApproxEquals(left, SphericalUtil.computeOffset(left, 0, 0)); expectLatLngApproxEquals( up, SphericalUtil.computeOffset(left, Math.PI * EARTH_RADIUS / 2, 0)); expectLatLngApproxEquals( down, SphericalUtil.computeOffset(left, Math.PI * EARTH_RADIUS / 2, 180)); expectLatLngApproxEquals( front, SphericalUtil.computeOffset(left, Math.PI * EARTH_RADIUS / 2, 90)); expectLatLngApproxEquals( back, SphericalUtil.computeOffset(left, Math.PI * EARTH_RADIUS / 2, -90)); expectLatLngApproxEquals( right, SphericalUtil.computeOffset(left, Math.PI * EARTH_RADIUS, 0)); expectLatLngApproxEquals( right, SphericalUtil.computeOffset(left, Math.PI * EARTH_RADIUS, 90)); } |
SphericalUtil { public static LatLng computeOffsetOrigin(LatLng to, double distance, double heading) { heading = toRadians(heading); distance /= EARTH_RADIUS; double n1 = cos(distance); double n2 = sin(distance) * cos(heading); double n3 = sin(distance) * sin(heading); double n4 = sin(toRadians(to.latitude)); double n12 = n1 * n1; double discriminant = n2 * n2 * n12 + n12 * n12 - n12 * n4 * n4; if (discriminant < 0) { return null; } double b = n2 * n4 + sqrt(discriminant); b /= n1 * n1 + n2 * n2; double a = (n4 - n2 * b) / n1; double fromLatRadians = atan2(a, b); if (fromLatRadians < -PI / 2 || fromLatRadians > PI / 2) { b = n2 * n4 - sqrt(discriminant); b /= n1 * n1 + n2 * n2; fromLatRadians = atan2(a, b); } if (fromLatRadians < -PI / 2 || fromLatRadians > PI / 2) { return null; } double fromLngRadians = toRadians(to.longitude) - atan2(n3, n1 * cos(fromLatRadians) - n2 * sin(fromLatRadians)); return new LatLng(toDegrees(fromLatRadians), toDegrees(fromLngRadians)); } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testComputeOffsetOrigin() { expectLatLngApproxEquals(front, SphericalUtil.computeOffsetOrigin(front, 0, 0)); expectLatLngApproxEquals( front, SphericalUtil.computeOffsetOrigin( new LatLng(0, 45), Math.PI * EARTH_RADIUS / 4, 90)); expectLatLngApproxEquals( front, SphericalUtil.computeOffsetOrigin( new LatLng(0, -45), Math.PI * EARTH_RADIUS / 4, -90)); expectLatLngApproxEquals( front, SphericalUtil.computeOffsetOrigin( new LatLng(45, 0), Math.PI * EARTH_RADIUS / 4, 0)); expectLatLngApproxEquals( front, SphericalUtil.computeOffsetOrigin( new LatLng(-45, 0), Math.PI * EARTH_RADIUS / 4, 180)); assertNull( SphericalUtil.computeOffsetOrigin( new LatLng(80, 0), Math.PI * EARTH_RADIUS / 4, 180)); assertNull( SphericalUtil.computeOffsetOrigin( new LatLng(80, 0), Math.PI * EARTH_RADIUS / 4, 90)); } |
SphericalUtil { public static LatLng interpolate(LatLng from, LatLng to, double fraction) { double fromLat = toRadians(from.latitude); double fromLng = toRadians(from.longitude); double toLat = toRadians(to.latitude); double toLng = toRadians(to.longitude); double cosFromLat = cos(fromLat); double cosToLat = cos(toLat); double angle = computeAngleBetween(from, to); double sinAngle = sin(angle); if (sinAngle < 1E-6) { return new LatLng( from.latitude + fraction * (to.latitude - from.latitude), from.longitude + fraction * (to.longitude - from.longitude)); } double a = sin((1 - fraction) * angle) / sinAngle; double b = sin(fraction * angle) / sinAngle; double x = a * cosFromLat * cos(fromLng) + b * cosToLat * cos(toLng); double y = a * cosFromLat * sin(fromLng) + b * cosToLat * sin(toLng); double z = a * sin(fromLat) + b * sin(toLat); double lat = atan2(z, sqrt(x * x + y * y)); double lng = atan2(y, x); return new LatLng(toDegrees(lat), toDegrees(lng)); } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testInterpolate() { expectLatLngApproxEquals(up, SphericalUtil.interpolate(up, up, 1 / 2.0)); expectLatLngApproxEquals(down, SphericalUtil.interpolate(down, down, 1 / 2.0)); expectLatLngApproxEquals(left, SphericalUtil.interpolate(left, left, 1 / 2.0)); expectLatLngApproxEquals(new LatLng(1, 0), SphericalUtil.interpolate(front, up, 1 / 90.0)); expectLatLngApproxEquals(new LatLng(1, 0), SphericalUtil.interpolate(up, front, 89 / 90.0)); expectLatLngApproxEquals( new LatLng(89, 0), SphericalUtil.interpolate(front, up, 89 / 90.0)); expectLatLngApproxEquals(new LatLng(89, 0), SphericalUtil.interpolate(up, front, 1 / 90.0)); expectLatLngApproxEquals( new LatLng(-1, 0), SphericalUtil.interpolate(front, down, 1 / 90.0)); expectLatLngApproxEquals( new LatLng(-1, 0), SphericalUtil.interpolate(down, front, 89 / 90.0)); expectLatLngApproxEquals( new LatLng(-89, 0), SphericalUtil.interpolate(front, down, 89 / 90.0)); expectLatLngApproxEquals( new LatLng(-89, 0), SphericalUtil.interpolate(down, front, 1 / 90.0)); expectLatLngApproxEquals( new LatLng(0, -91), SphericalUtil.interpolate(left, back, 1 / 90.0)); expectLatLngApproxEquals( new LatLng(0, -91), SphericalUtil.interpolate(back, left, 89 / 90.0)); expectLatLngApproxEquals( new LatLng(0, -179), SphericalUtil.interpolate(left, back, 89 / 90.0)); expectLatLngApproxEquals( new LatLng(0, -179), SphericalUtil.interpolate(back, left, 1 / 90.0)); expectLatLngApproxEquals( up, SphericalUtil.interpolate(new LatLng(45, 0), new LatLng(45, 180), 1 / 2.0)); expectLatLngApproxEquals( down, SphericalUtil.interpolate(new LatLng(-45, 0), new LatLng(-45, 180), 1 / 2.0)); expectLatLngApproxEquals(left, SphericalUtil.interpolate(left, back, 0)); expectLatLngApproxEquals(back, SphericalUtil.interpolate(left, back, 1.0)); expectLatLngApproxEquals( new LatLng(-37.756872, 175.325252), SphericalUtil.interpolate( new LatLng(-37.756891, 175.325262), new LatLng(-37.756853, 175.325242), 0.5)); } |
SphericalUtil { public static double computeLength(List<LatLng> path) { if (path.size() < 2) { return 0; } double length = 0; LatLng prev = path.get(0); double prevLat = toRadians(prev.latitude); double prevLng = toRadians(prev.longitude); for (LatLng point : path) { double lat = toRadians(point.latitude); double lng = toRadians(point.longitude); length += distanceRadians(prevLat, prevLng, lat, lng); prevLat = lat; prevLng = lng; } return length * EARTH_RADIUS; } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testComputeLength() { List<LatLng> latLngs; assertEquals(SphericalUtil.computeLength(Collections.<LatLng>emptyList()), 0, 1e-6); assertEquals(SphericalUtil.computeLength(Arrays.asList(new LatLng(0, 0))), 0, 1e-6); latLngs = Arrays.asList(new LatLng(0, 0), new LatLng(0.1, 0.1)); assertEquals( SphericalUtil.computeLength(latLngs), Math.toRadians(0.1) * Math.sqrt(2) * EARTH_RADIUS, 1); latLngs = Arrays.asList(new LatLng(0, 0), new LatLng(90, 0), new LatLng(0, 90)); assertEquals(SphericalUtil.computeLength(latLngs), Math.PI * EARTH_RADIUS, 1e-6); } |
SphericalUtil { public static double computeArea(List<LatLng> path) { return abs(computeSignedArea(path)); } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testComputeArea() { assertEquals( SphericalUtil.computeArea(Arrays.asList(right, up, front, down, right)), Math.PI * EARTH_RADIUS * EARTH_RADIUS, .4); assertEquals( SphericalUtil.computeArea(Arrays.asList(right, down, front, up, right)), Math.PI * EARTH_RADIUS * EARTH_RADIUS, .4); } |
SphericalUtil { public static double computeSignedArea(List<LatLng> path) { return computeSignedArea(path, EARTH_RADIUS); } private SphericalUtil(); static double computeHeading(LatLng from, LatLng to); static LatLng computeOffset(LatLng from, double distance, double heading); static LatLng computeOffsetOrigin(LatLng to, double distance, double heading); static LatLng interpolate(LatLng from, LatLng to, double fraction); static double computeDistanceBetween(LatLng from, LatLng to); static double computeLength(List<LatLng> path); static double computeArea(List<LatLng> path); static double computeSignedArea(List<LatLng> path); } | @Test public void testComputeSignedArea() { List<LatLng> path = Arrays.asList(right, up, front, down, right); List<LatLng> pathReversed = Arrays.asList(right, down, front, up, right); assertEquals( -SphericalUtil.computeSignedArea(path), SphericalUtil.computeSignedArea(pathReversed), 0); } |
PolyUtil { public static boolean containsLocation(LatLng point, List<LatLng> polygon, boolean geodesic) { return containsLocation(point.latitude, point.longitude, polygon, geodesic); } private PolyUtil(); static boolean containsLocation(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean containsLocation(double latitude, double longitude, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic,
double tolerance); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic, double tolerance); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnPath(LatLng point, List<LatLng> poly,
boolean geodesic, double tolerance); static int locationIndexOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnEdgeOrPath(LatLng point, List<LatLng> poly, boolean closed,
boolean geodesic, double toleranceEarth); static List<LatLng> simplify(List<LatLng> poly, double tolerance); static boolean isClosedPolygon(List<LatLng> poly); static double distanceToLine(final LatLng p, final LatLng start, final LatLng end); static List<LatLng> decode(final String encodedPath); static String encode(final List<LatLng> path); static final double DEFAULT_TOLERANCE; } | @Test public void testContainsLocation() { containsCase(makeList(), makeList(), makeList(0, 0)); containsCase(makeList(1, 2), makeList(1, 2), makeList(0, 0)); containsCase(makeList(1, 2, 3, 5), makeList(1, 2, 3, 5), makeList(0, 0, 40, 4)); containsCase( makeList(0., 0., 10., 12., 20., 5.), makeList(10., 12., 10, 11, 19, 5), makeList(0, 1, 11, 12, 30, 5, 0, -180, 0, 90)); containsCase( makeList(89, 0, 89, 120, 89, -120), makeList(90, 0, 90, 180, 90, -90), makeList(-90, 0, 0, 0)); containsCase( makeList(-89, 0, -89, 120, -89, -120), makeList(90, 0, 90, 180, 90, -90, 0, 0), makeList(-90, 0, -90, 90)); containsCase( makeList(5, 10, 10, 10, 0, 20, 0, -10), makeList(2.5, 10, 1, 0), makeList(15, 10, 0, -15, 0, 25, -1, 0)); } |
PolyUtil { public static List<LatLng> simplify(List<LatLng> poly, double tolerance) { final int n = poly.size(); if (n < 1) { throw new IllegalArgumentException("Polyline must have at least 1 point"); } if (tolerance <= 0) { throw new IllegalArgumentException("Tolerance must be greater than zero"); } boolean closedPolygon = isClosedPolygon(poly); LatLng lastPoint = null; if (closedPolygon) { final double OFFSET = 0.00000000001; lastPoint = poly.get(poly.size() - 1); poly.remove(poly.size() - 1); poly.add(new LatLng(lastPoint.latitude + OFFSET, lastPoint.longitude + OFFSET)); } int idx; int maxIdx = 0; Stack<int[]> stack = new Stack<>(); double[] dists = new double[n]; dists[0] = 1; dists[n - 1] = 1; double maxDist; double dist = 0.0; int[] current; if (n > 2) { int[] stackVal = new int[]{0, (n - 1)}; stack.push(stackVal); while (stack.size() > 0) { current = stack.pop(); maxDist = 0; for (idx = current[0] + 1; idx < current[1]; ++idx) { dist = distanceToLine(poly.get(idx), poly.get(current[0]), poly.get(current[1])); if (dist > maxDist) { maxDist = dist; maxIdx = idx; } } if (maxDist > tolerance) { dists[maxIdx] = maxDist; int[] stackValCurMax = {current[0], maxIdx}; stack.push(stackValCurMax); int[] stackValMaxCur = {maxIdx, current[1]}; stack.push(stackValMaxCur); } } } if (closedPolygon) { poly.remove(poly.size() - 1); poly.add(lastPoint); } idx = 0; ArrayList<LatLng> simplifiedLine = new ArrayList<>(); for (LatLng l : poly) { if (dists[idx] != 0) { simplifiedLine.add(l); } idx++; } return simplifiedLine; } private PolyUtil(); static boolean containsLocation(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean containsLocation(double latitude, double longitude, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic,
double tolerance); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic, double tolerance); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnPath(LatLng point, List<LatLng> poly,
boolean geodesic, double tolerance); static int locationIndexOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnEdgeOrPath(LatLng point, List<LatLng> poly, boolean closed,
boolean geodesic, double toleranceEarth); static List<LatLng> simplify(List<LatLng> poly, double tolerance); static boolean isClosedPolygon(List<LatLng> poly); static double distanceToLine(final LatLng p, final LatLng start, final LatLng end); static List<LatLng> decode(final String encodedPath); static String encode(final List<LatLng> path); static final double DEFAULT_TOLERANCE; } | @Test public void testSimplify() { final String LINE = "elfjD~a}uNOnFN~Em@fJv@tEMhGDjDe@hG^nF??@lA?n@IvAC`Ay@A{@DwCA{CF_EC{CEi@PBTFDJBJ?V?n@?D@?A@?@?F?F?LAf@?n@@`@@T@~@FpA?fA?p@?r@?vAH`@OR@^ETFJCLD?JA^?J?P?fAC`B@d@?b@A\\@`@Ad@@\\?`@?f@?V?H?DD@DDBBDBD?D?B?B@B@@@B@B@B@D?D?JAF@H@FCLADBDBDCFAN?b@Af@@x@@"; List<LatLng> line = PolyUtil.decode(LINE); assertEquals(95, line.size()); List<LatLng> simplifiedLine; List<LatLng> copy; double tolerance = 5; copy = new ArrayList<>(line); simplifiedLine = PolyUtil.simplify(line, tolerance); assertEquals(20, simplifiedLine.size()); assertEndPoints(line, simplifiedLine); assertSimplifiedPointsFromLine(line, simplifiedLine); assertLineLength(line, simplifiedLine); assertInputUnchanged(line, copy); tolerance = 10; copy = new ArrayList<>(line); simplifiedLine = PolyUtil.simplify(line, tolerance); assertEquals(14, simplifiedLine.size()); assertEndPoints(line, simplifiedLine); assertSimplifiedPointsFromLine(line, simplifiedLine); assertLineLength(line, simplifiedLine); assertInputUnchanged(line, copy); tolerance = 15; copy = new ArrayList<>(line); simplifiedLine = PolyUtil.simplify(line, tolerance); assertEquals(10, simplifiedLine.size()); assertEndPoints(line, simplifiedLine); assertSimplifiedPointsFromLine(line, simplifiedLine); assertLineLength(line, simplifiedLine); assertInputUnchanged(line, copy); tolerance = 20; copy = new ArrayList<>(line); simplifiedLine = PolyUtil.simplify(line, tolerance); assertEquals(8, simplifiedLine.size()); assertEndPoints(line, simplifiedLine); assertSimplifiedPointsFromLine(line, simplifiedLine); assertLineLength(line, simplifiedLine); assertInputUnchanged(line, copy); tolerance = 50; copy = new ArrayList<>(line); simplifiedLine = PolyUtil.simplify(line, tolerance); assertEquals(6, simplifiedLine.size()); assertEndPoints(line, simplifiedLine); assertSimplifiedPointsFromLine(line, simplifiedLine); assertLineLength(line, simplifiedLine); assertInputUnchanged(line, copy); tolerance = 500; copy = new ArrayList<>(line); simplifiedLine = PolyUtil.simplify(line, tolerance); assertEquals(3, simplifiedLine.size()); assertEndPoints(line, simplifiedLine); assertSimplifiedPointsFromLine(line, simplifiedLine); assertLineLength(line, simplifiedLine); assertInputUnchanged(line, copy); tolerance = 1000; copy = new ArrayList<>(line); simplifiedLine = PolyUtil.simplify(line, tolerance); assertEquals(2, simplifiedLine.size()); assertEndPoints(line, simplifiedLine); assertSimplifiedPointsFromLine(line, simplifiedLine); assertLineLength(line, simplifiedLine); assertInputUnchanged(line, copy); ArrayList<LatLng> triangle = new ArrayList<>(); triangle.add(new LatLng(28.06025, -82.41030)); triangle.add(new LatLng(28.06129, -82.40945)); triangle.add(new LatLng(28.06206, -82.40917)); triangle.add(new LatLng(28.06125, -82.40850)); triangle.add(new LatLng(28.06035, -82.40834)); triangle.add(new LatLng(28.06038, -82.40924)); assertFalse(PolyUtil.isClosedPolygon(triangle)); copy = new ArrayList<>(triangle); tolerance = 88; List<LatLng> simplifiedTriangle = PolyUtil.simplify(triangle, tolerance); assertEquals(4, simplifiedTriangle.size()); assertEndPoints(triangle, simplifiedTriangle); assertSimplifiedPointsFromLine(triangle, simplifiedTriangle); assertLineLength(triangle, simplifiedTriangle); assertInputUnchanged(triangle, copy); LatLng p = triangle.get(0); LatLng closePoint = new LatLng(p.latitude, p.longitude); triangle.add(closePoint); assertTrue(PolyUtil.isClosedPolygon(triangle)); copy = new ArrayList<>(triangle); tolerance = 88; simplifiedTriangle = PolyUtil.simplify(triangle, tolerance); assertEquals(4, simplifiedTriangle.size()); assertEndPoints(triangle, simplifiedTriangle); assertSimplifiedPointsFromLine(triangle, simplifiedTriangle); assertLineLength(triangle, simplifiedTriangle); assertInputUnchanged(triangle, copy); final String OVAL_POLYGON = "}wgjDxw_vNuAd@}AN{A]w@_Au@kAUaA?{@Ke@@_@C]D[FULWFOLSNMTOVOXO\\I\\CX?VJXJTDTNXTVVLVJ`@FXA\\AVLZBTATBZ@ZAT?\\?VFT@XGZ"; List<LatLng> oval = PolyUtil.decode(OVAL_POLYGON); assertFalse(PolyUtil.isClosedPolygon(oval)); copy = new ArrayList<>(oval); tolerance = 10; List<LatLng> simplifiedOval = PolyUtil.simplify(oval, tolerance); assertEquals(13, simplifiedOval.size()); assertEndPoints(oval, simplifiedOval); assertSimplifiedPointsFromLine(oval, simplifiedOval); assertLineLength(oval, simplifiedOval); assertInputUnchanged(oval, copy); p = oval.get(0); closePoint = new LatLng(p.latitude, p.longitude); oval.add(closePoint); assertTrue(PolyUtil.isClosedPolygon(oval)); copy = new ArrayList<>(oval); tolerance = 10; simplifiedOval = PolyUtil.simplify(oval, tolerance); assertEquals(13, simplifiedOval.size()); assertEndPoints(oval, simplifiedOval); assertSimplifiedPointsFromLine(oval, simplifiedOval); assertLineLength(oval, simplifiedOval); assertInputUnchanged(oval, copy); } |
PolyUtil { public static boolean isClosedPolygon(List<LatLng> poly) { LatLng firstPoint = poly.get(0); LatLng lastPoint = poly.get(poly.size() - 1); return firstPoint.equals(lastPoint); } private PolyUtil(); static boolean containsLocation(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean containsLocation(double latitude, double longitude, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic,
double tolerance); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic, double tolerance); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnPath(LatLng point, List<LatLng> poly,
boolean geodesic, double tolerance); static int locationIndexOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnEdgeOrPath(LatLng point, List<LatLng> poly, boolean closed,
boolean geodesic, double toleranceEarth); static List<LatLng> simplify(List<LatLng> poly, double tolerance); static boolean isClosedPolygon(List<LatLng> poly); static double distanceToLine(final LatLng p, final LatLng start, final LatLng end); static List<LatLng> decode(final String encodedPath); static String encode(final List<LatLng> path); static final double DEFAULT_TOLERANCE; } | @Test public void testIsClosedPolygon() { ArrayList<LatLng> poly = new ArrayList<>(); poly.add(new LatLng(28.06025, -82.41030)); poly.add(new LatLng(28.06129, -82.40945)); poly.add(new LatLng(28.06206, -82.40917)); poly.add(new LatLng(28.06125, -82.40850)); poly.add(new LatLng(28.06035, -82.40834)); assertFalse(PolyUtil.isClosedPolygon(poly)); poly.add(new LatLng(28.06025, -82.41030)); assertTrue(PolyUtil.isClosedPolygon(poly)); } |
PolyUtil { public static double distanceToLine(final LatLng p, final LatLng start, final LatLng end) { if (start.equals(end)) { return computeDistanceBetween(end, p); } final double s0lat = toRadians(p.latitude); final double s0lng = toRadians(p.longitude); final double s1lat = toRadians(start.latitude); final double s1lng = toRadians(start.longitude); final double s2lat = toRadians(end.latitude); final double s2lng = toRadians(end.longitude); double s2s1lat = s2lat - s1lat; double s2s1lng = s2lng - s1lng; final double u = ((s0lat - s1lat) * s2s1lat + (s0lng - s1lng) * s2s1lng) / (s2s1lat * s2s1lat + s2s1lng * s2s1lng); if (u <= 0) { return computeDistanceBetween(p, start); } if (u >= 1) { return computeDistanceBetween(p, end); } LatLng su = new LatLng(start.latitude + u * (end.latitude - start.latitude), start.longitude + u * (end.longitude - start.longitude)); return computeDistanceBetween(p, su); } private PolyUtil(); static boolean containsLocation(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean containsLocation(double latitude, double longitude, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic,
double tolerance); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic, double tolerance); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnPath(LatLng point, List<LatLng> poly,
boolean geodesic, double tolerance); static int locationIndexOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnEdgeOrPath(LatLng point, List<LatLng> poly, boolean closed,
boolean geodesic, double toleranceEarth); static List<LatLng> simplify(List<LatLng> poly, double tolerance); static boolean isClosedPolygon(List<LatLng> poly); static double distanceToLine(final LatLng p, final LatLng start, final LatLng end); static List<LatLng> decode(final String encodedPath); static String encode(final List<LatLng> path); static final double DEFAULT_TOLERANCE; } | @Test public void testDistanceToLine() { LatLng startLine = new LatLng(28.05359, -82.41632); LatLng endLine = new LatLng(28.05310, -82.41634); LatLng p = new LatLng(28.05342, -82.41594); double distance = PolyUtil.distanceToLine(p, startLine, endLine); assertEquals(37.947946, distance, 1e-6); }
@Test public void testDistanceToLineLessThanDistanceToExtrems() { LatLng startLine = new LatLng(28.05359, -82.41632); LatLng endLine = new LatLng(28.05310, -82.41634); LatLng p = new LatLng(28.05342, -82.41594); double distance = PolyUtil.distanceToLine(p, startLine, endLine); double distanceToStart = SphericalUtil.computeDistanceBetween(p, startLine); double distanceToEnd = SphericalUtil.computeDistanceBetween(p, endLine); assertTrue("Wrong distance.", distance <= distanceToStart && distance <= distanceToEnd); } |
KmlPolygon implements DataPolygon<ArrayList<ArrayList<LatLng>>> { public List<List<LatLng>> getInnerBoundaryCoordinates() { return mInnerBoundaryCoordinates; } KmlPolygon(List<LatLng> outerBoundaryCoordinates,
List<List<LatLng>> innerBoundaryCoordinates); String getGeometryType(); List<List<LatLng>> getGeometryObject(); List<LatLng> getOuterBoundaryCoordinates(); List<List<LatLng>> getInnerBoundaryCoordinates(); @Override String toString(); static final String GEOMETRY_TYPE; } | @Test public void testGetInnerBoundaryCoordinates() { KmlPolygon kmlPolygon = createRegularPolygon(); assertNotNull(kmlPolygon); assertNotNull(kmlPolygon.getInnerBoundaryCoordinates()); kmlPolygon = createOuterPolygon(); assertNotNull(kmlPolygon); assertNull(kmlPolygon.getInnerBoundaryCoordinates()); } |
PolyUtil { public static List<LatLng> decode(final String encodedPath) { int len = encodedPath.length(); final List<LatLng> path = new ArrayList<LatLng>(); int index = 0; int lat = 0; int lng = 0; while (index < len) { int result = 1; int shift = 0; int b; do { b = encodedPath.charAt(index++) - 63 - 1; result += b << shift; shift += 5; } while (b >= 0x1f); lat += (result & 1) != 0 ? ~(result >> 1) : (result >> 1); result = 1; shift = 0; do { b = encodedPath.charAt(index++) - 63 - 1; result += b << shift; shift += 5; } while (b >= 0x1f); lng += (result & 1) != 0 ? ~(result >> 1) : (result >> 1); path.add(new LatLng(lat * 1e-5, lng * 1e-5)); } return path; } private PolyUtil(); static boolean containsLocation(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean containsLocation(double latitude, double longitude, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic,
double tolerance); static boolean isLocationOnEdge(LatLng point, List<LatLng> polygon, boolean geodesic); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic, double tolerance); static boolean isLocationOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnPath(LatLng point, List<LatLng> poly,
boolean geodesic, double tolerance); static int locationIndexOnPath(LatLng point, List<LatLng> polyline,
boolean geodesic); static int locationIndexOnEdgeOrPath(LatLng point, List<LatLng> poly, boolean closed,
boolean geodesic, double toleranceEarth); static List<LatLng> simplify(List<LatLng> poly, double tolerance); static boolean isClosedPolygon(List<LatLng> poly); static double distanceToLine(final LatLng p, final LatLng start, final LatLng end); static List<LatLng> decode(final String encodedPath); static String encode(final List<LatLng> path); static final double DEFAULT_TOLERANCE; } | @Test public void testDecodePath() { List<LatLng> latLngs = PolyUtil.decode(TEST_LINE); int expectedLength = 21; assertEquals("Wrong length.", expectedLength, latLngs.size()); LatLng lastPoint = latLngs.get(expectedLength - 1); assertEquals(37.76953, lastPoint.latitude, 1e-6); assertEquals(-122.41488, lastPoint.longitude, 1e-6); } |
KmlPolygon implements DataPolygon<ArrayList<ArrayList<LatLng>>> { public List<List<LatLng>> getGeometryObject() { List<List<LatLng>> coordinates = new ArrayList<>(); coordinates.add(mOuterBoundaryCoordinates); if (mInnerBoundaryCoordinates != null) { coordinates.addAll(mInnerBoundaryCoordinates); } return coordinates; } KmlPolygon(List<LatLng> outerBoundaryCoordinates,
List<List<LatLng>> innerBoundaryCoordinates); String getGeometryType(); List<List<LatLng>> getGeometryObject(); List<LatLng> getOuterBoundaryCoordinates(); List<List<LatLng>> getInnerBoundaryCoordinates(); @Override String toString(); static final String GEOMETRY_TYPE; } | @Test public void testGetKmlGeometryObject() { KmlPolygon kmlPolygon = createRegularPolygon(); assertNotNull(kmlPolygon); assertNotNull(kmlPolygon.getGeometryObject()); assertEquals(2, kmlPolygon.getGeometryObject().size()); kmlPolygon = createOuterPolygon(); assertNotNull(kmlPolygon); assertNotNull(kmlPolygon.getGeometryObject()); assertEquals(1, kmlPolygon.getGeometryObject().size()); } |
ExternalSystemRecentTaskListModel extends DefaultListModel { @SuppressWarnings("unchecked") public void setFirst(@Nonnull ExternalTaskExecutionInfo task) { insertElementAt(task, 0); for (int i = 1; i < size(); i++) { if (task.equals(getElementAt(i))) { remove(i); break; } } ensureSize(ExternalSystemConstants.RECENT_TASKS_NUMBER); } ExternalSystemRecentTaskListModel(@Nonnull ProjectSystemId externalSystemId, @Nonnull Project project); @SuppressWarnings("unchecked") void setTasks(@Nonnull List<ExternalTaskExecutionInfo> tasks); @SuppressWarnings("unchecked") void setFirst(@Nonnull ExternalTaskExecutionInfo task); @Nonnull List<ExternalTaskExecutionInfo> getTasks(); @SuppressWarnings("unchecked") void ensureSize(int elementsNumber); void forgetTasksFrom(@Nonnull String externalProjectPath); } | @Test public void testSetFirst() throws Exception { List<ExternalTaskExecutionInfo> tasks = ContainerUtilRt.newArrayList(); for (int i = 0; i <= ExternalSystemConstants.RECENT_TASKS_NUMBER; i++) { new ExternalTaskExecutionInfo(new ExternalSystemTaskExecutionSettings(), "task" + i); } myModel.setTasks(tasks); myModel.setFirst(new ExternalTaskExecutionInfo(new ExternalSystemTaskExecutionSettings(), "newTask")); Assert.assertEquals(ExternalSystemConstants.RECENT_TASKS_NUMBER, myModel.getSize()); myModel.setFirst(new ExternalTaskExecutionInfo(new ExternalSystemTaskExecutionSettings(), "task1")); Assert.assertEquals(ExternalSystemConstants.RECENT_TASKS_NUMBER, myModel.getSize()); } |
ExternalSystemRecentTaskListModel extends DefaultListModel { @SuppressWarnings("unchecked") public void ensureSize(int elementsNumber) { int toAdd = elementsNumber - size(); if (toAdd == 0) { return; } if(toAdd < 0) { removeRange(elementsNumber, size() - 1); } while (--toAdd >= 0) { addElement(new MyEmptyDescriptor()); } } ExternalSystemRecentTaskListModel(@Nonnull ProjectSystemId externalSystemId, @Nonnull Project project); @SuppressWarnings("unchecked") void setTasks(@Nonnull List<ExternalTaskExecutionInfo> tasks); @SuppressWarnings("unchecked") void setFirst(@Nonnull ExternalTaskExecutionInfo task); @Nonnull List<ExternalTaskExecutionInfo> getTasks(); @SuppressWarnings("unchecked") void ensureSize(int elementsNumber); void forgetTasksFrom(@Nonnull String externalProjectPath); } | @Test public void testEnsureSize() throws Exception { List<ExternalTaskExecutionInfo> tasks = ContainerUtilRt.newArrayList(); myModel.setTasks(tasks); myModel.ensureSize(ExternalSystemConstants.RECENT_TASKS_NUMBER); Assert.assertEquals("task list widening failed", ExternalSystemConstants.RECENT_TASKS_NUMBER, myModel.getSize()); for (int i = 0; i < ExternalSystemConstants.RECENT_TASKS_NUMBER + 1; i++) { tasks.add(new ExternalTaskExecutionInfo(new ExternalSystemTaskExecutionSettings(), "task" + i)); } myModel.setTasks(tasks); Assert.assertEquals(ExternalSystemConstants.RECENT_TASKS_NUMBER + 1, myModel.getSize()); myModel.ensureSize(ExternalSystemConstants.RECENT_TASKS_NUMBER); Assert.assertEquals("task list reduction failed", ExternalSystemConstants.RECENT_TASKS_NUMBER, myModel.getSize()); } |
VcsLogMultiRepoJoiner { @Nonnull public List<Commit> join(@Nonnull Collection<List<Commit>> logsFromRepos) { if (logsFromRepos.size() == 1) { return logsFromRepos.iterator().next(); } int size = 0; for (List<Commit> repo : logsFromRepos) { size += repo.size(); } List<Commit> result = new ArrayList<>(size); Map<Commit, Iterator<Commit>> nextCommits = ContainerUtil.newHashMap(); for (List<Commit> log : logsFromRepos) { Iterator<Commit> iterator = log.iterator(); if (iterator.hasNext()) { nextCommits.put(iterator.next(), iterator); } } while (!nextCommits.isEmpty()) { Commit lastCommit = findLatestCommit(nextCommits.keySet()); Iterator<Commit> iterator = nextCommits.get(lastCommit); result.add(lastCommit); nextCommits.remove(lastCommit); if (iterator.hasNext()) { nextCommits.put(iterator.next(), iterator); } } return result; } @Nonnull List<Commit> join(@Nonnull Collection<List<Commit>> logsFromRepos); } | @Test public void joinTest() { List<? extends TimedVcsCommit> first = log("6|-a2|-a0", "3|-a1|-a0", "1|-a0|-"); List<? extends TimedVcsCommit> second = log("4|-b1|-b0", "2|-b0|-"); List<? extends TimedVcsCommit> third = log("7|-c1|-c0", "5|-c0|-"); List<TimedVcsCommit> expected = log("7|-c1|-c0", "6|-a2|-a0", "5|-c0|-", "4|-b1|-b0", "3|-a1|-a0", "2|-b0|-", "1|-a0|-"); List<? extends TimedVcsCommit> joined = new VcsLogMultiRepoJoiner().join(Arrays.asList(first, second, third)); assertEquals(expected, joined); } |
DefaultArrangementEntryMatcherSerializer { @SuppressWarnings("MethodMayBeStatic") @javax.annotation.Nullable public <T extends ArrangementEntryMatcher> Element serialize(@Nonnull T matcher) { if (matcher instanceof StdArrangementEntryMatcher) { return serialize(((StdArrangementEntryMatcher)matcher).getCondition()); } LOG.warn(String.format( "Can't serialize arrangement entry matcher of class '%s'. Reason: expected to find '%s' instance instead", matcher.getClass(), StdArrangementEntryMatcher.class )); return null; } DefaultArrangementEntryMatcherSerializer(DefaultArrangementSettingsSerializer.Mixin mixin); @SuppressWarnings("MethodMayBeStatic") @javax.annotation.Nullable Element serialize(@Nonnull T matcher); @SuppressWarnings("MethodMayBeStatic") @javax.annotation.Nullable StdArrangementEntryMatcher deserialize(@Nonnull Element matcherElement); } | @Test public void conditionsOrder() { ArrangementCompositeMatchCondition condition = new ArrangementCompositeMatchCondition(); ArrangementSettingsToken typeToPreserve = FIELD; Set<ArrangementSettingsToken> modifiersToPreserve = ContainerUtilRt.newHashSet(PUBLIC, STATIC, FINAL); condition.addOperand(new ArrangementAtomMatchCondition(typeToPreserve, typeToPreserve)); for (ArrangementSettingsToken modifier : modifiersToPreserve) { condition.addOperand(new ArrangementAtomMatchCondition(modifier, modifier)); } Element element = mySerializer.serialize(new StdArrangementEntryMatcher(condition)); assertNotNull(element); for (ArrangementSettingsToken type : StdArrangementTokens.EntryType.values()) { if (type != typeToPreserve) { condition.addOperand(new ArrangementAtomMatchCondition(type, type)); } } for (ArrangementSettingsToken modifier : StdArrangementTokens.Modifier.values()) { if (!modifiersToPreserve.contains(modifier)) { condition.addOperand(new ArrangementAtomMatchCondition(modifier, modifier)); } } for (ArrangementSettingsToken type : StdArrangementTokens.EntryType.values()) { if (type != typeToPreserve) { condition.removeOperand(new ArrangementAtomMatchCondition(type, type)); } } for (ArrangementSettingsToken modifier : StdArrangementTokens.Modifier.values()) { if (!modifiersToPreserve.contains(modifier)) { condition.removeOperand(new ArrangementAtomMatchCondition(modifier, modifier)); } } Element actual = mySerializer.serialize(new StdArrangementEntryMatcher(condition)); assertNotNull(actual); checkElements(element, actual); } |
RxDownloader { public Single<List<FileContainer>> asList() { this.subject.subscribe(this.itemsObserver); this.size = this.files.size(); this.remains = this.size; Observable<FileContainer> observable = Observable .fromIterable(this.files) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.io()); if (ORDER == DownloadStrategy.FLAG_PARALLEL) observable = parallelDownloading(observable); else if (ORDER == DownloadStrategy.FLAG_SEQUENTIAL) observable = sequentialDownloading(observable); return observable.toList(); } RxDownloader(final Builder builder); RxDownloader doOnEachSingleError(OnError action); RxDownloader doOnStart(OnStart action); RxDownloader doOnCompleteWithSuccess(OnCompleteWithSuccess action); RxDownloader doOnCompleteWithError(OnCompleteWithError action); RxDownloader doOnProgress(OnProgress action); Single<List<FileContainer>> asList(); static String TAG; } | @Test public void isMaxStrategyworks() throws Exception { rxDownloader = builder .strategy(DownloadStrategy.MAX) .addFile("http: .build(); List<FileContainer> res = rxDownloader.asList().blockingGet(); res.forEach(fileContainer -> { Log.i("RxDownloader", "key" + fileContainer.getFilename() + ",value " + fileContainer.getUrl()); }); assertNotEquals(res.size(), 0); Assert.assertEquals(res.size(), 3); }
@Test public void isAllStrategyworks() throws Exception { rxDownloader = builder .strategy(DownloadStrategy.ALL) .addFile("http: .build(); List<FileContainer> res = rxDownloader.asList().blockingGet(); Assert.assertEquals(res.size(), 0); } |
Utils { public static void shouldAllPositive(int... numbers) { for (int num : numbers) { if (num < 1) { throw new IllegalArgumentException("Number should be > 0"); } } } static int toPositiveInt(String input); static void shouldAllPositive(int... numbers); static void shouldAllNonNegative(int... numbers); } | @Test public void shouldAllPositive() throws Exception { Utils.shouldAllPositive(1, 2, 3, 4); }
@Test(expected = IllegalArgumentException.class) public void shouldAllPositive2() throws Exception { Utils.shouldAllPositive(1, -2, 3, 4); }
@Test(expected = IllegalArgumentException.class) public void shouldAllPositive3() throws Exception { Utils.shouldAllPositive(1, 2, 0, 4); }
@Test public void shouldAllNonNegative2() throws Exception { Utils.shouldAllPositive(1, 2, 3, 4); }
@Test(expected = IllegalArgumentException.class) public void shouldAllNonNegative3() throws Exception { Utils.shouldAllPositive(1, -2, 3, 4); } |
CommandFactory { public Command getCommand(String commandLine) throws InvalidCommandException, InvalidCommandParams { commandLine = commandLine.trim().replaceAll(" {2}", " "); String[] split = commandLine.split(" "); String mainCommand = split[0].toUpperCase(); String[] params = Arrays.copyOfRange(split, 1, split.length); switch (mainCommand) { case "Q": return new QuitCommand(); case "C": return new CreateCommand(params); case "L": return new DrawLineCommand(params); case "R": return new DrawRectangleCommand(params); case "B": return new BucketFillCommand(params); default: throw new InvalidCommandException(); } } Command getCommand(String commandLine); } | @Test public void getCommand3() throws Exception { Command command = commandFactory.getCommand("C 20 4"); Assert.assertThat(command, CoreMatchers.instanceOf(CreateCommand.class)); }
@Test public void getCommand4() throws Exception { Command command = commandFactory.getCommand("L 1 2 1 22"); Assert.assertThat(command, CoreMatchers.instanceOf(DrawLineCommand.class)); }
@Test public void getCommand5() throws Exception { Command command = commandFactory.getCommand("R 14 1 18 3"); Assert.assertThat(command, CoreMatchers.instanceOf(DrawRectangleCommand.class)); }
@Test public void getCommand6() throws Exception { Command command = commandFactory.getCommand("B 1 3 o"); Assert.assertThat(command, CoreMatchers.instanceOf(BucketFillCommand.class)); }
@Test public void getCommand() throws Exception { commandFactory.getCommand("Q"); } |
EntityFactory { public Entity getEntity(DrawEntityCommand command) { if (command instanceof DrawLineCommand) { DrawLineCommand cmd = (DrawLineCommand) command; return new Line(cmd.getX1(), cmd.getY1(), cmd.getX2(), cmd.getY2()); } else if (command instanceof DrawRectangleCommand) { DrawRectangleCommand cmd = (DrawRectangleCommand) command; return new Rectangle(cmd.getX1(), cmd.getY1(), cmd.getX2(), cmd.getY2()); } else if (command instanceof BucketFillCommand) { BucketFillCommand cmd = (BucketFillCommand) command; return new BucketFill(cmd.getX(), cmd.getY(), cmd.getCharacter()); } return null; } Entity getEntity(DrawEntityCommand command); } | @Test public void getEntity_DrawLineCommand() throws Exception { DrawLineCommand drawLineCommand = new DrawLineCommand( "1", "2", "1", "4"); assertEquals(entityFactory.getEntity(drawLineCommand), new Line(1, 2, 1, 4)); }
@Test public void getEntity_DrawRectangleCommand() throws Exception { DrawRectangleCommand drawLineCommand = new DrawRectangleCommand( "1", "2", "3", "4"); assertEquals(entityFactory.getEntity(drawLineCommand), new Rectangle(1, 2, 3, 4)); }
@Test public void getEntity_BucketFillCommand() throws Exception { BucketFillCommand drawLineCommand = new BucketFillCommand( "2", "3", "o"); assertEquals(entityFactory.getEntity(drawLineCommand), new BucketFill(2, 3, 'o')); }
@Test public void getEntity_null() throws Exception { assertEquals(entityFactory.getEntity(null), null); } |
IEXByteConverter { public static short convertBytesToShort(final byte[] bytes) { return (short) ( (0xff & bytes[1]) << 8 | (0xff & bytes[0]) << 0); } private IEXByteConverter(); static long convertBytesToLong(final byte[] bytes); static int convertBytesToInt(final byte[] bytes); static int convertBytesToUnsignedShort(final byte[] bytes); static short convertBytesToShort(final byte[] bytes); static String convertBytesToString(final byte[] bytes); static IEXPrice convertBytesToIEXPrice(final byte[] bytes); } | @Test public void shouldSuccessfullyConvertBytesToShort() { final short value = 24; byte[] bytes = IEXByteTestUtil.convert(value); assertThat(IEXByteConverter.convertBytesToShort(bytes)).isEqualTo(value); } |
IEXPrice implements Comparable<IEXPrice>, Serializable { @Override public int hashCode() { return Objects.hashCode(number); } IEXPrice(final long number); long getNumber(); BigDecimal toBigDecimal(); @Override int compareTo(final IEXPrice iexPrice); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void twoObjectsShouldBeEqualWithTheSameNumberInside() { final long number = 43215678L; final IEXPrice iexPrice_1 = new IEXPrice(number); final IEXPrice iexPrice_2 = new IEXPrice(number); assertThat(iexPrice_1).isEqualTo(iexPrice_2); assertThat(iexPrice_1.hashCode()).isEqualTo(iexPrice_2.hashCode()); } |
IEXPrice implements Comparable<IEXPrice>, Serializable { @Override public int compareTo(final IEXPrice iexPrice) { return compare(this.getNumber(), iexPrice.getNumber()); } IEXPrice(final long number); long getNumber(); BigDecimal toBigDecimal(); @Override int compareTo(final IEXPrice iexPrice); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void compareShouldReturnOneForBiggerNumber() { final long biggerNumber = 12345678L; final long smallerNumber = 1234567L; final IEXPrice iexPrice_1 = new IEXPrice(biggerNumber); final IEXPrice iexPrice_2 = new IEXPrice(smallerNumber); assertThat(iexPrice_1.compareTo(iexPrice_2)).isEqualTo(1); }
@Test public void compareShouldReturnMinusOneForSmallerNumber() { final long biggerNumber = 12345678L; final long smallerNumber = 1234567L; final IEXPrice iexPrice_1 = new IEXPrice(smallerNumber); final IEXPrice iexPrice_2 = new IEXPrice(biggerNumber); assertThat(iexPrice_1.compareTo(iexPrice_2)).isEqualTo(-1); }
@Test public void compareShouldReturnZeroForEqualsNumbers() { final long number = 12345L; final IEXPrice iexPrice_1 = new IEXPrice(number); final IEXPrice iexPrice_2 = new IEXPrice(number); assertThat(iexPrice_1.compareTo(iexPrice_2)).isEqualTo(0); } |
IEXTOPSMessageBlock extends IEXSegment { public static IEXSegment createIEXSegment(final byte[] packet) { final List<IEXMessage> iexMessages = new ArrayList<>(); int offset = 40; final IEXMessageHeader iexMessageHeader = IEXMessageHeader.createIEXMessageHeader(Arrays.copyOfRange(packet, 0, offset)); for (int i = 0; i < iexMessageHeader.getMessageCount(); i++) { short length = IEXByteConverter.convertBytesToShort(Arrays.copyOfRange(packet, offset, offset = offset + 2)); iexMessages.add(resolveMessage(Arrays.copyOfRange(packet, offset, offset = offset + length))); } return new IEXTOPSMessageBlock(iexMessageHeader, iexMessages); } private IEXTOPSMessageBlock(final IEXMessageHeader messageHeader, final List<IEXMessage> messages); static IEXSegment createIEXSegment(final byte[] packet); } | @Test public void shouldSuccessfullyCreateMessageBlockInstance() { final IEXMessageHeaderDataBuilder messageHeaderBuilder = IEXMessageHeaderDataBuilder.messageHeader() .withMessageCount((short) 2); final IEXTradeMessageDataBuilder tradeMessageBuilder = IEXTradeMessageDataBuilder.tradeMessage(); final IEXQuoteUpdateMessageDataBuilder quoteUpdateMessageBuilder = IEXQuoteUpdateMessageDataBuilder.quoteMessage(); final byte[] bytes = prepareMessages(messageHeaderBuilder, tradeMessageBuilder, quoteUpdateMessageBuilder); final IEXSegment segment = IEXTOPSMessageBlock.createIEXSegment(bytes); assertThat(segment.getMessages()).hasSize(2); assertThat(segment.getMessageHeader()).isEqualTo(messageHeaderBuilder.build()); assertThat(segment.getMessages().get(0)).isEqualTo(tradeMessageBuilder.build()); assertThat(segment.getMessages().get(1)).isEqualTo(quoteUpdateMessageBuilder.build()); } |
IEXByteConverter { public static int convertBytesToUnsignedShort(final byte[] bytes) { return convertBytesToShort(bytes) & 0xffff; } private IEXByteConverter(); static long convertBytesToLong(final byte[] bytes); static int convertBytesToInt(final byte[] bytes); static int convertBytesToUnsignedShort(final byte[] bytes); static short convertBytesToShort(final byte[] bytes); static String convertBytesToString(final byte[] bytes); static IEXPrice convertBytesToIEXPrice(final byte[] bytes); } | @Test public void shouldSuccessfullyConvertBytesToUnsignedShort() { final int value = 32817; byte[] bytes = IEXByteTestUtil.convertUnsignedShort(value); assertThat(IEXByteConverter.convertBytesToUnsignedShort(bytes)).isEqualTo(value); } |
IEXByteConverter { public static int convertBytesToInt(final byte[] bytes) { return ((0xff & bytes[3]) << 24 | (0xff & bytes[2]) << 16 | (0xff & bytes[1]) << 8 | (0xff & bytes[0]) << 0 ); } private IEXByteConverter(); static long convertBytesToLong(final byte[] bytes); static int convertBytesToInt(final byte[] bytes); static int convertBytesToUnsignedShort(final byte[] bytes); static short convertBytesToShort(final byte[] bytes); static String convertBytesToString(final byte[] bytes); static IEXPrice convertBytesToIEXPrice(final byte[] bytes); } | @Test public void shouldSuccessfullyConvertBytesToInt() { final int value = 123456; byte[] bytes = IEXByteTestUtil.convert(value); assertThat(IEXByteConverter.convertBytesToInt(bytes)).isEqualTo(value); } |
IEXByteConverter { public static long convertBytesToLong(final byte[] bytes) { return (long) (0xff & bytes[7]) << 56 | (long) (0xff & bytes[6]) << 48 | (long) (0xff & bytes[5]) << 40 | (long) (0xff & bytes[4]) << 32 | (long) (0xff & bytes[3]) << 24 | (long) (0xff & bytes[2]) << 16 | (long) (0xff & bytes[1]) << 8 | (long) (0xff & bytes[0]) << 0; } private IEXByteConverter(); static long convertBytesToLong(final byte[] bytes); static int convertBytesToInt(final byte[] bytes); static int convertBytesToUnsignedShort(final byte[] bytes); static short convertBytesToShort(final byte[] bytes); static String convertBytesToString(final byte[] bytes); static IEXPrice convertBytesToIEXPrice(final byte[] bytes); } | @Test public void shouldSuccessfullyConvertBytesToLong() { final long value = 1234567891L; byte[] bytes = IEXByteTestUtil.convert(value); assertThat(IEXByteConverter.convertBytesToLong(bytes)).isEqualTo(value); } |
IEXByteConverter { public static IEXPrice convertBytesToIEXPrice(final byte[] bytes) { return new IEXPrice(convertBytesToLong(bytes)); } private IEXByteConverter(); static long convertBytesToLong(final byte[] bytes); static int convertBytesToInt(final byte[] bytes); static int convertBytesToUnsignedShort(final byte[] bytes); static short convertBytesToShort(final byte[] bytes); static String convertBytesToString(final byte[] bytes); static IEXPrice convertBytesToIEXPrice(final byte[] bytes); } | @Test public void shouldSuccessfullyConvertBytesToIEXPrice() { final IEXPrice iexPrice = new IEXPrice(123456789L); byte[] bytes = IEXByteTestUtil.convert(iexPrice.getNumber()); assertThat(IEXByteConverter.convertBytesToIEXPrice(bytes)).isEqualTo(iexPrice); } |
IEXByteConverter { public static String convertBytesToString(final byte[] bytes) { return new String(bytes).trim(); } private IEXByteConverter(); static long convertBytesToLong(final byte[] bytes); static int convertBytesToInt(final byte[] bytes); static int convertBytesToUnsignedShort(final byte[] bytes); static short convertBytesToShort(final byte[] bytes); static String convertBytesToString(final byte[] bytes); static IEXPrice convertBytesToIEXPrice(final byte[] bytes); } | @Test public void shouldSuccessfullyConvertBytesToString() { final String symbol = "AAPL"; byte[] bytes = IEXByteTestUtil.convert(symbol); assertThat(IEXByteConverter.convertBytesToString(bytes)).isEqualTo(symbol); } |
IEXSegment { @Override public int hashCode() { return Objects.hash(messageHeader, messages); } protected IEXSegment(
final IEXMessageHeader messageHeader,
final List<IEXMessage> messages); IEXMessageHeader getMessageHeader(); List<IEXMessage> getMessages(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void shouldTwoInstancesWithSameValuesBeEqual() { final IEXMessageHeader iexMessageHeader = defaultMessageHeader(); final List<IEXMessage> iexMessageList = asList(defaultTradeMessage(), defaultTradeMessage()); final IEXSegment iexSegment_1 = new TestIEXSegment(iexMessageHeader, iexMessageList); final IEXSegment iexSegment_2 = new TestIEXSegment(iexMessageHeader, iexMessageList); assertThat(iexSegment_1).isEqualTo(iexSegment_2); assertThat(iexSegment_1.hashCode()).isEqualTo(iexSegment_2.hashCode()); } |
IEXMessageHeader { @Override public int hashCode() { return Objects.hash(version, messageProtocolID, channelID, sessionID, payloadLength, messageCount, streamOffset, firstMessageSequenceNumber, sendTime); } private IEXMessageHeader(
final byte version,
final IEXMessageProtocol messageProtocolID,
final int channelID,
final int sessionID,
final short payloadLength,
final short messageCount,
final long streamOffset,
final long firstMessageSequenceNumber,
final long sendTime); static IEXMessageHeader createIEXMessageHeader(final byte[] bytes); byte getVersion(); IEXMessageProtocol getMessageProtocolID(); int getChannelID(); int getSessionID(); short getPayloadLength(); short getMessageCount(); long getStreamOffset(); long getFirstMessageSequenceNumber(); long getSendTime(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final int LENGTH; } | @Test public void shouldTwoInstancesWithSameValuesBeEqual() { final IEXMessageHeader iexMessageHeader_1 = defaultMessageHeader(); final IEXMessageHeader iexMessageHeader_2 = defaultMessageHeader(); assertThat(iexMessageHeader_1).isEqualTo(iexMessageHeader_2); assertThat(iexMessageHeader_1.hashCode()).isEqualTo(iexMessageHeader_2.hashCode()); } |
IEXPrice implements Comparable<IEXPrice>, Serializable { public long getNumber() { return number; } IEXPrice(final long number); long getNumber(); BigDecimal toBigDecimal(); @Override int compareTo(final IEXPrice iexPrice); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void shouldSuccessfullyCreateInstanceThroughConstructor() { final long number = 12345678L; final IEXPrice iexPrice = new IEXPrice(number); assertThat(iexPrice.getNumber()).isEqualTo(number); } |
IEXPrice implements Comparable<IEXPrice>, Serializable { @Override public String toString() { return toBigDecimal() .toString(); } IEXPrice(final long number); long getNumber(); BigDecimal toBigDecimal(); @Override int compareTo(final IEXPrice iexPrice); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void shouldProperlyFormatPrice() { final long number = 1234567; final IEXPrice iexPrice = new IEXPrice(number); assertThat(iexPrice.toString()).isEqualTo("123.4567"); } |
BookServiceImpl implements BookService { @Override @Transactional public Book saveBook(@NotNull @Valid final Book book) { LOGGER.debug("Creating {}", book); Book existing = repository.findOne(book.getId()); if (existing != null) { throw new BookAlreadyExistsException( String.format("There already exists a book with id=%s", book.getId())); } return repository.save(book); } @Autowired BookServiceImpl(final BookRepository repository); @Override @Transactional Book saveBook(@NotNull @Valid final Book book); @Override @Transactional(readOnly = true) List<Book> getList(); @Override Book getBook(Long bookId); @Override @Transactional void deleteBook(final Long bookId); } | @Test public void shouldSaveNewUser_GivenThereDoesNotExistOneWithTheSameId_ThenTheSavedUserShouldBeReturned() throws Exception { final Book savedBook = stubRepositoryToReturnUserOnSave(); final Book book = UserUtil.createBook(); final Book returnedBook = bookService.saveBook(book); verify(bookRepository, times(1)).save(book); assertEquals("Returned book should come from the repository", savedBook, returnedBook); }
@Test public void shouldSaveNewUser_GivenThereExistsOneWithTheSameId_ThenTheExceptionShouldBeThrown() throws Exception { stubRepositoryToReturnExistingUser(); try { bookService.saveBook(UserUtil.createBook()); fail("Expected exception"); } catch (BookAlreadyExistsException ignored) { } verify(bookRepository, never()).save(any(Book.class)); } |
BookServiceImpl implements BookService { @Override @Transactional(readOnly = true) public List<Book> getList() { LOGGER.debug("Retrieving the list of all users"); return repository.findAll(); } @Autowired BookServiceImpl(final BookRepository repository); @Override @Transactional Book saveBook(@NotNull @Valid final Book book); @Override @Transactional(readOnly = true) List<Book> getList(); @Override Book getBook(Long bookId); @Override @Transactional void deleteBook(final Long bookId); } | @Test public void shouldListAllUsers_GivenThereExistSome_ThenTheCollectionShouldBeReturned() throws Exception { stubRepositoryToReturnExistingUsers(10); Collection<Book> list = bookService.getList(); assertNotNull(list); assertEquals(10, list.size()); verify(bookRepository, times(1)).findAll(); }
@Test public void shouldListAllUsers_GivenThereNoneExist_ThenTheEmptyCollectionShouldBeReturned() throws Exception { stubRepositoryToReturnExistingUsers(0); Collection<Book> list = bookService.getList(); assertNotNull(list); assertTrue(list.isEmpty()); verify(bookRepository, times(1)).findAll(); } |
BookController { @RequestMapping(value = "/books", method = RequestMethod.POST, consumes = {"application/json"}) public Book saveBook(@RequestBody @Valid final Book book) { LOGGER.debug("Received request to create the {}", book); return bookService.saveBook(book); } @Autowired BookController(final BookService bookService); @RequestMapping(value = "/books", method = RequestMethod.POST, consumes = {"application/json"}) Book saveBook(@RequestBody @Valid final Book book); @ApiOperation(value = "Retrieve a list of books.", responseContainer = "List") @RequestMapping(value = "/books", method = RequestMethod.GET, produces = {"application/json"}) List<Book> listBooks(); @RequestMapping(value = "/books/{id}", method = RequestMethod.GET, produces = {"application/json"}) @ResponseBody Book singleBook(@PathVariable Long id); @RequestMapping(value = "/books/{id}", method = RequestMethod.DELETE) void deleteBook(@PathVariable Long id); @ExceptionHandler @ResponseStatus(HttpStatus.CONFLICT) String handleUserAlreadyExistsException(BookAlreadyExistsException e); } | @Test public void shouldCreateUser() throws Exception { final Book savedBook = stubServiceToReturnStoredBook(); final Book book = UserUtil.createBook(); Book returnedBook = bookController.saveBook(book); verify(bookService, times(1)).saveBook(book); assertEquals("Returned book should come from the service", savedBook, returnedBook); } |
BookController { @ApiOperation(value = "Retrieve a list of books.", responseContainer = "List") @RequestMapping(value = "/books", method = RequestMethod.GET, produces = {"application/json"}) public List<Book> listBooks() { LOGGER.debug("Received request to list all books"); return bookService.getList(); } @Autowired BookController(final BookService bookService); @RequestMapping(value = "/books", method = RequestMethod.POST, consumes = {"application/json"}) Book saveBook(@RequestBody @Valid final Book book); @ApiOperation(value = "Retrieve a list of books.", responseContainer = "List") @RequestMapping(value = "/books", method = RequestMethod.GET, produces = {"application/json"}) List<Book> listBooks(); @RequestMapping(value = "/books/{id}", method = RequestMethod.GET, produces = {"application/json"}) @ResponseBody Book singleBook(@PathVariable Long id); @RequestMapping(value = "/books/{id}", method = RequestMethod.DELETE) void deleteBook(@PathVariable Long id); @ExceptionHandler @ResponseStatus(HttpStatus.CONFLICT) String handleUserAlreadyExistsException(BookAlreadyExistsException e); } | @Test public void shouldListAllUsers() throws Exception { stubServiceToReturnExistingUsers(10); Collection<Book> books = bookController.listBooks(); assertNotNull(books); assertEquals(10, books.size()); verify(bookService, times(1)).getList(); } |
Subsets and Splits