#2414 convert junit statements to assertj

This conversion is not complete, but the remaining statements are hard
to catch with regular expressions automatically.

6 files changed, 106 insertions, 99 deletions

diff --git a/tests/src/cgeo/geocaching/geopoint/DistanceParserTest.java b/tests/src/cgeo/geocaching/geopoint/DistanceParserTest.java
index a549cf1..621d268 100644
--- a/tests/src/cgeo/geocaching/geopoint/DistanceParserTest.java
+++ b/tests/src/cgeo/geocaching/geopoint/DistanceParserTest.java
@@ -2,31 +2,29 @@ package cgeo.geocaching.geopoint;
 
 import android.test.AndroidTestCase;
 
-import junit.framework.Assert;
-
 public class DistanceParserTest extends AndroidTestCase {
 
     static private final double MM = 1e-6; // 1mm, in kilometers
 
     public static void testFormats() {
-        Assert.assertEquals(1.2, DistanceParser.parseDistance("1200 m", true), MM);
-        Assert.assertEquals(1.2, DistanceParser.parseDistance("1.2 km", true), MM);
-        Assert.assertEquals(0.36576, DistanceParser.parseDistance("1200 ft", true), MM);
-        Assert.assertEquals(1.09728, DistanceParser.parseDistance("1200 yd", true), MM);
-        Assert.assertEquals(1.9312128, DistanceParser.parseDistance("1.2 mi", true), MM);
+        assertEquals(1.2, DistanceParser.parseDistance("1200 m", true), MM);
+        assertEquals(1.2, DistanceParser.parseDistance("1.2 km", true), MM);
+        assertEquals(0.36576, DistanceParser.parseDistance("1200 ft", true), MM);
+        assertEquals(1.09728, DistanceParser.parseDistance("1200 yd", true), MM);
+        assertEquals(1.9312128, DistanceParser.parseDistance("1.2 mi", true), MM);
     }
 
     public static void testImplicit() {
-        Assert.assertEquals(1.2, DistanceParser.parseDistance("1200", true), MM);
-        Assert.assertEquals(0.36576, DistanceParser.parseDistance("1200", false), MM);
+        assertEquals(1.2, DistanceParser.parseDistance("1200", true), MM);
+        assertEquals(0.36576, DistanceParser.parseDistance("1200", false), MM);
     }
 
     public static void testComma() {
-        Assert.assertEquals(1.2, DistanceParser.parseDistance("1,2km", true), MM);
+        assertEquals(1.2, DistanceParser.parseDistance("1,2km", true), MM);
     }
 
     public static void testCase() {
-        Assert.assertEquals(0.36576, DistanceParser.parseDistance("1200 FT", true), MM);
+        assertEquals(0.36576, DistanceParser.parseDistance("1200 FT", true), MM);
     }
 
 }
\ No newline at end of file
diff --git a/tests/src/cgeo/geocaching/geopoint/GeoPointFormatterTest.java b/tests/src/cgeo/geocaching/geopoint/GeoPointFormatterTest.java
index a1be25d..4b25247 100644
--- a/tests/src/cgeo/geocaching/geopoint/GeoPointFormatterTest.java
+++ b/tests/src/cgeo/geocaching/geopoint/GeoPointFormatterTest.java
@@ -1,5 +1,7 @@
 package cgeo.geocaching.geopoint;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import cgeo.geocaching.ui.Formatter;
 
 import android.test.AndroidTestCase;
@@ -12,7 +14,7 @@ public class GeoPointFormatterTest extends AndroidTestCase {
         final String format = GeopointFormatter.format(GeopointFormatter.Format.LAT_LON_DECDEGREE_COMMA, point);
         assertEquals("50.000000,5.000000", format);
         final String formatMinute = GeopointFormatter.format(GeopointFormatter.Format.LAT_LON_DECMINUTE_RAW, point);
-        assertEquals("N 50° 00.000 E 005° 00.000", formatMinute);
+        assertThat(formatMinute).isEqualTo("N 50° 00.000 E 005° 00.000");
         final String formatSecond = GeopointFormatter.format(GeopointFormatter.Format.LAT_LON_DECSECOND, point).replaceAll(",", ".");
         assertEquals(formatSecond, "N 50° 00' 00.000\"" + Formatter.SEPARATOR + "E 005° 00' 00.000\"", formatSecond);
     }
diff --git a/tests/src/cgeo/geocaching/geopoint/GeoPointParserTest.java b/tests/src/cgeo/geocaching/geopoint/GeoPointParserTest.java
index 1a24609..3e5667b 100644
--- a/tests/src/cgeo/geocaching/geopoint/GeoPointParserTest.java
+++ b/tests/src/cgeo/geocaching/geopoint/GeoPointParserTest.java
@@ -1,5 +1,7 @@
 package cgeo.geocaching.geopoint;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import cgeo.geocaching.ui.Formatter;
 
 import android.test.AndroidTestCase;
@@ -23,9 +25,9 @@ public class GeoPointParserTest extends AndroidTestCase {
     }
 
     private static void assertEquals(final Geopoint expected, Geopoint actual, double tolerance) {
-        assertNotNull(expected);
-        assertNotNull(actual);
-        assertTrue(expected.distanceTo(actual) <= tolerance);
+        assertThat(expected).isNotNull();
+        assertThat(actual).isNotNull();
+        assertThat(expected.distanceTo(actual) <= tolerance).isTrue();
     }
 
     public static void testCoordinateMissingPart() {
@@ -36,7 +38,7 @@ public class GeoPointParserTest extends AndroidTestCase {
         } catch (Geopoint.ParseException e) {
             // expected
         }
-        assertNull(point);
+        assertThat(point).isNull();
     }
 
     public static void testSouth() {
@@ -66,9 +68,9 @@ public class GeoPointParserTest extends AndroidTestCase {
     public static void testInSentence() {
         final Geopoint p1 = GeopointParser.parse("Station3: N51 21.523 / E07 02.680");
         final Geopoint p2 = GeopointParser.parse("N51 21.523 E07 02.680");
-        assertNotNull(p1);
-        assertNotNull(p2);
-        assertEquals(p1, p2);
+        assertThat(p1).isNotNull();
+        assertThat(p2).isNotNull();
+        assertThat(p2).isEqualTo(p1);
     }
 
     public static void testUnrelatedParts() {
@@ -78,7 +80,7 @@ public class GeoPointParserTest extends AndroidTestCase {
         } catch (Geopoint.ParseException e) {
             // expected
         }
-        assertNull(point);
+        assertThat(point).isNull();
     }
 
     public static void testComma() {
@@ -86,9 +88,9 @@ public class GeoPointParserTest extends AndroidTestCase {
                 "E 15° 53' 41,68''");
         final Geopoint pointDot = GeopointParser.parse("N 46° 27' 55.65''\n" +
                 "E 15° 53' 41.68''");
-        assertNotNull(pointComma);
-        assertNotNull(pointDot);
-        assertEquals(pointComma, pointDot);
+        assertThat(pointComma).isNotNull();
+        assertThat(pointDot).isNotNull();
+        assertThat(pointDot).isEqualTo(pointComma);
     }
 
     public static void testBlankAddedByAutocorrectionDot() {
@@ -112,6 +114,6 @@ public class GeoPointParserTest extends AndroidTestCase {
     }
 
     public static void testEquatorMeridian() {
-        assertEquals(Geopoint.ZERO, GeopointParser.parse("00° 00.000 00° 00.000"));
+        assertThat(GeopointParser.parse("00° 00.000 00° 00.000")).isEqualTo(Geopoint.ZERO);
     }
 }
diff --git a/tests/src/cgeo/geocaching/geopoint/GeopointTest.java b/tests/src/cgeo/geocaching/geopoint/GeopointTest.java
index 9e65a02..5db877a 100644
--- a/tests/src/cgeo/geocaching/geopoint/GeopointTest.java
+++ b/tests/src/cgeo/geocaching/geopoint/GeopointTest.java
@@ -1,48 +1,49 @@
 package cgeo.geocaching.geopoint;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.offset;
+
 import android.os.Build;
 import android.os.Bundle;
 import android.test.AndroidTestCase;
 
-import junit.framework.Assert;
-
 public class GeopointTest extends AndroidTestCase {
 
     public static void testCreation() {
         final Geopoint gp = new Geopoint(48.2, 3.5);
-        Assert.assertEquals(48.2, gp.getLatitude(), 1e-8);
-        Assert.assertEquals(3.5, gp.getLongitude(), 1e-8);
+        assertThat(gp.getLatitude()).isEqualTo(48.2, offset(1e-8));
+        assertThat(gp.getLongitude()).isEqualTo(3.5, offset(1e-8));
     }
 
     public static void testCreationWithParsing() {
         final Geopoint gp = new Geopoint("N 52° 25,111 E 009° 39,111");
-        Assert.assertEquals(52.41852, gp.getLatitude(), 1e-4);
-        Assert.assertEquals(9.65185, gp.getLongitude(), 1e-4);
+        assertThat(gp.getLatitude()).isEqualTo(52.41852, offset(1e-4));
+        assertThat(gp.getLongitude()).isEqualTo(9.65185, offset(1e-4));
     }
 
     public static void testCreationAtLimit() {
         // No exception should be raised.
         final Geopoint gp1 = new Geopoint(90.0, 10.0);
-        Assert.assertEquals(90, gp1.getLatitude(), 1e-8);
+        assertThat(gp1.getLatitude()).isEqualTo(90, offset(1e-8));
 
         final Geopoint gp2 = new Geopoint(-90.0, 10.0);
-        Assert.assertEquals(-90, gp2.getLatitude(), 1e-8);
+        assertThat(gp2.getLatitude()).isEqualTo(-90, offset(1e-8));
 
         final Geopoint gp3 = new Geopoint(10.0, 180.0);
-        Assert.assertEquals(180, gp3.getLongitude(), 1e-8);
+        assertThat(gp3.getLongitude()).isEqualTo(180, offset(1e-8));
     }
 
     public static void testEqual() {
         final Geopoint gp1 = new Geopoint(48.2, 2.31);
-        Assert.assertTrue(gp1.equals(gp1));
+        assertThat(gp1.equals(gp1)).isTrue();
         final Geopoint gp2 = new Geopoint(48.3, 2.31);
-        Assert.assertFalse(gp1.equals(gp2));
+        assertThat(gp1.equals(gp2)).isFalse();
     }
 
     public static void testGetE6() {
         final Geopoint gp = new Geopoint(41.2, -3.4);
-        Assert.assertEquals(41200000.0, gp.getLatitudeE6(), 1e-6);
-        Assert.assertEquals(-3400000.0, gp.getLongitudeE6(), 1e-6);
+        assertThat((double) gp.getLatitudeE6()).isEqualTo(41200000.0, offset(1e-6));
+        assertThat((double) gp.getLongitudeE6()).isEqualTo(-3400000.0, offset(1e-6));
     }
 
     public static void testBearingDistance() {
@@ -53,18 +54,18 @@ public class GeopointTest extends AndroidTestCase {
 
         // broken distance calculation in 4.2.1
         if (Build.VERSION.SDK_INT == 17) {
-            Assert.assertEquals(110.83107, d12, 1e-6);
+            assertThat((double) d12).isEqualTo(110.83107, offset(1e-6));
         }
         else {
-            Assert.assertEquals(110.967995, d12, 1e-6);
+            assertThat((double) d12).isEqualTo(110.967995, offset(1e-6));
         }
 
-        Assert.assertEquals(d12, gp2.distanceTo(gp1), 1e-6);
+        assertThat((double) gp2.distanceTo(gp1)).isEqualTo(d12, offset(1e-6));
 
         // Bearing in both directions cannot be added, as this is
         // the initial bearing of the path in both cases.
-        Assert.assertEquals(287.162, gp1.bearingTo(gp2), 1e-3);
-        Assert.assertEquals(107.715, gp2.bearingTo(gp1), 1e-3);
+        assertThat((double) gp1.bearingTo(gp2)).isEqualTo(287.162, offset(1e-3));
+        assertThat((double) gp2.bearingTo(gp1)).isEqualTo(107.715, offset(1e-3));
     }
 
     public static void testParcelable() {
@@ -72,7 +73,7 @@ public class GeopointTest extends AndroidTestCase {
         final String KEY = "geopoint";
         final Bundle bundle = new Bundle();
         bundle.putParcelable(KEY, gp);
-        assertEquals(gp, bundle.getParcelable(KEY));
+        assertThat(bundle.getParcelable(KEY)).isEqualTo(gp);
     }
 
     public static void testDDD() {
@@ -84,7 +85,7 @@ public class GeopointTest extends AndroidTestCase {
         final Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatDegFrac()),
                 String.valueOf(gp1.getLonDir()), String.valueOf(gp1.getLonDeg()), String.valueOf(gp1.getLonDegFrac()));
 
-        Assert.assertTrue(gp1a.equals(gp1));
+        assertThat(gp1a).isEqualTo(gp1);
 
         // case 2
         final Geopoint gp2 = new Geopoint(51.34567d, 13.87654d);
@@ -94,7 +95,7 @@ public class GeopointTest extends AndroidTestCase {
         final Geopoint gp2a = new Geopoint(String.valueOf(gp2.getLatDir()), String.valueOf(gp2.getLatDeg()), String.valueOf(gp2.getLatDegFrac()),
                 String.valueOf(gp2.getLonDir()), String.valueOf(gp2.getLonDeg()), String.valueOf(gp2.getLonDegFrac()));
 
-        Assert.assertTrue(gp2a.equals(gp2));
+        assertThat(gp2a).isEqualTo(gp2);
 
         // case 3
         final Geopoint gp3 = new Geopoint(51.29999833333333d, 13.8d);
@@ -118,17 +119,17 @@ public class GeopointTest extends AndroidTestCase {
     }
 
     private static void checkDDD(Geopoint gp, char latDir, int latDeg, int latDegFrac, char lonDir, int lonDeg, int lonDegFrac) {
-        Assert.assertEquals(latDir, gp.getLatDir());
-        Assert.assertEquals(latDeg, gp.getLatDeg());
-        Assert.assertEquals(latDegFrac, gp.getLatDegFrac());
-        Assert.assertEquals(lonDir, gp.getLonDir());
-        Assert.assertEquals(lonDeg, gp.getLonDeg());
-        Assert.assertEquals(lonDegFrac, gp.getLonDegFrac());
+        assertThat(gp.getLatDir()).isEqualTo(latDir);
+        assertThat(gp.getLatDeg()).isEqualTo(latDeg);
+        assertThat(gp.getLatDegFrac()).isEqualTo(latDegFrac);
+        assertThat(gp.getLonDir()).isEqualTo(lonDir);
+        assertThat(gp.getLonDeg()).isEqualTo(lonDeg);
+        assertThat(gp.getLonDegFrac()).isEqualTo(lonDegFrac);
     }
 
     private static void checkTolerance(Geopoint gp1, Geopoint gp2, double tolerance) {
-        Assert.assertTrue(Math.abs(gp1.getLatitude() - gp2.getLatitude()) <= tolerance);
-        Assert.assertTrue(Math.abs(gp1.getLongitude() - gp2.getLongitude()) <= tolerance);
+        assertThat(Math.abs(gp1.getLatitude() - gp2.getLatitude()) <= tolerance).isTrue();
+        assertThat(Math.abs(gp1.getLongitude() - gp2.getLongitude()) <= tolerance).isTrue();
     }
 
     public static void testDMM() {
@@ -140,7 +141,7 @@ public class GeopointTest extends AndroidTestCase {
         final Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatMin()), String.valueOf(gp1.getLatMinFrac()),
                 String.valueOf(gp1.getLonDir()), String.valueOf(gp1.getLonDeg()), String.valueOf(gp1.getLonMin()), String.valueOf(gp1.getLonMinFrac()));
 
-        Assert.assertTrue(gp1a.equals(gp1));
+        assertThat(gp1a).isEqualTo(gp1);
 
         // case 2
         final Geopoint gp2 = new Geopoint(51.34567d, 13.87654d);
@@ -174,14 +175,14 @@ public class GeopointTest extends AndroidTestCase {
     }
 
     private static void checkDMM(Geopoint gp, char latDir, int latDeg, int latMin, int latMinFrac, char lonDir, int lonDeg, int lonMin, int lonMinFrac) {
-        Assert.assertEquals(latDir, gp.getLatDir());
-        Assert.assertEquals(latDeg, gp.getLatDeg());
-        Assert.assertEquals(latMin, gp.getLatMin());
-        Assert.assertEquals(latMinFrac, gp.getLatMinFrac());
-        Assert.assertEquals(lonDir, gp.getLonDir());
-        Assert.assertEquals(lonDeg, gp.getLonDeg());
-        Assert.assertEquals(lonMin, gp.getLonMin());
-        Assert.assertEquals(lonMinFrac, gp.getLonMinFrac());
+        assertThat(gp.getLatDir()).isEqualTo(latDir);
+        assertThat(gp.getLatDeg()).isEqualTo(latDeg);
+        assertThat(gp.getLatMin()).isEqualTo(latMin);
+        assertThat(gp.getLatMinFrac()).isEqualTo(latMinFrac);
+        assertThat(gp.getLonDir()).isEqualTo(lonDir);
+        assertThat(gp.getLonDeg()).isEqualTo(lonDeg);
+        assertThat(gp.getLonMin()).isEqualTo(lonMin);
+        assertThat(gp.getLonMinFrac()).isEqualTo(lonMinFrac);
     }
 
     public static void testDMS() {
@@ -193,7 +194,7 @@ public class GeopointTest extends AndroidTestCase {
         final Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatMin()), String.valueOf(gp1.getLatSec()), String.valueOf(gp1.getLatSecFrac()),
                 String.valueOf(gp1.getLonDir()), String.valueOf(gp1.getLonDeg()), String.valueOf(gp1.getLonMin()), String.valueOf(gp1.getLonSec()), String.valueOf(gp1.getLonSecFrac()));
 
-        Assert.assertTrue(gp1a.equals(gp1));
+        assertThat(gp1a).isEqualTo(gp1);
 
         // case 2
         final Geopoint gp2 = new Geopoint(51.34567d, 13.87654d);
@@ -227,22 +228,22 @@ public class GeopointTest extends AndroidTestCase {
     }
 
     private static void checkDMS(Geopoint gp, char latDir, int latDeg, int latMin, int latSec, int latSecFrac, char lonDir, int lonDeg, int lonMin, int lonSec, int lonSecFrac) {
-        Assert.assertEquals(latDir, gp.getLatDir());
-        Assert.assertEquals(latDeg, gp.getLatDeg());
-        Assert.assertEquals(latMin, gp.getLatMin());
-        Assert.assertEquals(latSec, gp.getLatSec());
-        Assert.assertEquals(latSecFrac, gp.getLatSecFrac());
-        Assert.assertEquals(lonDir, gp.getLonDir());
-        Assert.assertEquals(lonDeg, gp.getLonDeg());
-        Assert.assertEquals(lonMin, gp.getLonMin());
-        Assert.assertEquals(lonSec, gp.getLonSec());
-        Assert.assertEquals(lonSecFrac, gp.getLonSecFrac());
+        assertThat(gp.getLatDir()).isEqualTo(latDir);
+        assertThat(gp.getLatDeg()).isEqualTo(latDeg);
+        assertThat(gp.getLatMin()).isEqualTo(latMin);
+        assertThat(gp.getLatSec()).isEqualTo(latSec);
+        assertThat(gp.getLatSecFrac()).isEqualTo(latSecFrac);
+        assertThat(gp.getLonDir()).isEqualTo(lonDir);
+        assertThat(gp.getLonDeg()).isEqualTo(lonDeg);
+        assertThat(gp.getLonMin()).isEqualTo(lonMin);
+        assertThat(gp.getLonSec()).isEqualTo(lonSec);
+        assertThat(gp.getLonSecFrac()).isEqualTo(lonSecFrac);
     }
 
     private static void assertParseException(Runnable runnable) {
         try {
             runnable.run();
-            Assert.fail("Should have thrown Geopoint.ParseException");
+            fail("Should have thrown Geopoint.ParseException");
         } catch (Geopoint.ParseException e) {
             //success
         }
diff --git a/tests/src/cgeo/geocaching/geopoint/UnitsTest.java b/tests/src/cgeo/geocaching/geopoint/UnitsTest.java
index 52c5adf..acc964a 100644
--- a/tests/src/cgeo/geocaching/geopoint/UnitsTest.java
+++ b/tests/src/cgeo/geocaching/geopoint/UnitsTest.java
@@ -1,5 +1,7 @@
 package cgeo.geocaching.geopoint;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import cgeo.CGeoTestCase;
 import cgeo.geocaching.settings.Settings;
 import cgeo.geocaching.settings.TestSettings;
@@ -20,7 +22,7 @@ public class UnitsTest extends CGeoTestCase {
     // Make method non-static so that Settings is initialized
     @SuppressWarnings("static-method")
     public void testDistance() {
-        assertEquals("?", Units.getDistanceFromKilometers(null));
+        assertThat(Units.getDistanceFromKilometers(null)).isEqualTo("?");
         final boolean savedImperial = Settings.isUseImperialUnits();
         try {
             TestSettings.setUseImperialUnits(false);
@@ -43,7 +45,7 @@ public class UnitsTest extends CGeoTestCase {
     // Make method non-static so that Settings is initialized
     @SuppressWarnings("static-method")
     public void testSpeed() {
-        assertEquals("?", Units.getDistanceFromKilometers(null));
+        assertThat(Units.getDistanceFromKilometers(null)).isEqualTo("?");
         final boolean savedImperial = Settings.isUseImperialUnits();
         try {
             TestSettings.setUseImperialUnits(false);
diff --git a/tests/src/cgeo/geocaching/geopoint/ViewportTest.java b/tests/src/cgeo/geocaching/geopoint/ViewportTest.java
index 11f78ad..ab59e79 100644
--- a/tests/src/cgeo/geocaching/geopoint/ViewportTest.java
+++ b/tests/src/cgeo/geocaching/geopoint/ViewportTest.java
@@ -1,5 +1,7 @@
 package cgeo.geocaching.geopoint;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import cgeo.geocaching.ICoordinates;
 
 import org.eclipse.jdt.annotation.NonNull;
@@ -38,66 +40,66 @@ public class ViewportTest extends AndroidTestCase {
     }
 
     public static void testMinMax() {
-        assertEquals(-1.0, vpRef.getLatitudeMin());
-        assertEquals(3.0, vpRef.getLatitudeMax());
-        assertEquals(-2.0, vpRef.getLongitudeMin());
-        assertEquals(4.0, vpRef.getLongitudeMax());
+        assertThat(vpRef.getLatitudeMin()).isEqualTo(-1.0);
+        assertThat(vpRef.getLatitudeMax()).isEqualTo(3.0);
+        assertThat(vpRef.getLongitudeMin()).isEqualTo(-2.0);
+        assertThat(vpRef.getLongitudeMax()).isEqualTo(4.0);
     }
 
     public static void testSpans() {
-        assertEquals(4.0, vpRef.getLatitudeSpan());
-        assertEquals(6.0, vpRef.getLongitudeSpan());
+        assertThat(vpRef.getLatitudeSpan()).isEqualTo(4.0);
+        assertThat(vpRef.getLongitudeSpan()).isEqualTo(6.0);
     }
 
     public static void testInViewport() {
-        assertFalse(vpRef.contains(new Geopoint(-2.0, -2.0)));
-        assertFalse(vpRef.contains(new Geopoint(4.0, 4.0)));
-        assertTrue(vpRef.contains(Geopoint.ZERO));
-        assertTrue(vpRef.contains(new Geopoint(-1.0, -2.0)));
-        assertTrue(vpRef.contains(new Geopoint(3.0, 4.0)));
+        assertThat(vpRef.contains(new Geopoint(-2.0, -2.0))).isFalse();
+        assertThat(vpRef.contains(new Geopoint(4.0, 4.0))).isFalse();
+        assertThat(vpRef.contains(Geopoint.ZERO)).isTrue();
+        assertThat(vpRef.contains(new Geopoint(-1.0, -2.0))).isTrue();
+        assertThat(vpRef.contains(new Geopoint(3.0, 4.0))).isTrue();
     }
 
     public static void testSqlWhere() {
-        assertEquals("latitude >= -1.0 and latitude <= 3.0 and longitude >= -2.0 and longitude <= 4.0", vpRef.sqlWhere(null).toString());
-        assertEquals("t.latitude >= -1.0 and t.latitude <= 3.0 and t.longitude >= -2.0 and t.longitude <= 4.0", vpRef.sqlWhere("t").toString());
+        assertThat(vpRef.sqlWhere(null).toString()).isEqualTo("latitude >= -1.0 and latitude <= 3.0 and longitude >= -2.0 and longitude <= 4.0");
+        assertThat(vpRef.sqlWhere("t").toString()).isEqualTo("t.latitude >= -1.0 and t.latitude <= 3.0 and t.longitude >= -2.0 and t.longitude <= 4.0");
         Locale current = null;
         try {
             current = Locale.getDefault();
             Locale.setDefault(Locale.FRENCH);
             assertEquals("1,0", String.format("%.2g", 1.0d));  // Control that we are in a locale with commma separator
-            assertEquals("t.latitude >= -1.0 and t.latitude <= 3.0 and t.longitude >= -2.0 and t.longitude <= 4.0", vpRef.sqlWhere("t").toString());
+            assertThat(vpRef.sqlWhere("t").toString()).isEqualTo("t.latitude >= -1.0 and t.latitude <= 3.0 and t.longitude >= -2.0 and t.longitude <= 4.0");
         } finally {
             Locale.setDefault(current);
         }
     }
 
     public static void testEquals() {
-        assertEquals(vpRef, vpRef);
+        assertThat(vpRef).isEqualTo(vpRef);
         assertEquals(vpRef, new Viewport(vpRef.bottomLeft, vpRef.topRight));
-        assertFalse(vpRef.equals(new Viewport(new Geopoint(0.0, 0.0), 1.0, 1.0)));
+        assertThat(vpRef.equals(new Viewport(new Geopoint(0.0, 0.0), 1.0, 1.0))).isFalse();
     }
 
     public static void testResize() {
-        assertEquals(vpRef, vpRef.resize(1.0));
+        assertThat(vpRef.resize(1.0)).isEqualTo(vpRef);
         assertEquals(new Viewport(new Geopoint(-3.0, -5.0), new Geopoint(5.0, 7.0)), vpRef.resize(2.0));
         assertEquals(new Viewport(new Geopoint(0.0, -0.5), new Geopoint(2.0, 2.5)), vpRef.resize(0.5));
     }
 
     public static void testIncludes() {
-        assertTrue(vpRef.includes(vpRef));
-        assertTrue(vpRef.includes(vpRef.resize(0.5)));
-        assertFalse(vpRef.includes(vpRef.resize(2.0)));
+        assertThat(vpRef.includes(vpRef)).isTrue();
+        assertThat(vpRef.includes(vpRef.resize(0.5))).isTrue();
+        assertThat(vpRef.includes(vpRef.resize(2.0))).isFalse();
     }
 
     public static void testContaining() {
-        assertNull(Viewport.containing(Collections.singleton((ICoordinates) null)));
+        assertThat(Viewport.containing(Collections.singleton((ICoordinates) null))).isNull();
         final Set<Geopoint> points = new HashSet<Geopoint>();
         points.add(vpRef.bottomLeft);
         assertEquals(new Viewport(vpRef.bottomLeft, vpRef.bottomLeft), Viewport.containing(points));
         points.add(vpRef.topRight);
-        assertEquals(vpRef, Viewport.containing(points));
+        assertThat(Viewport.containing(points)).isEqualTo(vpRef);
         points.add(vpRef.center);
-        assertEquals(vpRef, Viewport.containing(points));
+        assertThat(Viewport.containing(points)).isEqualTo(vpRef);
     }
 
 }