Changes in f7c52b6: bug6219: implementation that lets formerly failing test pass; if tied on medal series points, apply compareByBetterScore to the scoring medal race columns

				java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/LeaderboardScoringAndRankingForLowPointsTest.java
			
          @@ -215,20 +215,22 @@ public class LeaderboardScoringAndRankingForLowPointsTest extends LeaderboardSco

                   // in favor of C2 because C2 must have performed better in the medal races F1/F2 due to the worse

                   // carried score

                   assertEquals(raceColumnNames.size(), leaderboard.getNetPoints(competitors.get(0), carryColumn, now), EPSILON);

          -        leaderboard.getScoreCorrection().correctScore(competitors.get(0), f1, 5.0);

          -        leaderboard.getScoreCorrection().correctScore(competitors.get(0), f2, 3.0); // medal series: 3 (Carry) + 5 + 3 = 11

          +        leaderboard.getScoreCorrection().correctScore(competitors.get(0), f1, 7.0);

          +        leaderboard.getScoreCorrection().correctScore(competitors.get(0), f2, 3.0); // medal series: 5 (Carry) + 7 + 3 = 15

                   assertEquals(2*raceColumnNames.size(), leaderboard.getNetPoints(competitors.get(1), carryColumn, now), EPSILON);

                   leaderboard.getScoreCorrection().correctScore(competitors.get(1), f1, 1.0);

          -        leaderboard.getScoreCorrection().correctScore(competitors.get(1), f2, 4.0); // medal series: 6 (Carry) + 1 + 4 = 11

          +        leaderboard.getScoreCorrection().correctScore(competitors.get(1), f2, 4.0); // medal series: 10 (Carry) + 1 + 4 = 15

          +        assertEquals(leaderboard.getNetPoints(competitors.get(0), now), leaderboard.getNetPoints(competitors.get(1), now), EPSILON);

                   // construct a tie between C9 and C10 (index 8 and 9, respectively); the tie is expected to be broken

                   // in favor of C9 because although both carried the same number of points from the open series due

                   // to the "reduced points" rule, and both scores equal points in total in F1 and F2, C9 had the better

                   // best score.

                   assertEquals(leaderboard.getNetPoints(competitors.get(8), carryColumn, now), leaderboard.getNetPoints(competitors.get(9), carryColumn, now), EPSILON);

          -        leaderboard.getScoreCorrection().correctScore(competitors.get(8), f1, 6.0);

          -        leaderboard.getScoreCorrection().correctScore(competitors.get(8), f2, 8.0);

          -        leaderboard.getScoreCorrection().correctScore(competitors.get(9), f1, 7.0);

          -        leaderboard.getScoreCorrection().correctScore(competitors.get(9), f2, 7.0);

          +        leaderboard.getScoreCorrection().correctScore(competitors.get(8), f1, 5.0);

          +        leaderboard.getScoreCorrection().correctScore(competitors.get(8), f2, 7.0);

          +        leaderboard.getScoreCorrection().correctScore(competitors.get(9), f1, 6.0);

          +        leaderboard.getScoreCorrection().correctScore(competitors.get(9), f2, 6.0);

          +        assertEquals(leaderboard.getNetPoints(competitors.get(8), now), leaderboard.getNetPoints(competitors.get(9), now), EPSILON);

                   // construct a tie between C7 and C8 (index 6 and 7, respectively); the tie is based on

                   // equal carried points and equal medal series points throughout (both DNF in F1 and F2),

                   // but C7 is expected to be ranked better because of the better rank in the opening series,

          @@ -251,7 +253,7 @@ public class LeaderboardScoringAndRankingForLowPointsTest extends LeaderboardSco

                   leaderboard.getScoreCorrection().correctScore(competitors.get(2), f2, 1.0);

                   leaderboard.getScoreCorrection().correctScore(competitors.get(3), f2, 2.0);

                   leaderboard.getScoreCorrection().correctScore(competitors.get(4), f2, 5.0);

          -        leaderboard.getScoreCorrection().correctScore(competitors.get(5), f2, 6.0);

          +        leaderboard.getScoreCorrection().correctScore(competitors.get(5), f2, 8.0);

                   final Iterable<Competitor> ranking = leaderboard.getCompetitorsFromBestToWorst(now);

                   assertTrue(Util.indexOf(ranking, competitors.get(6)) < Util.indexOf(ranking, competitors.get(7)));

                   assertTrue(Util.indexOf(ranking, competitors.get(8)) < Util.indexOf(ranking, competitors.get(9)));

				java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/ScoringScheme.java
			
          @@ -100,7 +100,6 @@ public interface ScoringScheme extends Serializable {

                *            scores of the first competitor, in the order of race columns in the leaderboard

                * @param competitor2Scores

                *            scores of the second competitor, in the order of race columns in the leaderboard

          -     * @param raceColumnsToConsider TODO

                * @param discardedRaceColumnsPerCompetitor

                *            for each competitor holds the result of {@link Leaderboard#getResultDiscardingRule()

                *            Leaderborad.getResultDiscardingRule()}{@code .}{@link ResultDiscardingRule#getDiscardedRaceColumns(Competitor, Leaderboard, Iterable, TimePoint, ScoringScheme)

          @@ -108,8 +107,11 @@ public interface ScoringScheme extends Serializable {

                *            for each competitor again.

                */

               int compareByBetterScore(Competitor o1, List<Util.Pair<RaceColumn, Double>> competitor1Scores, Competitor o2,

          -            List<Util.Pair<RaceColumn, Double>> competitor2Scores, Iterable<RaceColumn> raceColumnsToConsider, boolean nullScoresAreBetter,

          -            TimePoint timePoint, Leaderboard leaderboard, Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor, BiFunction<Competitor, RaceColumn, Double> totalPointsSupplier, WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache);

          +            List<Util.Pair<RaceColumn, Double>> competitor2Scores, Iterable<RaceColumn> raceColumnsToConsider,

          +            boolean nullScoresAreBetter, TimePoint timePoint, Leaderboard leaderboard,

          +            Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor,

          +            BiFunction<Competitor, RaceColumn, Double> totalPointsSupplier,

          +            WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache);

               /**

                * In case two competitors scored in different numbers of races, this scoring scheme decides whether this

          @@ -349,16 +351,28 @@ public interface ScoringScheme extends Serializable {

               }

               /**

          -     * Precondition: either both scored in medal race or both didn't. If both scored, the better score wins.

          +     * Precondition: either both scored in medal race or both didn't. If both scored, the better score sum wins. If both

          +     * scored the same sum in the medal races, apply

          +     * {@link #compareByScoreSum(Competitor, List, double, Competitor, List, double, boolean, boolean, Supplier)} to

          +     * apply the same tie breaking to the medal races as for other series.

          +     * <p>

          +     * 

                * This is to be applied only if the net score of both competitors are equal to each other.

                */

          -    default int compareByMedalRaceScore(Double o1MedalRaceScore, Double o2MedalRaceScore, boolean nullScoresAreBetter) {

          +    default int compareByMedalRaceScore(Competitor o1, Competitor o2, Double o1MedalRaceScore, Double o2MedalRaceScore,

          +            List<Pair<RaceColumn, Double>> o1ScoringMedalRaces, List<Pair<RaceColumn, Double>> o2ScoringMedalRaces,

          +            TimePoint timePoint, Leaderboard leaderboard,

          +            Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor,

          +            BiFunction<Competitor, RaceColumn, Double> totalPointsSupplier, boolean nullScoresAreBetter,

          +            WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache) {

                   assert o1MedalRaceScore != null || o2MedalRaceScore == null;

                   final int result;

                   if (o1MedalRaceScore != null) {

                       result = getScoreComparator(nullScoresAreBetter).compare(o1MedalRaceScore, o2MedalRaceScore);

                   } else {

          -            result = 0;

          +            result = compareByBetterScore(o1, o1ScoringMedalRaces, o2, o2ScoringMedalRaces, Util.map(o1ScoringMedalRaces, Pair::getA),

          +                    nullScoresAreBetter, timePoint, leaderboard, discardedRaceColumnsPerCompetitor, totalPointsSupplier,

          +                    cache);

                   }

                   return result;

               }

				java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/LeaderboardTotalRankComparator.java
			
          @@ -169,8 +169,10 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {

                   List<Util.Pair<RaceColumn, Double>> o2TotalPoints = new ArrayList<>();

                   double o1ScoreSum = getLeaderboard().getCarriedPoints(o1);

                   double o2ScoreSum = getLeaderboard().getCarriedPoints(o2);

          -        Double o1MedalRaceScore = 0.0; // "blindly" adds them all up, regardless of "series starts with zero score"

          -        Double o2MedalRaceScore = 0.0; // "blindly" adds them all up, regardless of "series starts with zero score"

          +        final List<Util.Pair<RaceColumn, Double>> o1ScoringMedalRaces = new ArrayList<>();

          +        final List<Util.Pair<RaceColumn, Double>> o2ScoringMedalRaces = new ArrayList<>();

          +        Double o1MedalRaceScoreSum = 0.0; // "blindly" adds them all up, regardless of "series starts with zero score"

          +        Double o2MedalRaceScoreSum = 0.0; // "blindly" adds them all up, regardless of "series starts with zero score"

                   Double o1CarryForwardScoreInMedals = null;

                   Double o2CarryForwardScoreInMedals = null;

                   // When a column has isStartsWithZeroScore, the competitor's score only need to be reset to zero if from there on

          @@ -240,10 +242,12 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {

                               // only count the score for the medal race score if it wasn't a carry-forward column

                               if (!raceColumn.isCarryForward()) {

                                   if (o1Score != null) {

          -                            o1MedalRaceScore += o1Score;

          +                            o1MedalRaceScoreSum += o1Score;

          +                            o1ScoringMedalRaces.add(new Pair<>(raceColumn, o1Score));

                                   }

                                   if (o2Score != null) {

          -                            o2MedalRaceScore += o2Score;

          +                            o2MedalRaceScoreSum += o2Score;

          +                            o2ScoringMedalRaces.add(new Pair<>(raceColumn, o2Score));

                                   }

                               } else {

                                   o1CarryForwardScoreInMedals = o1Score;

          @@ -319,7 +323,12 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {

                                                   (competitor, raceColumn)->totalPointsCache.get(new Pair<>(competitor, raceColumn)), cache, timePoint,

                                                   zeroBasedIndexOfLastMedalSeriesInWhichO1Scored, numberOfMedalRacesWonO1, numberOfMedalRacesWonO2);

                                           if (result == 0) {

          -                                    result = scoringScheme.compareByMedalRaceScore(o1MedalRaceScore, o2MedalRaceScore, nullScoresAreBetter);

          +                                    result = scoringScheme.compareByMedalRaceScore(o1, o2, o1MedalRaceScoreSum,

          +                                            o2MedalRaceScoreSum, o1ScoringMedalRaces, o2ScoringMedalRaces, timePoint,

          +                                            leaderboard, Collections.unmodifiableMap(discardedRaceColumnsPerCompetitor),

          +                                            (competitor1, raceColumn1) -> totalPointsCache

          +                                                    .get(new Pair<>(competitor1, raceColumn1)),

          +                                            nullScoresAreBetter, cache);

                                               if (result == 0) {

                                                   result = scoringScheme.compareByBetterScore(o1, Collections.unmodifiableList(o1TotalPoints),

                                                                                               o2, Collections.unmodifiableList(o2TotalPoints),

				java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/LowPointFirstToWinThreeRaces.java
			
          @@ -355,7 +355,7 @@ public class LowPointFirstToWinThreeRaces extends LowPoint {

                * {@link #compareByMedalRacesWon(int, int)} instead.

                */

               @Override

          -    public int compareByMedalRaceScore(Double o1MedalRaceScore, Double o2MedalRaceScore, boolean nullScoresAreBetter) {

          +    public int compareByMedalRaceScore(Competitor o1, Competitor o2, Double o1MedalRaceScore, Double o2MedalRaceScore, List<Pair<RaceColumn, Double>> o1ScoringMedalRaces, List<Pair<RaceColumn, Double>> o2ScoringMedalRaces, TimePoint timePoint, Leaderboard leaderboard, Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor, BiFunction<Competitor, RaceColumn, Double> totalPointSupplier, boolean nullScoresAreBetter, WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache) {

                   return 0;

               }

				java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/LowPointWithEliminatingMedalSeriesWithPromotions.java
			
          @@ -126,7 +126,7 @@ public abstract class LowPointWithEliminatingMedalSeriesWithPromotions extends L

                * medal series, or if already at the first medal series, the opening series will be used for tie-breaking.

                */

               @Override

          -    public int compareByMedalRaceScore(Double o1MedalRaceScore, Double o2MedalRaceScore, boolean nullScoresAreBetter) {

          +    public int compareByMedalRaceScore(Competitor o1, Competitor o2, Double o1MedalRaceScore, Double o2MedalRaceScore, List<Pair<RaceColumn, Double>> o1ScoringMedalRaces, List<Pair<RaceColumn, Double>> o2ScoringMedalRaces, TimePoint timePoint, Leaderboard leaderboard, Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor, BiFunction<Competitor, RaceColumn, Double> totalPointSupplier, boolean nullScoresAreBetter, WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache) {

                   return 0;

               }

				java/com.sap.sse.test/src/com/sap/sse/test/CPUTimeMeasurementTest.java
			
          @@ -1,5 +1,6 @@

           package com.sap.sse.test;

          +import static org.junit.jupiter.api.Assertions.assertEquals;

           import static org.junit.jupiter.api.Assertions.assertFalse;

           import static org.junit.jupiter.api.Assertions.assertTrue;

          @@ -13,6 +14,8 @@ import org.junit.jupiter.api.BeforeAll;

           import org.junit.jupiter.api.Disabled;

           import org.junit.jupiter.api.Test;

          +import com.sap.sse.metering.CPUMeter;

          +

           public class CPUTimeMeasurementTest {

               private static final Logger logger = Logger.getLogger(CPUTimeMeasurementTest.class.getName());

          @@ -38,6 +41,12 @@ public class CPUTimeMeasurementTest {

                           +" ("+((double) durationWithCpuTimeEnabled / (double) durationWithCpuTimeDisabled)+")");

                   assertFalse((double) durationWithCpuTimeEnabled > 1.5*durationWithCpuTimeDisabled);

               }

          +   

          +    @Test

          +    public void testCallableResultProperlyReturned() {

          +        final int result = CPUMeter.create().callWithCPUMeter(() -> { return 2; });

          +        assertEquals(2, result);

          +    }

               @Test

               public void testSingleThreadedWorkloadOffByLessThanFactorTwo() {

...	...	@@ -215,20 +215,22 @@ public class LeaderboardScoringAndRankingForLowPointsTest extends LeaderboardSco
215	215	// in favor of C2 because C2 must have performed better in the medal races F1/F2 due to the worse
216	216	// carried score
217	217	assertEquals(raceColumnNames.size(), leaderboard.getNetPoints(competitors.get(0), carryColumn, now), EPSILON);
218		- leaderboard.getScoreCorrection().correctScore(competitors.get(0), f1, 5.0);
219		- leaderboard.getScoreCorrection().correctScore(competitors.get(0), f2, 3.0); // medal series: 3 (Carry) + 5 + 3 = 11
	218	+ leaderboard.getScoreCorrection().correctScore(competitors.get(0), f1, 7.0);
	219	+ leaderboard.getScoreCorrection().correctScore(competitors.get(0), f2, 3.0); // medal series: 5 (Carry) + 7 + 3 = 15
220	220	assertEquals(2*raceColumnNames.size(), leaderboard.getNetPoints(competitors.get(1), carryColumn, now), EPSILON);
221	221	leaderboard.getScoreCorrection().correctScore(competitors.get(1), f1, 1.0);
222		- leaderboard.getScoreCorrection().correctScore(competitors.get(1), f2, 4.0); // medal series: 6 (Carry) + 1 + 4 = 11
	222	+ leaderboard.getScoreCorrection().correctScore(competitors.get(1), f2, 4.0); // medal series: 10 (Carry) + 1 + 4 = 15
	223	+ assertEquals(leaderboard.getNetPoints(competitors.get(0), now), leaderboard.getNetPoints(competitors.get(1), now), EPSILON);
223	224	// construct a tie between C9 and C10 (index 8 and 9, respectively); the tie is expected to be broken
224	225	// in favor of C9 because although both carried the same number of points from the open series due
225	226	// to the "reduced points" rule, and both scores equal points in total in F1 and F2, C9 had the better
226	227	// best score.
227	228	assertEquals(leaderboard.getNetPoints(competitors.get(8), carryColumn, now), leaderboard.getNetPoints(competitors.get(9), carryColumn, now), EPSILON);
228		- leaderboard.getScoreCorrection().correctScore(competitors.get(8), f1, 6.0);
229		- leaderboard.getScoreCorrection().correctScore(competitors.get(8), f2, 8.0);
230		- leaderboard.getScoreCorrection().correctScore(competitors.get(9), f1, 7.0);
231		- leaderboard.getScoreCorrection().correctScore(competitors.get(9), f2, 7.0);
	229	+ leaderboard.getScoreCorrection().correctScore(competitors.get(8), f1, 5.0);
	230	+ leaderboard.getScoreCorrection().correctScore(competitors.get(8), f2, 7.0);
	231	+ leaderboard.getScoreCorrection().correctScore(competitors.get(9), f1, 6.0);
	232	+ leaderboard.getScoreCorrection().correctScore(competitors.get(9), f2, 6.0);
	233	+ assertEquals(leaderboard.getNetPoints(competitors.get(8), now), leaderboard.getNetPoints(competitors.get(9), now), EPSILON);
232	234	// construct a tie between C7 and C8 (index 6 and 7, respectively); the tie is based on
233	235	// equal carried points and equal medal series points throughout (both DNF in F1 and F2),
234	236	// but C7 is expected to be ranked better because of the better rank in the opening series,
...	...	@@ -251,7 +253,7 @@ public class LeaderboardScoringAndRankingForLowPointsTest extends LeaderboardSco
251	253	leaderboard.getScoreCorrection().correctScore(competitors.get(2), f2, 1.0);
252	254	leaderboard.getScoreCorrection().correctScore(competitors.get(3), f2, 2.0);
253	255	leaderboard.getScoreCorrection().correctScore(competitors.get(4), f2, 5.0);
254		- leaderboard.getScoreCorrection().correctScore(competitors.get(5), f2, 6.0);
	256	+ leaderboard.getScoreCorrection().correctScore(competitors.get(5), f2, 8.0);
255	257	final Iterable<Competitor> ranking = leaderboard.getCompetitorsFromBestToWorst(now);
256	258	assertTrue(Util.indexOf(ranking, competitors.get(6)) < Util.indexOf(ranking, competitors.get(7)));
257	259	assertTrue(Util.indexOf(ranking, competitors.get(8)) < Util.indexOf(ranking, competitors.get(9)));

...	...	@@ -100,7 +100,6 @@ public interface ScoringScheme extends Serializable {
100	100	* scores of the first competitor, in the order of race columns in the leaderboard
101	101	* @param competitor2Scores
102	102	* scores of the second competitor, in the order of race columns in the leaderboard
103		- * @param raceColumnsToConsider TODO
104	103	* @param discardedRaceColumnsPerCompetitor
105	104	* for each competitor holds the result of {@link Leaderboard#getResultDiscardingRule()
106	105	* Leaderborad.getResultDiscardingRule()}{@code .}{@link ResultDiscardingRule#getDiscardedRaceColumns(Competitor, Leaderboard, Iterable, TimePoint, ScoringScheme)
...	...	@@ -108,8 +107,11 @@ public interface ScoringScheme extends Serializable {
108	107	* for each competitor again.
109	108	*/
110	109	int compareByBetterScore(Competitor o1, List<Util.Pair<RaceColumn, Double>> competitor1Scores, Competitor o2,
111		- List<Util.Pair<RaceColumn, Double>> competitor2Scores, Iterable<RaceColumn> raceColumnsToConsider, boolean nullScoresAreBetter,
112		- TimePoint timePoint, Leaderboard leaderboard, Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor, BiFunction<Competitor, RaceColumn, Double> totalPointsSupplier, WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache);
	110	+ List<Util.Pair<RaceColumn, Double>> competitor2Scores, Iterable<RaceColumn> raceColumnsToConsider,
	111	+ boolean nullScoresAreBetter, TimePoint timePoint, Leaderboard leaderboard,
	112	+ Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor,
	113	+ BiFunction<Competitor, RaceColumn, Double> totalPointsSupplier,
	114	+ WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache);
113	115
114	116	/**
115	117	* In case two competitors scored in different numbers of races, this scoring scheme decides whether this
...	...	@@ -349,16 +351,28 @@ public interface ScoringScheme extends Serializable {
349	351	}
350	352
351	353	/**
352		- * Precondition: either both scored in medal race or both didn't. If both scored, the better score wins.
	354	+ * Precondition: either both scored in medal race or both didn't. If both scored, the better score sum wins. If both
	355	+ * scored the same sum in the medal races, apply
	356	+ * {@link #compareByScoreSum(Competitor, List, double, Competitor, List, double, boolean, boolean, Supplier)} to
	357	+ * apply the same tie breaking to the medal races as for other series.
	358	+ * <p>
	359	+ *
353	360	* This is to be applied only if the net score of both competitors are equal to each other.
354	361	*/
355		- default int compareByMedalRaceScore(Double o1MedalRaceScore, Double o2MedalRaceScore, boolean nullScoresAreBetter) {
	362	+ default int compareByMedalRaceScore(Competitor o1, Competitor o2, Double o1MedalRaceScore, Double o2MedalRaceScore,
	363	+ List<Pair<RaceColumn, Double>> o1ScoringMedalRaces, List<Pair<RaceColumn, Double>> o2ScoringMedalRaces,
	364	+ TimePoint timePoint, Leaderboard leaderboard,
	365	+ Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor,
	366	+ BiFunction<Competitor, RaceColumn, Double> totalPointsSupplier, boolean nullScoresAreBetter,
	367	+ WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache) {
356	368	assert o1MedalRaceScore != null \|\| o2MedalRaceScore == null;
357	369	final int result;
358	370	if (o1MedalRaceScore != null) {
359	371	result = getScoreComparator(nullScoresAreBetter).compare(o1MedalRaceScore, o2MedalRaceScore);
360	372	} else {
361		- result = 0;
	373	+ result = compareByBetterScore(o1, o1ScoringMedalRaces, o2, o2ScoringMedalRaces, Util.map(o1ScoringMedalRaces, Pair::getA),
	374	+ nullScoresAreBetter, timePoint, leaderboard, discardedRaceColumnsPerCompetitor, totalPointsSupplier,
	375	+ cache);
362	376	}
363	377	return result;
364	378	}

...	...	@@ -169,8 +169,10 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
169	169	List<Util.Pair<RaceColumn, Double>> o2TotalPoints = new ArrayList<>();
170	170	double o1ScoreSum = getLeaderboard().getCarriedPoints(o1);
171	171	double o2ScoreSum = getLeaderboard().getCarriedPoints(o2);
172		- Double o1MedalRaceScore = 0.0; // "blindly" adds them all up, regardless of "series starts with zero score"
173		- Double o2MedalRaceScore = 0.0; // "blindly" adds them all up, regardless of "series starts with zero score"
	172	+ final List<Util.Pair<RaceColumn, Double>> o1ScoringMedalRaces = new ArrayList<>();
	173	+ final List<Util.Pair<RaceColumn, Double>> o2ScoringMedalRaces = new ArrayList<>();
	174	+ Double o1MedalRaceScoreSum = 0.0; // "blindly" adds them all up, regardless of "series starts with zero score"
	175	+ Double o2MedalRaceScoreSum = 0.0; // "blindly" adds them all up, regardless of "series starts with zero score"
174	176	Double o1CarryForwardScoreInMedals = null;
175	177	Double o2CarryForwardScoreInMedals = null;
176	178	// When a column has isStartsWithZeroScore, the competitor's score only need to be reset to zero if from there on
...	...	@@ -240,10 +242,12 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
240	242	// only count the score for the medal race score if it wasn't a carry-forward column
241	243	if (!raceColumn.isCarryForward()) {
242	244	if (o1Score != null) {
243		- o1MedalRaceScore += o1Score;
	245	+ o1MedalRaceScoreSum += o1Score;
	246	+ o1ScoringMedalRaces.add(new Pair<>(raceColumn, o1Score));
244	247	}
245	248	if (o2Score != null) {
246		- o2MedalRaceScore += o2Score;
	249	+ o2MedalRaceScoreSum += o2Score;
	250	+ o2ScoringMedalRaces.add(new Pair<>(raceColumn, o2Score));
247	251	}
248	252	} else {
249	253	o1CarryForwardScoreInMedals = o1Score;
...	...	@@ -319,7 +323,12 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
319	323	(competitor, raceColumn)->totalPointsCache.get(new Pair<>(competitor, raceColumn)), cache, timePoint,
320	324	zeroBasedIndexOfLastMedalSeriesInWhichO1Scored, numberOfMedalRacesWonO1, numberOfMedalRacesWonO2);
321	325	if (result == 0) {
322		- result = scoringScheme.compareByMedalRaceScore(o1MedalRaceScore, o2MedalRaceScore, nullScoresAreBetter);
	326	+ result = scoringScheme.compareByMedalRaceScore(o1, o2, o1MedalRaceScoreSum,
	327	+ o2MedalRaceScoreSum, o1ScoringMedalRaces, o2ScoringMedalRaces, timePoint,
	328	+ leaderboard, Collections.unmodifiableMap(discardedRaceColumnsPerCompetitor),
	329	+ (competitor1, raceColumn1) -> totalPointsCache
	330	+ .get(new Pair<>(competitor1, raceColumn1)),
	331	+ nullScoresAreBetter, cache);
323	332	if (result == 0) {
324	333	result = scoringScheme.compareByBetterScore(o1, Collections.unmodifiableList(o1TotalPoints),
325	334	o2, Collections.unmodifiableList(o2TotalPoints),

...	...	@@ -355,7 +355,7 @@ public class LowPointFirstToWinThreeRaces extends LowPoint {
355	355	* {@link #compareByMedalRacesWon(int, int)} instead.
356	356	*/
357	357	@Override
358		- public int compareByMedalRaceScore(Double o1MedalRaceScore, Double o2MedalRaceScore, boolean nullScoresAreBetter) {
	358	+ public int compareByMedalRaceScore(Competitor o1, Competitor o2, Double o1MedalRaceScore, Double o2MedalRaceScore, List<Pair<RaceColumn, Double>> o1ScoringMedalRaces, List<Pair<RaceColumn, Double>> o2ScoringMedalRaces, TimePoint timePoint, Leaderboard leaderboard, Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor, BiFunction<Competitor, RaceColumn, Double> totalPointSupplier, boolean nullScoresAreBetter, WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache) {
359	359	return 0;
360	360	}
361	361

...	...	@@ -126,7 +126,7 @@ public abstract class LowPointWithEliminatingMedalSeriesWithPromotions extends L
126	126	* medal series, or if already at the first medal series, the opening series will be used for tie-breaking.
127	127	*/
128	128	@Override
129		- public int compareByMedalRaceScore(Double o1MedalRaceScore, Double o2MedalRaceScore, boolean nullScoresAreBetter) {
	129	+ public int compareByMedalRaceScore(Competitor o1, Competitor o2, Double o1MedalRaceScore, Double o2MedalRaceScore, List<Pair<RaceColumn, Double>> o1ScoringMedalRaces, List<Pair<RaceColumn, Double>> o2ScoringMedalRaces, TimePoint timePoint, Leaderboard leaderboard, Map<Competitor, Set<RaceColumn>> discardedRaceColumnsPerCompetitor, BiFunction<Competitor, RaceColumn, Double> totalPointSupplier, boolean nullScoresAreBetter, WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache) {
130	130	return 0;
131	131	}
132	132

...	...	@@ -1,5 +1,6 @@
1	1	package com.sap.sse.test;
2	2
	3	+import static org.junit.jupiter.api.Assertions.assertEquals;
3	4	import static org.junit.jupiter.api.Assertions.assertFalse;
4	5	import static org.junit.jupiter.api.Assertions.assertTrue;
5	6
...	...	@@ -13,6 +14,8 @@ import org.junit.jupiter.api.BeforeAll;
13	14	import org.junit.jupiter.api.Disabled;
14	15	import org.junit.jupiter.api.Test;
15	16
	17	+import com.sap.sse.metering.CPUMeter;
	18	+
16	19	public class CPUTimeMeasurementTest {
17	20	private static final Logger logger = Logger.getLogger(CPUTimeMeasurementTest.class.getName());
18	21
...	...	@@ -38,6 +41,12 @@ public class CPUTimeMeasurementTest {
38	41	+" ("+((double) durationWithCpuTimeEnabled / (double) durationWithCpuTimeDisabled)+")");
39	42	assertFalse((double) durationWithCpuTimeEnabled > 1.5*durationWithCpuTimeDisabled);
40	43	}
	44	+
	45	+ @Test
	46	+ public void testCallableResultProperlyReturned() {
	47	+ final int result = CPUMeter.create().callWithCPUMeter(() -> { return 2; });
	48	+ assertEquals(2, result);
	49	+ }
41	50
42	51	@Test
43	52	public void testSingleThreadedWorkloadOffByLessThanFactorTwo() {