diff --git a/src/androidTest/java/de/dennisguse/opentracks/io/file/importer/TrackPointAssert.java b/src/androidTest/java/de/dennisguse/opentracks/io/file/importer/TrackPointAssert.java
index e77825cec..0db162fd3 100644
--- a/src/androidTest/java/de/dennisguse/opentracks/io/file/importer/TrackPointAssert.java
+++ b/src/androidTest/java/de/dennisguse/opentracks/io/file/importer/TrackPointAssert.java
@@ -14,62 +14,62 @@ public class TrackPointAssert {
     }
 
     public void assertEquals(TrackPoint expected, TrackPoint actual) {
-        Assert.assertEquals(expected.getTime(), actual.getTime());
+        Assert.assertEquals("time", expected.getTime(), actual.getTime());
 
-        Assert.assertEquals(expected.getType(), actual.getType());
+        Assert.assertEquals("type", expected.getType(), actual.getType());
 
-        Assert.assertEquals(expected.hasLocation(), actual.hasLocation());
+        Assert.assertEquals("has location,", expected.hasLocation(), actual.hasLocation());
         if (expected.hasLocation()) {
-            Assert.assertEquals(expected.getLatitude(), actual.getLatitude(), 0.001);
-            Assert.assertEquals(expected.getLongitude(), actual.getLongitude(), 0.001);
+            Assert.assertEquals("latitude", expected.getLatitude(), actual.getLatitude(), 0.001);
+            Assert.assertEquals("longitude", expected.getLongitude(), actual.getLongitude(), 0.001);
         }
 
-        Assert.assertEquals(expected.hasAltitude(), actual.hasAltitude());
+        Assert.assertEquals("has altitude", expected.hasAltitude(), actual.hasAltitude());
         if (expected.hasAltitude()) {
-            Assert.assertEquals(expected.getAltitude().toM(), actual.getAltitude().toM(), delta);
+            Assert.assertEquals("altitude", expected.getAltitude().toM(), actual.getAltitude().toM(), delta);
         }
 
-        Assert.assertEquals(expected.hasAltitudeGain(), actual.hasAltitudeGain());
+        Assert.assertEquals("has altitudeGain", expected.hasAltitudeGain(), actual.hasAltitudeGain());
         if (expected.hasAltitudeGain()) {
-            Assert.assertEquals(expected.getAltitudeGain(), actual.getAltitudeGain(), delta);
+            Assert.assertEquals("altitudeGain", expected.getAltitudeGain(), actual.getAltitudeGain(), delta);
         }
-        Assert.assertEquals(expected.hasAltitudeLoss(), actual.hasAltitudeLoss());
+        Assert.assertEquals("has altitudeLoss", expected.hasAltitudeLoss(), actual.hasAltitudeLoss());
         if (expected.hasAltitudeLoss()) {
-            Assert.assertEquals(expected.getAltitudeLoss(), actual.getAltitudeLoss(), delta);
+            Assert.assertEquals("altitudeLoss", expected.getAltitudeLoss(), actual.getAltitudeLoss(), delta);
         }
 
-        Assert.assertEquals(expected.hasSpeed(), actual.hasSpeed());
+        Assert.assertEquals("has speed", expected.hasSpeed(), actual.hasSpeed());
         if (expected.hasSpeed()) {
-            Assert.assertEquals(expected.getSpeed().toMPS(), actual.getSpeed().toMPS(), delta);
+            Assert.assertEquals("speed", expected.getSpeed().toMPS(), actual.getSpeed().toMPS(), delta);
         }
 
-        Assert.assertEquals(expected.hasHorizontalAccuracy(), actual.hasHorizontalAccuracy());
+        Assert.assertEquals("has horizontalAccuracy", expected.hasHorizontalAccuracy(), actual.hasHorizontalAccuracy());
         if (expected.hasHorizontalAccuracy()) {
-            Assert.assertEquals(expected.getHorizontalAccuracy().toM(), actual.getHorizontalAccuracy().toM(), delta);
+            Assert.assertEquals("horizontalAccuracy", expected.getHorizontalAccuracy().toM(), actual.getHorizontalAccuracy().toM(), delta);
         }
-        Assert.assertEquals(expected.hasVerticalAccuracy(), actual.hasVerticalAccuracy());
+        Assert.assertEquals("has verticalAccuracy", expected.hasVerticalAccuracy(), actual.hasVerticalAccuracy());
         if (expected.hasVerticalAccuracy()) {
-            Assert.assertEquals(expected.getVerticalAccuracy().toM(), actual.getVerticalAccuracy().toM(), delta);
+            Assert.assertEquals("verticalAccuracy", expected.getVerticalAccuracy().toM(), actual.getVerticalAccuracy().toM(), delta);
         }
 
-        Assert.assertEquals(expected.hasSensorDistance(), actual.hasSensorDistance());
+        Assert.assertEquals("has sensorDistance", expected.hasSensorDistance(), actual.hasSensorDistance());
         if (expected.hasSensorDistance()) {
-            Assert.assertEquals(expected.getSensorDistance().toM(), actual.getSensorDistance().toM(), delta);
+            Assert.assertEquals("sensorDistance", expected.getSensorDistance().toM(), actual.getSensorDistance().toM(), delta);
         }
 
-        Assert.assertEquals(expected.hasHeartRate(), actual.hasHeartRate());
+        Assert.assertEquals("has heartrate", expected.hasHeartRate(), actual.hasHeartRate());
         if (expected.hasHeartRate()) {
-            Assert.assertEquals(expected.getHeartRate(), actual.getHeartRate());
+            Assert.assertEquals("heartrate", expected.getHeartRate(), actual.getHeartRate());
         }
 
-        Assert.assertEquals(expected.hasPower(), actual.hasPower());
+        Assert.assertEquals("has power", expected.hasPower(), actual.hasPower());
         if (expected.hasPower()) {
-            Assert.assertEquals(expected.getPower(), actual.getPower());
+            Assert.assertEquals("power", expected.getPower(), actual.getPower());
         }
 
-        Assert.assertEquals(expected.hasCadence(), actual.hasCadence());
+        Assert.assertEquals("has cadence", expected.hasCadence(), actual.hasCadence());
         if (expected.hasCadence()) {
-            Assert.assertEquals(expected.getCadence(), actual.getCadence());
+            Assert.assertEquals("cadence", expected.getCadence(), actual.getCadence());
         }
     }