Java 10

Author: kloverde

.classpath

@@ -2,7 +2,11 @@
 <classpath>
 	<classpathentry kind="src" path="src/main/java"/>
 	<classpathentry kind="src" path="src/test/java"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8/"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-10">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

CHANGELOG.md

@@ -1,3 +1,18 @@
+# Release 4.0 (May 26, 2018)
+
+This release ends support for Java 8 and 9.  Java 10 is now required, which is why this release has a major version bump despite the fact that the only code changes are on the testing side.  Read on...
+
+* Tweaked the JUnit tests after discovering that they fail with Java 9 and 10.  [Java 8 introduced a floating point bug](https://bugs.openjdk.java.net/browse/JDK-8039915) which was fixed in Java 9, but the tests were only ever run on Java 8, so I was unaware that different JREs were giving different results for floating point calculations.  Although the tests were using an epsilon for floating-point comparisons, it wasn't large enough to account for the floating point change introduced in Java 9, so the tests failed.
+* Upgraded Mockito to prevent "[Illegal reflective access](https://github.com/mockito/mockito/issues/1295)" when building on Java 9 and 10.
+
+The reasons for ending support for Java 8 and 9 are:
+
+1. Due to floating point differences, keeping the JUnit tests working from Java 8 to 10 would have required allowing a greater margin of error in calculations
+2. The status of the JUnit tests on Java 9 is unknowable because Oracle ended support for Java 9.  They pulled the SDK from their site, so I can't install it to test.
+
+If you build this project from source, and you use my [https://github.com/kloverde/BuildScripts](BuildScripts) project to do it, you'll need to pull the latest version.  I had to remove findbugs from BuildScripts because it's incompatible with Java 10 - plus, [the project is dead](https://mailman.cs.umd.edu/pipermail/findbugs-discuss/2016-November/004321.html).
+
+
 # Release 3.0.1 (April 22, 2018)
 
 Only the README has been updated.  The README incorrectly stated that the Latitude/Longitude classes are mutable.  They are not - this was a relic of prior behavior in v1.3 and earlier.

README.md

@@ -1,14 +1,16 @@
-GeographicCoordinate 3.0.1
-==========================
+GeographicCoordinate 4.0
+========================
 
 See LICENSE for this software's licensing terms.
 
 GeographicCoordinate is a Java library for representing latitude, longitude and cardinal points of the compass, and calculating distance and bearing between points.
 
+Starting with v4.0, Java 10 or later is required.  See the v4.0 release notes in CHANGELOG.MD for an explanation of why this is so.  For lower JRE versions, use a release prior to v4.0.  There are no API or runtime differences between the last 3.x release and 4.0.
+
 
 ## Features
 
-* Unlike using floating-point primitives to represent latitude and longitude, GeographicCoordinate enforces automatic range checking:  objects can never have invalid values.
+* Unlike using floating-point primitives to represent latitude and longitude, GeographicCoordinate uses objects that enforce automatic range checking; there's no possibility of having an object with an invalid value.
 * Coordinates can be initialized in floating-point form or as degrees, minutes and seconds
 * Calculates the distance between two points, or the total travel distance between an unlimited number of points (using the Haversine formula).  Supports a wide array of units of distance.
 * Calculates initial bearing and back azimuth
@@ -37,7 +39,7 @@ Use this software at your own risk.
 You only need to bother with these if you want to build using the same setup I used (see included project and build files).
 
 1.  [BuildScripts](https://github.com/kloverde/BuildScripts)
-2.  The Eclipse Buildship plugin (available on the Eclipse Marketplace)
+2.  The Eclipse Buildship plugin (available on the Eclipse Marketplace if it wasn't pre-packaged with your version of Eclipse)
 3.  Gradle
 
 

build.gradle

@@ -6,7 +6,7 @@ dependencies {
    compile files( "lib/numberutil/numberutil-1.0.jar" )
 
    testCompile "junit:junit:4.12"
-   testCompile "org.mockito:mockito-core:1.10.19"
+   testCompile "org.mockito:mockito-core:2.18.3"
 }
 
 task release( type : Zip ) {

gradle.properties

@@ -6,9 +6,9 @@ buildScriptsDir=../BuildScripts
 # BuildScripts configuration
 
 projectName=GeographicCoordinate
-releaseVersion=3.0
+releaseVersion=4.0
 specVersion=3.0
-javaSourceCompatibility=1.8
-javaTargetCompatibility=1.8
+javaSourceCompatibility=1.10
+javaTargetCompatibility=1.10
 jarName=geographiccoordinate
-builtByName=
+builtByName=

src/test/java/org/loverde/geographiccoordinate/calculator/DistanceCalculatorTest.java

@@ -169,43 +169,43 @@ public void distance_nullLongitudePoint2() {
    @Test
    public void distance_feet() {
       final double distance = DistanceCalculator.distance( Unit.FEET, point1, point2 );
-      assertEquals( 1070813.1682906998d, distance, fpDelta );
+      assertEquals( 1070813.1682907024d, distance, fpDelta );
    }
 
    @Test
    public void distance_kilometers() {
       final double distance = DistanceCalculator.distance( Unit.KILOMETERS, point1, point2 );
-      assertEquals( 326.3838536950053d, distance, fpDelta );
+      assertEquals( 326.3838536950061d, distance, fpDelta );
    }
 
    @Test
    public void distance_meters() {
       final double distance = DistanceCalculator.distance( Unit.METERS, point1, point2 );
-      assertEquals( 326383.8536950053d, distance, fpDelta );
+      assertEquals( 326383.8536950061d, distance, fpDelta );
    }
 
    @Test
    public void distance_miles() {
       final double distance = DistanceCalculator.distance( Unit.MILES, point1, point2 );
-      assertEquals( 202.805524297481d, distance, fpDelta );
+      assertEquals( 202.80552429748153, distance, fpDelta );
    }
 
    @Test
    public void distance_nauticalMiles() {
       final double distance = DistanceCalculator.distance( Unit.NAUTICAL_MILES, point1, point2 );
-      assertEquals( 176.2331823407156d, distance, fpDelta );
+      assertEquals( 176.23318234071604d, distance, fpDelta );
    }
 
    @Test
    public void distance_usSurveyfeet() {
       final double distance = DistanceCalculator.distance( Unit.US_SURVEY_FEET, point1, point2 );
-      assertEquals( 1070811.0266643632d, distance, fpDelta );
+      assertEquals( 1070811.026664366d, distance, fpDelta );
    }
 
    @Test
    public void distance_yards() {
       final double distance = DistanceCalculator.distance( Unit.YARDS, point1, point2 );
-      assertEquals( 356937.72276356665d, distance, fpDelta );
+      assertEquals( 356937.7227635675d, distance, fpDelta );
    }
 
    /**