Merge remote-tracking branch 'github/bug6219'

+ <stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit5"/>

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

+ public void testA8TieBreakForMulitpleMedalRacesWithCarryColumn() {

+ final TimePoint now = TimePoint.now();

+ series = new ArrayList<>();

+ final List<Fleet> fleets = new ArrayList<>();

+ final Fleet defaultFleet = new FleetImpl("Default");

+ fleets.add(defaultFleet);

+ final List<String> raceColumnNames = Arrays.asList("R1", "R2", "R3", "R4", "R5");

+ Series openingSeries = new SeriesImpl("Opening", /* isMedal */ false,

+ /* isFleetsCanRunInParallel */ true, fleets, raceColumnNames,

+ /* trackedRegattaRegistry */ null);

+ series.add(openingSeries);

+ final List<Fleet> medalFleet = new ArrayList<>();

+ final Fleet medalDefaultFleet = new FleetImpl("Default");

+ medalFleet.add(medalDefaultFleet);

+ final List<String> medalRaceColumnNames = Arrays.asList("Carry", "F1", "F2");

+ final Series medalSeries = new SeriesImpl("Medal", /* isMedal */ true, /* isFleetsCanRunInParallel */ true,

+ medalFleet, medalRaceColumnNames, /* trackedRegattaRegistry */ null);

+ medalSeries.setFirstColumnIsNonDiscardableCarryForward(true);

+ medalSeries.setStartsWithZeroScore(true);

+ series.add(medalSeries);

+ final Regatta regatta = setupRegatta(/* use first two wins */ false); // regular LowPoint

+ final List<Competitor> competitors = createCompetitors(20);

+ for (final RaceColumn openingSeriesRaceColumn : openingSeries.getRaceColumns()) {

+ openingSeriesRaceColumn.setTrackedRace(defaultFleet, new MockedTrackedRaceWithStartTimeAndRanks(now, competitors));

+ }

+ final Leaderboard leaderboard = createLeaderboard(regatta, /* discarding thresholds */ new int[0]);

+ final RaceColumn carryColumn = leaderboard.getRaceColumnByName("Carry");

+ final Competitor thirdAfterOpeningSeries = Util.get(leaderboard.getCompetitorsFromBestToWorst(now), 2);

+ final double scoreOfThirdAfterOpeningSeries = leaderboard.getNetPoints(thirdAfterOpeningSeries, now);

+ for (int medalRaceCompetitorIndex=0; medalRaceCompetitorIndex<10; medalRaceCompetitorIndex++) {

+ final double regularScore = leaderboard.getNetPoints(competitors.get(medalRaceCompetitorIndex), now);

+ leaderboard.getScoreCorrection().correctScore(competitors.get(medalRaceCompetitorIndex), carryColumn, Math.min(regularScore, scoreOfThirdAfterOpeningSeries+18));

+ }

+ final RaceColumn f1 = leaderboard.getRaceColumnByName("F1");

+ final RaceColumn f2 = leaderboard.getRaceColumnByName("F2");

+ carryColumn.setFactor(1.0);

+ f1.setFactor(1.0);

+ f2.setFactor(1.0);

+ // construct a tie between C1 and C2 (index 0 and 1, respectively); the tie is expected to be broken

+ // 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, 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: 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, 7.0);

+ leaderboard.getScoreCorrection().correctScore(competitors.get(8), f2, 5.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,

+ // only it got "squashed" to the same reduced points as those of C8, but the tie break would

+ // have to go by opening series rank as a last resort:

+ assertEquals(leaderboard.getNetPoints(competitors.get(6), carryColumn, now), leaderboard.getNetPoints(competitors.get(7), carryColumn, now), EPSILON);

+ leaderboard.getScoreCorrection().correctScore(competitors.get(6), f1, 11.0);

+ leaderboard.getScoreCorrection().setMaxPointsReason(competitors.get(6), f1, MaxPointsReason.DNF);

+ leaderboard.getScoreCorrection().correctScore(competitors.get(6), f2, 11.0);

+ leaderboard.getScoreCorrection().setMaxPointsReason(competitors.get(6), f2, MaxPointsReason.DNF);

+ leaderboard.getScoreCorrection().correctScore(competitors.get(7), f1, 11.0);

+ leaderboard.getScoreCorrection().setMaxPointsReason(competitors.get(7), f1, MaxPointsReason.DNF);

+ leaderboard.getScoreCorrection().correctScore(competitors.get(7), f2, 11.0);

+ leaderboard.getScoreCorrection().setMaxPointsReason(competitors.get(7), f2, MaxPointsReason.DNF);

+ // construct scores for the remaining competitors C3..C6

+ leaderboard.getScoreCorrection().correctScore(competitors.get(2), f1, 2.0);

+ leaderboard.getScoreCorrection().correctScore(competitors.get(3), f1, 3.0);

+ leaderboard.getScoreCorrection().correctScore(competitors.get(4), f1, 4.0);

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

+ 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, 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)));

+ assertTrue(Util.indexOf(ranking, competitors.get(1)) < Util.indexOf(ranking, competitors.get(0)));

+ }

+

+ @Test

+ 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);

+ * 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>

+ *

+ 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) {

+ int result;

+ if (result == 0 && o1ScoringMedalRaces.size() > 1) { // only work calling if more than one scoring medal race

+ result = compareByBetterScore(o1, o1ScoringMedalRaces, o2, o2ScoringMedalRaces,

+ Util.map(o1ScoringMedalRaces, Pair::getA), nullScoresAreBetter, timePoint, leaderboard,

+ discardedRaceColumnsPerCompetitor, totalPointsSupplier, cache);

+ }

+ Iterable<RaceColumn> raceColumnsToConsider, BiFunction<Competitor, RaceColumn, Double> totalPointsSupplier,

+ WindLegTypeAndLegBearingAndORCPerformanceCurveCache cache, TimePoint timePoint, int zeroBasedIndexOfLastMedalSeriesInWhichBothScored,

+ int numberOfMedalRacesWonO1, int numberOfMedalRacesWonO2) {

+ 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"

+ o1MedalRaceScoreSum += o1Score;

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

+ o2MedalRaceScoreSum += o2Score;

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

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

+ zeroBasedIndexOfLastMedalSeriesInWhichO1Scored, numberOfMedalRacesWonO1, numberOfMedalRacesWonO2);

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

+ o2MedalRaceScoreSum, o1ScoringMedalRaces, o2ScoringMedalRaces, timePoint,

+ leaderboard, Collections.unmodifiableMap(discardedRaceColumnsPerCompetitor),

+ (competitor1, raceColumn1) -> totalPointsCache

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

+ nullScoresAreBetter, cache);

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

+ cache);

+ 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) {

+ 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) {

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

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

+

+

+ @Test

+ public void testCallableResultProperlyReturned() {

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

+ assertEquals(2, result);

+ }