Merge branch 'master' into bug5147

2026-09-23 22:19:13 +00:00 · 2022-11-07 12:58:01 +01:00
parent 15fc0e6ba6 fd5a052471
commit 2e669c4ea8
205 changed files with 3717 additions and 985 deletions
@@ -79,7 +79,7 @@ public class WaypointPositionAndDistanceCacheTest {
        trackedRace = new DynamicTrackedRaceImpl(trackedRegatta, race, Collections.emptyList(), EmptyWindStore.INSTANCE,
                /* delayToLiveInMillis */ 8000, /* millisecondsOverWhichToAverageWind */ 30000,
                /* millisecondsOverWhichToAverageSpeed */ 15000, /* delayForCacheInvalidationOfWindEstimation */ 10000,
-                /* useInternalMarkPassingAlgorithm */ false, OneDesignRankingMetric::new, mock(RaceLogAndTrackedRaceResolver.class), null);
+                /* useInternalMarkPassingAlgorithm */ false, OneDesignRankingMetric::new, mock(RaceLogAndTrackedRaceResolver.class), null, /* markPassingRaceFingerprintRegistry */ null);
        timeRangeResolution = Duration.ONE_MINUTE;
        now = new MillisecondsTimePoint(MillisecondsTimePoint.now().asMillis() / timeRangeResolution.asMillis() * timeRangeResolution.asMillis());
        trackedRace.getOrCreateTrack(pinEnd).addGPSFix(new GPSFixImpl(new DegreePosition(0, -0.0000001), now));
@@ -31,7 +31,7 @@ public class MarkPassingCalculatorTest {
    private static class MyMarkPassingCalculator extends MarkPassingCalculator {
        public MyMarkPassingCalculator(DynamicTrackedRace race, boolean doListen,
                boolean waitForInitialMarkPassingCalculation) {
-            super(race, doListen, waitForInitialMarkPassingCalculation);
+            super(race, doListen, waitForInitialMarkPassingCalculation, /* markPassingRaceFingerprintRegistry */ null);
        }

        @Override
@@ -136,7 +136,7 @@ public class TestCrossFleetScoring extends LeaderboardScoringAndRankingTestBase
                    /* delay for wind estimation cache invalidation */ 0, /* useMarkPassingCalculator */ false,
                    tr -> new TimeOnTimeAndDistanceRankingMetric(tr, timeOnTimeFactors, // time-on-time
                            c -> new MillisecondsDurationImpl((long) (1000. * timeOnDistanceAllowance.apply(c)))),
-                    mock(RaceLogAndTrackedRaceResolver.class), null);
+                    mock(RaceLogAndTrackedRaceResolver.class), null, /* markPassingRaceFingerprintRegistry */ null);
            // in this simplified artificial course, the top mark is exactly north of the right leeward gate
            DegreePosition topPosition = new DegreePosition(1, 0);
            trackedRace.getOrCreateTrack(left)
@@ -128,7 +128,7 @@ public class TestFarthestAheadWithSkippedMarkPassing {
                /* delayToLiveInMillis */ 0,
                /* millisecondsOverWhichToAverageWind */ 30000, /* millisecondsOverWhichToAverageSpeed */ 30000,
                /* delay for wind estimation cache invalidation */ 0, /*useMarkPassingCalculator*/ false,
-                tr->new OneDesignRankingMetric(tr), mock(RaceLogAndTrackedRaceResolver.class), null);
+                tr->new OneDesignRankingMetric(tr), mock(RaceLogAndTrackedRaceResolver.class), null, /* markPassingRaceFingerprintRegistry */ null);
        // in this simplified artificial course, the top mark is exactly north of the right leeward gate
        DegreePosition topPosition = new DegreePosition(1, 0);
        trackedRace.getOrCreateTrack(left).addGPSFix(new GPSFixImpl(new DegreePosition(0, -0.000001), timePointForFixes));
@@ -102,7 +102,7 @@ public class TestSimpleTimeOnTimeRankingWithOneUpwindLeg {
                /* delay for wind estimation cache invalidation */ 0, /*useMarkPassingCalculator*/ false,
                tr->new TimeOnTimeAndDistanceRankingMetric(tr,
                        timeOnTimeFactors, // time-on-time
-                        c->new MillisecondsDurationImpl((long) (1000.*timeOnDistanceFactors.apply(c)))), mock(RaceLogAndTrackedRaceResolver.class), null);
+                        c->new MillisecondsDurationImpl((long) (1000.*timeOnDistanceFactors.apply(c)))), mock(RaceLogAndTrackedRaceResolver.class), null, /* markPassingRaceFingerprintRegistry */ null);
        // in this simplified artificial course, the top mark is exactly north of the right leeward gate
        DegreePosition topPosition = new DegreePosition(1, 0);
        trackedRace.getOrCreateTrack(left).addGPSFix(new GPSFixImpl(new DegreePosition(0, -0.000001), timePointForFixes));
@@ -322,7 +322,7 @@ public class CourseTest {
                Collections.<Sideline> emptyList(), EmptyWindStore.INSTANCE, /* delayToLiveInMillis */3000,
                /* millisecondsOverWhichToAverageWind */30000,
                /* millisecondsOverWhichToAverageSpeed */8000, /*useMarkPassingCalculator*/ false, OneDesignRankingMetric::new,
-                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null);
+                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        assertLegStructure(course, trackedRace);
        course.removeWaypoint(0);
        assertLegStructure(course, trackedRace);
@@ -358,7 +358,7 @@ public class CourseTest {
                EmptyWindStore.INSTANCE, /* delayToLiveInMillis */ 3000,
                        /* millisecondsOverWhichToAverageWind */ 30000,
                        /* millisecondsOverWhichToAverageSpeed */ 8000, /*useMarkPassingCalculator*/ false, OneDesignRankingMetric::new,
-                        mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null);
+                        mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        assertLegStructure(course, trackedRace);
        final WaypointImpl wp1_5 = new WaypointImpl(new MarkImpl("Test Mark 1.5"));
        assertWaypointIndexes(course);
@@ -88,7 +88,7 @@ public class CourseUpdateDuringNonAtomicSerializationTest implements Serializabl
                EmptyWindStore.INSTANCE, 
                /* delayToLiveInMillis */10000, /* millisecondsOverWhichToAverageWind */30000, /* millisecondsOverWhichToAverageSpeed */
                7000, /* useMarkPassingCalculator */ false, OneDesignRankingMetric::new,
-                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null) {
+                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null) {
            private static final long serialVersionUID = 9114777576548711763L;

            @Override
@@ -101,7 +101,7 @@ public class CourseUpdateTest extends AbstractTracTracLiveTest {
                /* delayToLiveInMillis */0l, /* millisecondsOverWhichToAverageWind */30000, /* simulator */null, /* courseDesignUpdateURI */
                null, /* tracTracUsername */null, /* tracTracPassword */null, getEventSubscriber(), getRaceSubscriber(),
                /*ignoreTracTracMarkPassings*/false, mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                new DefaultRaceTrackingHandler()) {
+                new DefaultRaceTrackingHandler(), /* markPassingRaceFingerprintRegistry */ null) {
            @Override
            protected void handleEvent(Triple<IControlRoute, Long, Void> event) {
                super.handleEvent(event);
@@ -140,7 +140,7 @@ public class LeaderboardCourseChangeTest {
        TrackedRace spyedTrackedRace = spy(new DynamicTrackedRaceImpl(mockedTrackedRegatta, mockedRace,
                new HashSet<Sideline>(), EmptyWindStore.INSTANCE, 5000, 20000, 20000,
                /* useMarkPassingCalculator */ false, OneDesignRankingMetric::new,
-                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null));
+                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null));

        return spyedTrackedRace;
    }
@@ -59,28 +59,28 @@ public class MultipleClassesInRegattaTest {
                        EmptyRegattaLogStore.INSTANCE, EmptyWindStore.INSTANCE, new DummyTrackedRegattaRegistry(),
                        mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), createConnectivityParams(httpAndHost, liveURI, storedURI, courseDesignUpdateURI,
                                tracTracUsername, tracTracPassword, "cce678c8-97e6-11e0-9aed-406186cbf87c"), RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                        new DefaultRaceTrackingHandler());
+                        new DefaultRaceTrackingHandler(), /* markPassingRaceFingerprintRegistry */ null);
        kiwotest2 = domainFactory
                .createRaceTracker(
                        EmptyRaceLogStore.INSTANCE,
                        EmptyRegattaLogStore.INSTANCE, EmptyWindStore.INSTANCE, new DummyTrackedRegattaRegistry(),
                        mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), createConnectivityParams(httpAndHost, liveURI, storedURI, courseDesignUpdateURI,
                                tracTracUsername, tracTracPassword, "11290bd6-97e7-11e0-9aed-406186cbf87c"), RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                        new DefaultRaceTrackingHandler());
+                        new DefaultRaceTrackingHandler(), /* markPassingRaceFingerprintRegistry */ null);
        kiwotest3 = domainFactory
                .createRaceTracker(
                        EmptyRaceLogStore.INSTANCE,
                        EmptyRegattaLogStore.INSTANCE, EmptyWindStore.INSTANCE, new DummyTrackedRegattaRegistry(),
                        mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), createConnectivityParams(httpAndHost, liveURI, storedURI, courseDesignUpdateURI,
                                tracTracUsername, tracTracPassword, "39635b24-97e7-11e0-9aed-406186cbf87c"), RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                        new DefaultRaceTrackingHandler());
+                        new DefaultRaceTrackingHandler(), /* markPassingRaceFingerprintRegistry */ null);
        weym470may112014_2 = domainFactory
                .createRaceTracker(
                        EmptyRaceLogStore.INSTANCE,
                        EmptyRegattaLogStore.INSTANCE, EmptyWindStore.INSTANCE, new DummyTrackedRegattaRegistry(),
                        mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), createConnectivityParams(httpAndHost, liveURI, storedURI, courseDesignUpdateURI,
                                tracTracUsername, tracTracPassword, "04498426-7dfd-11e0-8236-406186cbf87c"), RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                        new DefaultRaceTrackingHandler());
+                        new DefaultRaceTrackingHandler(), /* markPassingRaceFingerprintRegistry */ null);

        assertEquals("STG", kiwotest1.getRegatta().getBoatClass().getName());
        assertEquals("5O5", kiwotest2.getRegatta().getBoatClass().getName());
@@ -133,9 +133,9 @@ public abstract class OnlineTracTracBasedTest extends AbstractTracTracLiveTest i
        ArrayList<Receiver> receivers = new ArrayList<Receiver>();
        for (Receiver r : domainFactory.getUpdateReceivers(trackedRegatta, getTracTracRace(), EmptyWindStore.INSTANCE, /* delayToLiveInMillis */0l, /* simulator */null, createRaceDefinitionSet(),
                /* trackedRegattaRegistry */ null,
-                mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), /* courseDesignUpdateURI */null, /* tracTracUsername */null, /* tracTracPassword */
-                null, getEventSubscriber(), getRaceSubscriber(), /*ignoreTracTracMarkPassings*/ false, RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                new DefaultRaceTrackingHandler(), /* raceAndCompetitorStatusWithRaceLogReconciler */ null, receiverTypes)) {
+                mock(RaceLogAndTrackedRaceResolver.class), /* markPassingRaceFingerprintRegistry */ null, mock(LeaderboardGroupResolver.class), /* courseDesignUpdateURI */null, /* tracTracPassword */
+                /* tracTracUsername */null, null, getEventSubscriber(), getRaceSubscriber(), /*ignoreTracTracMarkPassings*/ false,
+                RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS, new DefaultRaceTrackingHandler(), /* raceAndCompetitorStatusWithRaceLogReconciler */ null, receiverTypes)) {
            receivers.add(r);
        }
        getRaceSubscriber().subscribeConnectionStatus(new IConnectionStatusListener() {
@@ -129,7 +129,8 @@ public class RaceColumnCacheTest extends AbstractLeaderboardTest {
        TrackedRace spyedTrackedRace = spy(new DynamicTrackedRaceImpl(mockedTrackedRegatta, mockedRace,
                new HashSet<Sideline>(), EmptyWindStore.INSTANCE, 5000, 20000, 20000,
                /* useMarkPassingCalculator */ false, OneDesignRankingMetric::new,
-                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null));
+                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null,
+                /* markPassingRaceFingerprintRegistry */ null));
        return spyedTrackedRace;
    }

@@ -119,7 +119,7 @@ public class ReachingLegTest extends TrackBasedTest {
                /* delayToLiveInMillis */ 0,
                /* millisecondsOverWhichToAverageWind */ 30000, /* millisecondsOverWhichToAverageSpeed */ 30000,
                /* delay for wind estimation cache invalidation */ 0, /*useMarkPassingCalculator*/ false,
-                OneDesignRankingMetric::new, mock(RaceLogAndTrackedRaceResolver.class), null);
+                OneDesignRankingMetric::new, mock(RaceLogAndTrackedRaceResolver.class), null, /* markPassingRaceFingerprintRegistry */ null);
        // in this simplified artificial course, the top mark is exactly north of the right leeward gate, the offset
        // mark is slightly west of the top mark; wind from the north makes the leg from top to offset a reaching leg
        Position leftPosition = new DegreePosition(0, -0.00001);
@@ -121,10 +121,10 @@ public class ReceiveMarkPassingDataTest extends AbstractTracTracLiveTest {
                    public void addRaceDefinition(RaceDefinition race, DynamicTrackedRace trackedRace) {
                    }
                }, /* trackedRegattaRegistry */null,
-                mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), /* courseDesignUpdateURI */null, /* tracTracUsername */null, /* tracTracPassword */
-                null, getEventSubscriber(), getRaceSubscriber(), /*ignoreTracTracMarkPassings*/ false, RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                new DefaultRaceTrackingHandler(), /* raceAndCompetitorStatusWithRaceLogReconciler */ null,
-                ReceiverType.RACECOURSE, ReceiverType.MARKPOSITIONS, ReceiverType.RACESTARTFINISH, ReceiverType.RAWPOSITIONS)) {
+                mock(RaceLogAndTrackedRaceResolver.class), /* markPassingRaceFingerprintRegistry */ null, mock(LeaderboardGroupResolver.class), /* courseDesignUpdateURI */null, /* tracTracPassword */
+                /* tracTracUsername */null, null, getEventSubscriber(), getRaceSubscriber(), /*ignoreTracTracMarkPassings*/ false,
+                RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS, new DefaultRaceTrackingHandler(),
+                /* raceAndCompetitorStatusWithRaceLogReconciler */ null, ReceiverType.RACECOURSE, ReceiverType.MARKPOSITIONS, ReceiverType.RACESTARTFINISH, ReceiverType.RAWPOSITIONS)) {
            receivers.add(r);
            addReceiverToStopDuringTearDown(r);
        }
@@ -89,9 +89,9 @@ public class ReceiveTrackingDataTest extends AbstractTracTracLiveTest {
                            public void addRaceDefinition(RaceDefinition race, DynamicTrackedRace trackedRace) {
                            }
                        },
-                        /* trackedRegattaRegistry */null, mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), getTracTracRace(), /* courseDesignUpdateURI */
-                        null, /* tracTracUsername */null, /* tracTracPassword */null, getEventSubscriber(), getRaceSubscriber(), /*ignoreTracTracMarkPassings*/ false, RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                        new DefaultRaceTrackingHandler(), /* raceAndCompetitorStatusWithRaceLogReconciler */ null)) {
+                        /* trackedRegattaRegistry */null, mock(RaceLogAndTrackedRaceResolver.class), /* markPassingRaceFingerprintRegistry */ null, mock(LeaderboardGroupResolver.class), /* courseDesignUpdateURI */
+                        getTracTracRace(), null, /* tracTracUsername */null, /* tracTracPassword */null, getEventSubscriber(), getRaceSubscriber(), /*ignoreTracTracMarkPassings*/ false,
+                        RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS, new DefaultRaceTrackingHandler(), /* raceAndCompetitorStatusWithRaceLogReconciler */ null)) {
            receiver.subscribe();
            getRaceSubscriber().start();
            addReceiverToStopDuringTearDown(receiver);
@@ -103,9 +103,9 @@ public class ReceiveTrackingDataTest extends AbstractTracTracLiveTest {
                            @Override
                            public void addRaceDefinition(RaceDefinition race, DynamicTrackedRace trackedRace) {
                            }
-                        }, /* trackedRegattaRegistry */null, mock(RaceLogAndTrackedRaceResolver.class), mock(LeaderboardGroupResolver.class), getTracTracRace(), /* courseDesignUpdateURI */
-                        null, /* tracTracUsername */null, /* tracTracPassword */null, getEventSubscriber(), getRaceSubscriber(), /*ignoreTracTracMarkPassings*/ false, RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                        new DefaultRaceTrackingHandler(), /* raceAndCompetitorStatusWithRaceLogReconciler */ null));
+                        }, /* trackedRegattaRegistry */null, mock(RaceLogAndTrackedRaceResolver.class), /* markPassingRaceFingerprintRegistry */ null, mock(LeaderboardGroupResolver.class), /* courseDesignUpdateURI */
+                        getTracTracRace(), null, /* tracTracUsername */null, /* tracTracPassword */null, getEventSubscriber(), getRaceSubscriber(), /*ignoreTracTracMarkPassings*/ false,
+                        RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS, new DefaultRaceTrackingHandler(), /* raceAndCompetitorStatusWithRaceLogReconciler */ null));
    }

    @Test
@@ -42,7 +42,7 @@ public class SerializeRankingMetricTest extends AbstractSerializationTest {
                new RaceDefinitionImpl("Race", new CourseImpl("Course", Collections.<Waypoint>emptyList()) , 
                        /* boatClass */ _49er, Collections.<Competitor,Boat>emptyMap()),
                Collections.<Sideline> emptyList(), EmptyWindStore.INSTANCE, 0l, 0l, 0l,
-                false, TimeOnTimeAndDistanceRankingMetric::new, null, /* trackingConnectorInfo */ null);
+                false, TimeOnTimeAndDistanceRankingMetric::new, null, /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        RankingMetric clone = cloneBySerialization(trackedRace.getRankingMetric(), DomainFactory.INSTANCE);
        assertNotNull(clone);
        assertTrue(clone instanceof TimeOnTimeAndDistanceRankingMetric);
@@ -91,7 +91,7 @@ public class StarbordSideOfStartLineRecognitionTest {

        public MockedTrackedRaceImpl() {
            super(null, null, Collections.<Sideline> emptyList(), null, 0, 0, 0, 0, false, OneDesignRankingMetric::new,
-                    mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null);
+                    mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        }
        
        @Override
@@ -33,7 +33,7 @@ import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.common.impl.KnotSpeedImpl;
 import com.sap.sailing.domain.common.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.common.impl.WindImpl;
-import com.sap.sailing.domain.polars.NotEnoughDataHasBeenAddedException;
+import com.sap.sailing.domain.common.polars.NotEnoughDataHasBeenAddedException;
 import com.sap.sailing.domain.polars.PolarDataService;
 import com.sap.sailing.domain.tracking.MarkPositionAtTimePointCache;
 import com.sap.sailing.domain.tracking.TrackedLeg;
@@ -201,7 +201,7 @@ public abstract class TrackBasedTest {
                /* delayToLiveInMillis */ 0,
                /* millisecondsOverWhichToAverageWind */ 30000, /* millisecondsOverWhichToAverageSpeed */ 30000,
                /* delay for wind estimation cache invalidation */ 0, useMarkPassingCalculator,
-                rankingMetricConstructor, raceLogResolver, /* trackingConnectorInfo */ null);
+                rankingMetricConstructor, raceLogResolver, /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        // in this simplified artificial course, the top mark is exactly north of the right leeward gate
        DegreePosition topPosition = new DegreePosition(54.48, 10.24);
        TimePoint afterTheRace = new MillisecondsTimePoint(timePointForFixes.asMillis() + 36000000); // 10h after the fix timed
@@ -74,7 +74,7 @@ public class UnicodeCharactersInCompetitorNamesTest {
                                                /* preferReplayIfAvailable */ false, /* timeoutInMillis */ (int) RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
                                                /* useOfficialEventsToUpdateRaceLog */ false),
                                                RaceTracker.TIMEOUT_FOR_RECEIVING_RACE_DEFINITION_IN_MILLISECONDS,
-                                                new DefaultRaceTrackingHandler());
+                                                new DefaultRaceTrackingHandler(), /* markPassingRaceFingerprintRegistry */ null);

        Iterable<Competitor> competitors = fourtyninerYellow_2.getRaceHandle().getRace().getCompetitors();
        for (Competitor competitor : competitors) {
@@ -53,7 +53,7 @@ public class UpdateMarkPassingTest {
                race, Collections.<Sideline> emptyList(), EmptyWindStore.INSTANCE, /* delayToLiveInMillis */1000,
                /* millisecondsOverWhichToAverageWind */30000, /* millisecondsOverWhichToAverageSpeed */30000,
                /* useMarkPassingCalculator */ false, OneDesignRankingMetric::new,
-                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null);
+                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        TimePoint now = MillisecondsTimePoint.now();
        TimePoint later = now.plus(1000);
        trackedRace.updateMarkPassings(competitor, Arrays.asList(new MarkPassing[] { new MarkPassingImpl(now, waypoint, competitor) }));
@@ -108,7 +108,7 @@ public class WindEstimationLockingUnderLoadTest {
                /* sidelines */ Collections.emptySet(), EmptyWindStore.INSTANCE, /* delayToLiveInMillis */ 10000,
                /* millisecondsOverWhichToAverageWind */ 30000, /* millisecondsOverWhichToAverageSpeed */ 15000,
                /* useInternalMarkPassingAlgorithm */ false, regatta.getRankingMetricConstructor(), /* raceLogResolver */ null,
-                /* trackingConnectorInfo */ null) {
+                /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null) {
                    private static final long serialVersionUID = 1L;

                    @Override
@@ -356,7 +356,7 @@ public class WindTest {
                EmptyWindStore.INSTANCE, /* delayToLiveInMillis */ 1000,
                        /* millisecondsOverWhichToAverageWind */ 30000,
                        /* millisecondsOverWhichToAverageSpeed */ 30000, /*useMarkPassingCalculator*/ false, OneDesignRankingMetric::new,
-                        mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null);
+                        mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        TimePoint start = MillisecondsTimePoint.now();
        TimePoint topMarkRounding = start.plus(30000);
        TimePoint finish = topMarkRounding.plus(30000);
@@ -107,7 +107,7 @@ public abstract class AbstractExportedPositionsBasedTest {
                EmptyWindStore.INSTANCE,
                /* delayToLiveInMillis */ 3000, /* millisecondsOverWhichToAverageWind */ 15000,
                /* millisecondsOverWhichToAverageSpeed */ 10000, /* useInternalMarkPassingAlgorithm */ true,
-                OneDesignRankingMetric::new, /* raceLogResolver */ null, /* trackingConnectorInfo */ null);
+                OneDesignRankingMetric::new, /* raceLogResolver */ null, /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        result.setStatus(new TrackedRaceStatusImpl(TrackedRaceStatusEnum.LOADING, 0.0));
        for (final Entry<CompetitorWithBoat, Iterable<GPSFixMoving>> e : competitorsAndTheirTracks.entrySet()) {
            final DynamicGPSFixTrack<Competitor, GPSFixMoving> track = result.getTrack(e.getKey());
@@ -120,7 +120,7 @@ public abstract class AbstractMarkPassingTest extends OnlineTracTracBasedTest {
        Map<Competitor, Map<Waypoint, MarkPassing>> computedPasses = new HashMap<>();
        // Get calculatedMarkPasses
        long time = System.currentTimeMillis();
-        MarkPassingCalculator mpc = new MarkPassingCalculator(getTrackedRace(), false, /* waitForInitialMarkPassingCalculation */ true);
+        MarkPassingCalculator mpc = new MarkPassingCalculator(getTrackedRace(), false, /* waitForInitialMarkPassingCalculation */ true, /* markPassingRaceFingerprintRegistry */ null);
        time = System.currentTimeMillis() - time;

        for (Competitor c : getRace().getCompetitors()) {
@@ -88,7 +88,7 @@ public class AbstractMockedRaceMarkPassingTest {
        race = new DynamicTrackedRaceImpl(new DynamicTrackedRegattaImpl(r), raceDef, new ArrayList<Sideline>(),
                new EmptyWindStore(), 0, 10000, 10000, /* useMarkPassingCalculator */ false,
                OneDesignRankingMetric::new,
-                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null);
+                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
        race.setStartTimeReceived(new MillisecondsTimePoint(10000));
        TimePoint t = new MillisecondsTimePoint(30000);
        List<Util.Pair<Mark, Position>> pos = Arrays.asList(new Util.Pair<Mark, Position>(m, new DegreePosition(0, 0)),
@@ -49,7 +49,7 @@ public class StarIDM2013MarkPassingTest extends AbstractMarkPassingTest {
    }

    private void testWholeRace5() throws InvalidDateException {
-        new MarkPassingCalculator(getTrackedRace(), false, /* waitForInitialMarkPassingCalculation */ true); // do our calculation, injecting into TrackedRace
+        new MarkPassingCalculator(getTrackedRace(), false, /* waitForInitialMarkPassingCalculation */ true, /* markPassingRaceFingerprintRegistry */ null); // do our calculation, injecting into TrackedRace
        final Competitor GER7897 = getCompetitorByName("Tusch, Frank,Winkelmann, Sven");
        // the start mark passing of Tuschi and Sven is a bit dubious; TracTrac sees them over the line at 2013-05-04T14:50:10+0200
        // but at that time the pin end still seems to be moving to port, and the track seems to pass the pin end on the outside;
@@ -9,11 +9,18 @@ import java.net.MalformedURLException;
 import java.net.URISyntaxException;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.UUID;

 import org.json.simple.JSONObject;
 import org.junit.Before;
 import org.junit.Test;

+import com.sap.sailing.domain.abstractlog.impl.LogEventAuthorImpl;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFixedMarkPassingEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogSuppressedMarkPassingsEvent;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogFixedMarkPassingEventImpl;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogImpl;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogSuppressedMarkPassingsEventImpl;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.ControlPoint;
 import com.sap.sailing.domain.base.ControlPointWithTwoMarks;
@@ -25,6 +32,7 @@ import com.sap.sailing.domain.base.impl.WaypointImpl;
 import com.sap.sailing.domain.common.PassingInstruction;
 import com.sap.sailing.domain.common.Position;
 import com.sap.sailing.domain.common.SpeedWithBearing;
+import com.sap.sailing.domain.common.abstractlog.NotRevokableException;
 import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.common.tracking.GPSFixMoving;
 import com.sap.sailing.domain.common.tracking.impl.GPSFixImpl;
@@ -60,14 +68,16 @@ public class MarkPassingRaceFingerprintJsonSerializationTest extends OnlineTracT
                new ReceiverType[] { ReceiverType.MARKPASSINGS, ReceiverType.MARKPOSITIONS, ReceiverType.RACECOURSE,
                        ReceiverType.RACESTARTFINISH, ReceiverType.RAWPOSITIONS, ReceiverType.SENSORDATA });
        trackedRace1 = getTrackedRace();
+        trackedRace1.attachRaceLog(new RaceLogImpl(UUID.randomUUID()));
        super.setUp();
        super.setUp("event_20110505_SailingTea", // Semifinale
                /* raceId */ "01ea3604-02ef-11e1-9efc-406186cbf87c", /* liveUri */ null, /* storedUri */ null,
                new ReceiverType[] { ReceiverType.MARKPASSINGS, ReceiverType.MARKPOSITIONS, ReceiverType.RACECOURSE,
                        ReceiverType.RACESTARTFINISH, ReceiverType.RAWPOSITIONS, ReceiverType.SENSORDATA });
        trackedRace2 = getTrackedRace();
-        calculator1 = new MarkPassingCalculator(trackedRace1, false, false);
-        calculator2 = new MarkPassingCalculator(trackedRace2, false, false);
+        trackedRace2.attachRaceLog(new RaceLogImpl(UUID.randomUUID()));
+        calculator1 = new MarkPassingCalculator(trackedRace1, false, false, /* markPassingRaceFingerprintRegistry */ null);
+        calculator2 = new MarkPassingCalculator(trackedRace2, false, false, /* markPassingRaceFingerprintRegistry */ null);
    }

    @Test
@@ -148,6 +158,74 @@ public class MarkPassingRaceFingerprintJsonSerializationTest extends OnlineTracT
        assertNotEquals("Json1 and Json2 are equal: " + json1 + " json2: " + json2, json1, json2);
    }

+    @Test
+    public void testFixedMarkPassingAddition() {
+        MarkPassingRaceFingerprintFactory factory = MarkPassingRaceFingerprintFactory.INSTANCE;
+        MarkPassingRaceFingerprint fingerprint1 = factory.createFingerprint(trackedRace1);
+        assertTrue(fingerprint1.matches(trackedRace2));
+        trackedRace2.getAttachedRaceLogs().iterator().next().add(new RaceLogFixedMarkPassingEventImpl(TimePoint.now(), new LogEventAuthorImpl("me", 0),
+                trackedRace2.getRace().getCompetitors().iterator().next(), /* pPassId */ 1, TimePoint.now(), 0));
+        MarkPassingRaceFingerprint fingerprint2 = factory.createFingerprint(trackedRace2);
+        assertFalse(fingerprint1.matches(trackedRace2));
+        assertFalse(fingerprint2.matches(trackedRace1));
+        JSONObject json1 = fingerprint1.toJson();
+        JSONObject json2 = fingerprint2.toJson();
+        assertNotEquals("Json1 and Json2 are equal: " + json1 + " json2: " + json2, json1, json2);
+    }
+
+    @Test
+    public void testFixedMarkPassingRevocation() throws NotRevokableException {
+        final LogEventAuthorImpl author = new LogEventAuthorImpl("me", 0);
+        final RaceLogFixedMarkPassingEvent fixedMarkPassingEvent = new RaceLogFixedMarkPassingEventImpl(TimePoint.now(), author,
+                trackedRace2.getRace().getCompetitors().iterator().next(), /* pPassId */ 1, TimePoint.now(), 0);
+        trackedRace1.getAttachedRaceLogs().iterator().next().add(fixedMarkPassingEvent);
+        trackedRace2.getAttachedRaceLogs().iterator().next().add(fixedMarkPassingEvent);
+        MarkPassingRaceFingerprintFactory factory = MarkPassingRaceFingerprintFactory.INSTANCE;
+        MarkPassingRaceFingerprint fingerprint1 = factory.createFingerprint(trackedRace1);
+        assertTrue(fingerprint1.matches(trackedRace2));
+        trackedRace2.getAttachedRaceLogs().iterator().next().revokeEvent(author, fixedMarkPassingEvent);
+        MarkPassingRaceFingerprint fingerprint2 = factory.createFingerprint(trackedRace2);
+        assertFalse(fingerprint1.matches(trackedRace2));
+        assertFalse(fingerprint2.matches(trackedRace1));
+        JSONObject json1 = fingerprint1.toJson();
+        JSONObject json2 = fingerprint2.toJson();
+        assertNotEquals("Json1 and Json2 are equal: " + json1 + " json2: " + json2, json1, json2);
+    }
+
+    @Test
+    public void testMarkPassingSuppressionAddition() {
+        MarkPassingRaceFingerprintFactory factory = MarkPassingRaceFingerprintFactory.INSTANCE;
+        MarkPassingRaceFingerprint fingerprint1 = factory.createFingerprint(trackedRace1);
+        assertTrue(fingerprint1.matches(trackedRace2));
+        trackedRace2.getAttachedRaceLogs().iterator().next().add(new RaceLogSuppressedMarkPassingsEventImpl(TimePoint.now(), new LogEventAuthorImpl("me", 0),
+                trackedRace2.getRace().getCompetitors().iterator().next(), /* pPassId */ 1, 0));
+        MarkPassingRaceFingerprint fingerprint2 = factory.createFingerprint(trackedRace2);
+        assertFalse(fingerprint1.matches(trackedRace2));
+        assertFalse(fingerprint2.matches(trackedRace1));
+        JSONObject json1 = fingerprint1.toJson();
+        JSONObject json2 = fingerprint2.toJson();
+        assertNotEquals("Json1 and Json2 are equal: " + json1 + " json2: " + json2, json1, json2);
+    }
+
+    @Test
+    public void testMarkPassingSuppressionAdditionRevocation() throws NotRevokableException {
+        final LogEventAuthorImpl author = new LogEventAuthorImpl("me", 0);
+        final RaceLogSuppressedMarkPassingsEvent fixedMarkPassingEvent = new RaceLogSuppressedMarkPassingsEventImpl(TimePoint.now(), author,
+                trackedRace2.getRace().getCompetitors().iterator().next(), /* pPassId */ 1, 0);
+        trackedRace1.getAttachedRaceLogs().iterator().next().add(fixedMarkPassingEvent);
+        trackedRace2.getAttachedRaceLogs().iterator().next().add(fixedMarkPassingEvent);
+        MarkPassingRaceFingerprintFactory factory = MarkPassingRaceFingerprintFactory.INSTANCE;
+        MarkPassingRaceFingerprint fingerprint1 = factory.createFingerprint(trackedRace1);
+        assertTrue(fingerprint1.matches(trackedRace2));
+        trackedRace2.getAttachedRaceLogs().iterator().next().revokeEvent(author, fixedMarkPassingEvent);
+        MarkPassingRaceFingerprint fingerprint2 = factory.createFingerprint(trackedRace2);
+        assertFalse(fingerprint1.matches(trackedRace2));
+        assertFalse(fingerprint2.matches(trackedRace1));
+        JSONObject json1 = fingerprint1.toJson();
+        JSONObject json2 = fingerprint2.toJson();
+        assertNotEquals("Json1 and Json2 are equal: " + json1 + " json2: " + json2, json1, json2);
+    }
+
    @Test
    public void testCompetitorFixChange() {
        DynamicTrackedRaceImpl testRace = trackedRace2;
@@ -44,6 +44,7 @@ import com.sap.sailing.domain.common.TargetTimeInfo;
 import com.sap.sailing.domain.common.Wind;
 import com.sap.sailing.domain.common.WindSource;
 import com.sap.sailing.domain.common.WindSourceType;
+import com.sap.sailing.domain.common.polars.NotEnoughDataHasBeenAddedException;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.tracking.GPSFix;
 import com.sap.sailing.domain.common.tracking.GPSFixMoving;
@@ -52,7 +53,7 @@ import com.sap.sailing.domain.leaderboard.ScoringScheme;
 import com.sap.sailing.domain.leaderboard.impl.CompetitorAndRankComparable;
 import com.sap.sailing.domain.leaderboard.impl.CompetitorProviderFromRaceColumnsAndRegattaLike;
 import com.sap.sailing.domain.leaderboard.impl.RankAndRankComparable;
-import com.sap.sailing.domain.polars.NotEnoughDataHasBeenAddedException;
+import com.sap.sailing.domain.markpassinghash.MarkPassingRaceFingerprintRegistry;
 import com.sap.sailing.domain.polars.PolarDataService;
 import com.sap.sailing.domain.racelog.RaceLogAndTrackedRaceResolver;
 import com.sap.sailing.domain.ranking.RankingMetric;
@@ -676,7 +677,7 @@ public class MockedTrackedRace implements DynamicTrackedRace {
                    DynamicRaceDefinitionSet raceDefinitionSetToUpdate, boolean useMarkPassingcalculator,
                    RaceLogAndTrackedRaceResolver raceLogResolver,
                    Optional<ThreadLocalTransporter> threadLocalTransporter,
-                    TrackingConnectorInfo trackingConnectorInfo) {
+                    TrackingConnectorInfo trackingConnectorInfo, MarkPassingRaceFingerprintRegistry markPassingRaceFingerprintRegistry) {
                return null;
            }

@@ -39,13 +39,13 @@ import com.sap.sailing.domain.common.TargetTimeInfo;
 import com.sap.sailing.domain.common.Wind;
 import com.sap.sailing.domain.common.WindSource;
 import com.sap.sailing.domain.common.WindSourceType;
+import com.sap.sailing.domain.common.polars.NotEnoughDataHasBeenAddedException;
 import com.sap.sailing.domain.common.tracking.GPSFix;
 import com.sap.sailing.domain.common.tracking.GPSFixMoving;
 import com.sap.sailing.domain.common.tracking.SensorFix;
 import com.sap.sailing.domain.leaderboard.Leaderboard.RankComparableRank;
 import com.sap.sailing.domain.leaderboard.impl.CompetitorAndRankComparable;
 import com.sap.sailing.domain.leaderboard.impl.RankAndRankComparable;
-import com.sap.sailing.domain.polars.NotEnoughDataHasBeenAddedException;
 import com.sap.sailing.domain.polars.PolarDataService;
 import com.sap.sailing.domain.ranking.RankingMetric;
 import com.sap.sailing.domain.ranking.RankingMetric.RankingInfo;
@@ -122,6 +122,6 @@ public class TrackedRegattaTest {
        RaceDefinition race1 = new RaceDefinitionImpl(name, course, boatClass, Collections.emptyMap());
        return new DynamicTrackedRaceImpl(regatta, race1, Collections.<Sideline> emptyList(),
                EmptyWindStore.INSTANCE, 0, 0, 0, /* useMarkPassingCalculator */ false, OneDesignRankingMetric::new,
-                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null);
+                mock(RaceLogAndTrackedRaceResolver.class), /* trackingConnectorInfo */ null, /* markPassingRaceFingerprintRegistry */ null);
    }
 }