From 8b7d4fa8130b0609f892648099a1d3f9e9090791 Mon Sep 17 00:00:00 2001 From: "Marcatili, Manuel" Date: Thu, 16 Apr 2026 11:35:50 +0300 Subject: [PATCH] Added explicit assertions to tests --- .../dennisguse/opentracks/EspressoUITest.java | 13 ++- .../data/CustomContentProviderUtilsTest.java | 34 ++++--- .../IntervalStatisticsUpdaterTest.java | 89 ++++++++++++++----- 3 files changed, 99 insertions(+), 37 deletions(-) diff --git a/src/androidTest/java/de/dennisguse/opentracks/EspressoUITest.java b/src/androidTest/java/de/dennisguse/opentracks/EspressoUITest.java index ea1fa12e6..0589cb0cd 100644 --- a/src/androidTest/java/de/dennisguse/opentracks/EspressoUITest.java +++ b/src/androidTest/java/de/dennisguse/opentracks/EspressoUITest.java @@ -70,6 +70,9 @@ public class EspressoUITest { resumeStoppedTrack(UI_TIMEOUT); stopRecordingToTrackStopped(UI_TIMEOUT, R.id.finish_button); finishStoppedTrack(UI_TIMEOUT); + + onView(withId(R.id.track_list)) + .check(matches(isDisplayed())); } } @@ -96,7 +99,12 @@ public class EspressoUITest { waitUntilTabSelectionSettlesAt(0); // stop - stopRecordingToTrackStopped(UI_TIMEOUT, R.id.resume_button); + stopRecordingToTrackStopped(UI_TIMEOUT, R.id.resume_button, R.id.finish_button); + + onView(withId(R.id.resume_button)) + .check(matches(isDisplayed())); + onView(withId(R.id.finish_button)) + .check(matches(isDisplayed())); } } @@ -114,6 +122,9 @@ public class EspressoUITest { onView(withId(R.id.track_list)).check(matches(isDisplayed())); onView(allOf(withId(R.id.track_list_item_name), withText(uniqueTrackName))) .perform(performLongClickOnAncestor()); + + onView(withId(androidx.appcompat.R.id.action_mode_bar)) + .check(matches(isDisplayed())); } private void waitUntilTabSelectionSettlesAt(int index) { diff --git a/src/androidTest/java/de/dennisguse/opentracks/data/CustomContentProviderUtilsTest.java b/src/androidTest/java/de/dennisguse/opentracks/data/CustomContentProviderUtilsTest.java index 53b897eba..ab6653736 100644 --- a/src/androidTest/java/de/dennisguse/opentracks/data/CustomContentProviderUtilsTest.java +++ b/src/androidTest/java/de/dennisguse/opentracks/data/CustomContentProviderUtilsTest.java @@ -94,21 +94,21 @@ public class CustomContentProviderUtilsTest { @Test public void testLocationIterator_noPoints() { - testIterator(new Track.Id(1), 0); + assertEquals(0, testIterator(new Track.Id(1), 0).size()); } @Test public void testLocationIterator_noAscending() { - testIterator(new Track.Id(1), 50); - testIterator(new Track.Id(2), 50); + assertEquals(50, testIterator(new Track.Id(1), 50).size()); + assertEquals(50, testIterator(new Track.Id(2), 50).size()); } @Test public void testLocationIterator_largeTrack() { - testIterator(new Track.Id(1), 20000 / 2); + assertEquals(20000 / 2, testIterator(new Track.Id(1), 20000 / 2).size()); } - private void testIterator(Track.Id trackId, int numPoints) { + private List testIterator(Track.Id trackId, int numPoints) { TrackPoint.Id lastPointId = initializeTrack(trackId, numPoints); List locations = new ArrayList<>(numPoints); try (TrackPointIterator it = contentProviderUtils.getTrackPointIterator(trackId, null)) { @@ -121,6 +121,7 @@ public class CustomContentProviderUtilsTest { } assertEquals(numPoints, locations.size()); } + return locations; } private TrackPoint.Id initializeTrack(Track.Id id, int numPoints) { @@ -1194,7 +1195,7 @@ public class CustomContentProviderUtilsTest { assertEquals(sensorStatistics.avgPower().getW(), stats.avgPower, 0f); } - private void testGetSensorStats_randomData(int totalPoints, boolean withStartSegments) { + private Pair testGetSensorStats_randomData(int totalPoints, boolean withStartSegments) { // given Instant start = Instant.now(); TestSensorDataUtil sensorDataUtil = new TestSensorDataUtil(); @@ -1217,22 +1218,27 @@ public class CustomContentProviderUtilsTest { SensorStatistics sensorStatistics = contentProviderUtils.getSensorStats(trackId); TestSensorDataUtil.SensorDataStats stats = sensorDataUtil.computeStats(); - // then - assertEquals(sensorStatistics.avgHeartRate().getBPM(), stats.avgHr, 0.01f); - assertEquals(sensorStatistics.maxHeartRate().getBPM(), stats.maxHr, 0.01f); - assertEquals(sensorStatistics.avgCadence().getRPM(), stats.avgCadence, 0.01f); - assertEquals(sensorStatistics.maxCadence().getRPM(), stats.maxCadence, 0.01f); - assertEquals(sensorStatistics.avgPower().getW(), stats.avgPower, 0.01f); + return Pair.create(sensorStatistics, stats); } @Test public void testGetSensorStats_veryLongActivity12h() { - testGetSensorStats_randomData(43200 / 6, false); + Pair result = testGetSensorStats_randomData(43200 / 6, false); + assertEquals(result.first.avgHeartRate().getBPM(), result.second.avgHr, 0.01f); + assertEquals(result.first.maxHeartRate().getBPM(), result.second.maxHr, 0.01f); + assertEquals(result.first.avgCadence().getRPM(), result.second.avgCadence, 0.01f); + assertEquals(result.first.maxCadence().getRPM(), result.second.maxCadence, 0.01f); + assertEquals(result.first.avgPower().getW(), result.second.avgPower, 0.01f); } @Test public void testGetSensorStats_withSeveralRandomStartSegments() { - testGetSensorStats_randomData(5000, true); + Pair result = testGetSensorStats_randomData(5000, true); + assertEquals(result.first.avgHeartRate().getBPM(), result.second.avgHr, 0.01f); + assertEquals(result.first.maxHeartRate().getBPM(), result.second.maxHr, 0.01f); + assertEquals(result.first.avgCadence().getRPM(), result.second.avgCadence, 0.01f); + assertEquals(result.first.maxCadence().getRPM(), result.second.maxCadence, 0.01f); + assertEquals(result.first.avgPower().getW(), result.second.avgPower, 0.01f); } private TrackPoint getLastValidTrackPoint(Track.Id trackId) { diff --git a/src/androidTest/java/de/dennisguse/opentracks/ui/intervals/IntervalStatisticsUpdaterTest.java b/src/androidTest/java/de/dennisguse/opentracks/ui/intervals/IntervalStatisticsUpdaterTest.java index 8bab9be0f..c2abe6a75 100644 --- a/src/androidTest/java/de/dennisguse/opentracks/ui/intervals/IntervalStatisticsUpdaterTest.java +++ b/src/androidTest/java/de/dennisguse/opentracks/ui/intervals/IntervalStatisticsUpdaterTest.java @@ -35,7 +35,10 @@ public class IntervalStatisticsUpdaterTest { float distanceInterval = 1000f; // when and then - whenAndThen(50, distanceInterval); + IntervalStatisticsComputation computation = computeIntervalStatistics(50, distanceInterval); + assertIntervalStatisticsComputation(computation, 50, distanceInterval); + assertEquals((int) Math.ceil(computation.track.statistics().totalDistance().toM() / distanceInterval), computation.intervalList.size()); + assertEquals(computation.track.statistics().totalDistance().toM(), computation.totalDistance.toM(), 0.01); } /** @@ -49,7 +52,10 @@ public class IntervalStatisticsUpdaterTest { float distanceInterval = 1000f; // when and then - whenAndThen(200, distanceInterval); + IntervalStatisticsComputation computation = computeIntervalStatistics(200, distanceInterval); + assertIntervalStatisticsComputation(computation, 200, distanceInterval); + assertEquals((int) Math.ceil(computation.track.statistics().totalDistance().toM() / distanceInterval), computation.intervalList.size()); + assertEquals(computation.track.statistics().totalDistance().toM(), computation.totalDistance.toM(), 0.01); } /** @@ -63,7 +69,10 @@ public class IntervalStatisticsUpdaterTest { float distanceInterval = 3000f; // when and then - whenAndThen(3000, distanceInterval); + IntervalStatisticsComputation computation = computeIntervalStatistics(3000, distanceInterval); + assertIntervalStatisticsComputation(computation, 3000, distanceInterval); + assertEquals((int) Math.ceil(computation.track.statistics().totalDistance().toM() / distanceInterval), computation.intervalList.size()); + assertEquals(computation.track.statistics().totalDistance().toM(), computation.totalDistance.toM(), 0.01); } /** @@ -77,7 +86,10 @@ public class IntervalStatisticsUpdaterTest { float distanceInterval = 3000f; // when and then - whenAndThen(1000, distanceInterval); + IntervalStatisticsComputation computation = computeIntervalStatistics(1000, distanceInterval); + assertIntervalStatisticsComputation(computation, 1000, distanceInterval); + assertEquals((int) Math.ceil(computation.track.statistics().totalDistance().toM() / distanceInterval), computation.intervalList.size()); + assertEquals(computation.track.statistics().totalDistance().toM(), computation.totalDistance.toM(), 0.01); } /** @@ -91,7 +103,10 @@ public class IntervalStatisticsUpdaterTest { float distanceInterval = 1000f; // when and then - whenAndThen(10000, distanceInterval); + IntervalStatisticsComputation computation = computeIntervalStatistics(10000, distanceInterval); + assertIntervalStatisticsComputation(computation, 10000, distanceInterval); + assertEquals((int) Math.ceil(computation.track.statistics().totalDistance().toM() / distanceInterval), computation.intervalList.size()); + assertEquals(computation.track.statistics().totalDistance().toM(), computation.totalDistance.toM(), 0.01); } @Test @@ -122,15 +137,18 @@ public class IntervalStatisticsUpdaterTest { Pair> trackWithStats = new Pair<>(dummyTrack, trackPoints); // when and then - whenAndThen(trackWithStats.first, trackWithStats.second, numberOfPoints, distanceInterval); + IntervalStatisticsComputation computation = computeIntervalStatistics(trackWithStats.first, trackWithStats.second, distanceInterval); + assertIntervalStatisticsComputation(computation, numberOfPoints, distanceInterval); + assertEquals((int) Math.ceil(computation.track.statistics().totalDistance().toM() / distanceInterval), computation.intervalList.size()); + assertEquals(computation.track.statistics().totalDistance().toM(), computation.totalDistance.toM(), 0.01); } - private void whenAndThen(int numberOfPoints, float distanceInterval) { + private IntervalStatisticsComputation computeIntervalStatistics(int numberOfPoints, float distanceInterval) { Pair> trackWithStats = buildTrackWithTrackPoints(numberOfPoints); - whenAndThen(trackWithStats.first, trackWithStats.second, numberOfPoints, distanceInterval); + return computeIntervalStatistics(trackWithStats.first, trackWithStats.second, distanceInterval); } - private void whenAndThen(Track track, List trackPoints, int numberOfPoints, float distanceInterval) { + private IntervalStatisticsComputation computeIntervalStatistics(Track track, List trackPoints, float distanceInterval) { IntervalStatisticsUpdater intervalStatistics = new IntervalStatisticsUpdater(Distance.of(distanceInterval)); intervalStatistics.addTrackPoints(trackPoints.iterator()); @@ -157,23 +175,27 @@ public class IntervalStatisticsUpdaterTest { } } - // then - assertEquals(track.statistics().totalDuration().toSeconds(), totalTime, 0.01); - assertEquals(track.statistics().totalDistance().toM(), totalDistance.toM(), 0.01); - assertEquals(intervalList.size(), (int) Math.ceil(track.statistics().totalDistance().toM() / distanceInterval)); - if (totalGain != null && totalLoss != null) { - assertEquals(totalGain, numberOfPoints * TestDataUtil.ALTITUDE_GAIN, 0.1); - assertEquals(totalLoss, numberOfPoints * TestDataUtil.ALTITUDE_LOSS, 0.1); + return new IntervalStatisticsComputation(track, intervalList, totalDistance, totalTime, totalGain, totalLoss); + } + + private void assertIntervalStatisticsComputation(IntervalStatisticsComputation computation, int numberOfPoints, float distanceInterval) { + assertEquals(computation.track.statistics().totalDuration().toSeconds(), computation.totalTime, 0.01); + assertEquals(computation.track.statistics().totalDistance().toM(), computation.totalDistance.toM(), 0.01); + assertEquals(computation.intervalList.size(), (int) Math.ceil(computation.track.statistics().totalDistance().toM() / distanceInterval)); + if (computation.totalGain != null && computation.totalLoss != null) { + assertEquals(computation.totalGain, numberOfPoints * TestDataUtil.ALTITUDE_GAIN, 0.1); + assertEquals(computation.totalLoss, numberOfPoints * TestDataUtil.ALTITUDE_LOSS, 0.1); } else { - assertTrue(intervalStatistics.getIntervalList().stream().noneMatch(i -> i.altitudeGainLoss() != null)); + assertTrue(computation.intervalList.stream().noneMatch(i -> i.altitudeGainLoss() != null)); } - for (int i = 0; i < intervalList.size() - 1; i++) { - assertEquals(intervalList.get(i).totalDistance().toM(), distanceInterval, 0.001); - totalDistance = totalDistance.minus(intervalList.get(i).totalDistance()); + Distance remainingDistance = computation.totalDistance; + for (int i = 0; i < computation.intervalList.size() - 1; i++) { + assertEquals(computation.intervalList.get(i).totalDistance().toM(), distanceInterval, 0.001); + remainingDistance = remainingDistance.minus(computation.intervalList.get(i).totalDistance()); } - assertEquals(intervalList.get(intervalList.size() - 1).totalDistance().toM(), totalDistance.toM(), 0.01); + assertEquals(computation.intervalList.get(computation.intervalList.size() - 1).totalDistance().toM(), remainingDistance.toM(), 0.01); } private static Pair> buildTrackWithTrackPoints(int numberOfPoints) { @@ -195,4 +217,27 @@ public class IntervalStatisticsUpdaterTest { return new Pair<>(track, trackPoints); } -} \ No newline at end of file + + private static final class IntervalStatisticsComputation { + private final Track track; + private final List intervalList; + private final Distance totalDistance; + private final float totalTime; + private final Float totalGain; + private final Float totalLoss; + + private IntervalStatisticsComputation(Track track, + List intervalList, + Distance totalDistance, + float totalTime, + Float totalGain, + Float totalLoss) { + this.track = track; + this.intervalList = intervalList; + this.totalDistance = totalDistance; + this.totalTime = totalTime; + this.totalGain = totalGain; + this.totalLoss = totalLoss; + } + } +}