bug4661 formating/code style only change

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/LeaderboardScoringAndRankingTestForLowPoints.java

@@ -60,8 +60,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         final BoatClass boatClass = DomainFactory.INSTANCE.getOrCreateBoatClass("470",
                 /* typicallyStartsUpwind */ true);
         Regatta regatta = new RegattaImpl(RegattaImpl.getDefaultName("Test Regatta", boatClass.getName()), boatClass,
-                false, /* startDate */ null, /* endDate */ null, series,
-                /* persistent */false,
+                false, /* startDate */ null, /* endDate */ null, series, /* persistent */false,
                 DomainFactory.INSTANCE
                         .createScoringScheme(useFirstTwoWins ? ScoringSchemeType.LOW_POINT_FIRST_TO_WIN_TWO_RACES
                                 : ScoringSchemeType.LOW_POINT),
@@ -96,7 +95,6 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
                 /* trackedRegattaRegistry */ null);
         series.add(qualificationSeries);
     }
-    
 
     private List<Pair<Competitor, Double>> createCompetitorResultForTimestamp(TimePoint time, Leaderboard leaderboard) {
         List<Pair<Competitor, Double>> list = new ArrayList<>();
@@ -105,11 +103,11 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         }
         return list;
     }
-    
 
     private void assertNonFinalistsAreBehindFinalistsAndNotChanged(
             List<Pair<Competitor, Double>> preSeriesScoreRankResult, List<Pair<Competitor, Double>> afterFinalResults) {
-        List<Pair<Competitor, Double>> nonFinalistsPreScore = preSeriesScoreRankResult.subList(4, preSeriesScoreRankResult.size());
+        List<Pair<Competitor, Double>> nonFinalistsPreScore = preSeriesScoreRankResult.subList(4,
+                preSeriesScoreRankResult.size());
         List<Pair<Competitor, Double>> nonFinalistsAfterScore = afterFinalResults.subList(4, afterFinalResults.size());
         Assert.assertEquals(nonFinalistsPreScore, nonFinalistsAfterScore);
     }
@@ -135,7 +133,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
 
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
@@ -159,7 +158,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(2.0001, leaderboard.getNetPoints(medalCompetitorsBestToWorst.get(1), later), EPSILON);
         Assert.assertEquals(3.0002, leaderboard.getNetPoints(medalCompetitorsBestToWorst.get(2), later), EPSILON);
         Assert.assertEquals(4.0003, leaderboard.getNetPoints(medalCompetitorsBestToWorst.get(3), later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
@@ -185,7 +184,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
         Competitor preFirst = medalCompetitorsBestToWorst.get(0);
@@ -229,7 +229,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(4.0, leaderboard.getNetPoints(preFirst, m2later), EPSILON);
         Assert.assertEquals(6.0002, leaderboard.getNetPoints(preThird, m2later), EPSILON);
         Assert.assertEquals(8.0003, leaderboard.getNetPoints(preFourth, m2later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(m2later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
@@ -255,7 +255,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
         Competitor preFirst = medalCompetitorsBestToWorst.get(0);
@@ -299,7 +300,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(3.0001, leaderboard.getNetPoints(preSecond, m2later), EPSILON);
         Assert.assertEquals(6.0002, leaderboard.getNetPoints(preThird, m2later), EPSILON);
         Assert.assertEquals(8.0003, leaderboard.getNetPoints(preFourth, m2later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(m2later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
@@ -325,7 +326,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
         Competitor preFirst = medalCompetitorsBestToWorst.get(0);
@@ -369,7 +371,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(4.0, leaderboard.getNetPoints(preFirst, m2later), EPSILON);
         Assert.assertEquals(6.0001, leaderboard.getNetPoints(preSecond, m2later), EPSILON);
         Assert.assertEquals(8.0002, leaderboard.getNetPoints(preThird, m2later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(m2later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
@@ -395,7 +397,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
         Competitor preFirst = medalCompetitorsBestToWorst.get(0);
@@ -439,12 +442,11 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(4.0, leaderboard.getNetPoints(preFirst, m2later), EPSILON);
         Assert.assertEquals(6.0001, leaderboard.getNetPoints(preSecond, m2later), EPSILON);
         Assert.assertEquals(5.0002, leaderboard.getNetPoints(preThird, m2later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(m2later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
-    
-    
+
     @Test
     public void negativeTestFirstPreseriesWinsAgain() throws NoWindException {
         series = new ArrayList<Series>();
@@ -465,7 +467,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         executeRandomPreSeries(yellow, blue, now);
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
         List<Competitor> medalCompetitors = preSeriesRankResult.subList(0, 4);
 
         manuallyTransferCarry(leaderboard, medalCompetitors);
@@ -490,7 +493,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(4.0002, leaderboard.getNetPoints(medalCompetitors.get(1), later), EPSILON);
         Assert.assertEquals(6.0004, leaderboard.getNetPoints(medalCompetitors.get(2), later), EPSILON);
         Assert.assertEquals(8.0006, leaderboard.getNetPoints(medalCompetitors.get(3), later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
@@ -516,7 +519,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
         Competitor preFirst = medalCompetitorsBestToWorst.get(0);
@@ -560,7 +564,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(8.0, leaderboard.getNetPoints(preFirst, m2later), EPSILON);
         Assert.assertEquals(12.0004, leaderboard.getNetPoints(preThird, m2later), EPSILON);
         Assert.assertEquals(16.0006, leaderboard.getNetPoints(preFourth, m2later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(m2later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
@@ -586,7 +590,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
         Competitor preFirst = medalCompetitorsBestToWorst.get(0);
@@ -630,7 +635,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(6.0002, leaderboard.getNetPoints(preSecond, m2later), EPSILON);
         Assert.assertEquals(12.0004, leaderboard.getNetPoints(preThird, m2later), EPSILON);
         Assert.assertEquals(16.0006, leaderboard.getNetPoints(preFourth, m2later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(m2later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
@@ -656,8 +661,9 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
-        
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
+
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
         Competitor preFirst = medalCompetitorsBestToWorst.get(0);
@@ -701,7 +707,7 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(8.0, leaderboard.getNetPoints(preFirst, m2later), EPSILON);
         Assert.assertEquals(12.0002, leaderboard.getNetPoints(preSecond, m2later), EPSILON);
         Assert.assertEquals(16.0004, leaderboard.getNetPoints(preThird, m2later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(m2later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
@@ -727,7 +733,8 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
 
         List<Competitor> preSeriesRankResult = leaderboard.getCompetitorsFromBestToWorst(later);
         List<Competitor> medalCompetitorsBestToWorst = preSeriesRankResult.subList(0, 4);
-        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later, leaderboard);
+        List<Pair<Competitor, Double>> preSeriesScoreRankResult = createCompetitorResultForTimestamp(later,
+                leaderboard);
         manuallyTransferCarry(leaderboard, medalCompetitorsBestToWorst);
 
         Competitor preFirst = medalCompetitorsBestToWorst.get(0);
@@ -771,9 +778,9 @@ public class LeaderboardScoringAndRankingTestForLowPoints extends LeaderboardSco
         Assert.assertEquals(8.0, leaderboard.getNetPoints(preFirst, m2later), EPSILON);
         Assert.assertEquals(12.0002, leaderboard.getNetPoints(preSecond, m2later), EPSILON);
         Assert.assertEquals(10.0004, leaderboard.getNetPoints(preThird, m2later), EPSILON);
-        
+
         List<Pair<Competitor, Double>> afterFinalResults = createCompetitorResultForTimestamp(m2later, leaderboard);
         assertNonFinalistsAreBehindFinalistsAndNotChanged(preSeriesScoreRankResult, afterFinalResults);
     }
-    
+
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/ScoringScheme.java

@@ -138,16 +138,16 @@ public interface ScoringScheme extends Serializable {
     default boolean doesCountAsWinInMedalRace(Double o1Score, RaceColumn raceColumn) {
         throw new IllegalStateException("This call is not valid for this scoringSheme");
     }
-    
+
     /**
-     * Usually, the scores in each leaderboard column count as they are for the overall score. However, if a column is
-     * a medal race column it usually counts double. Under certain circumstances, columns may also count with factors different
-     * from 1 or 2. For example, we've seen cases in the Extreme Sailing Series where the race committee defined that in the
-     * overall series leaderboard the last two columns each count 1.5 times their scores.
+     * Usually, the scores in each leaderboard column count as they are for the overall score. However, if a column is a
+     * medal race column it usually counts double. Under certain circumstances, columns may also count with factors
+     * different from 1 or 2. For example, we've seen cases in the Extreme Sailing Series where the race committee
+     * defined that in the overall series leaderboard the last two columns each count 1.5 times their scores.
      */
     default double getScoreFactor(RaceColumn a) {
         Double factor = a.getExplicitFactor();
-        if(factor == null) {
+        if (factor == null) {
             factor = a.isMedalRace() ? DEFAULT_MEDAL_RACE_FACTOR : 1.0;
         }
         return factor;

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/AbstractScoringSchemeImpl.java

@@ -129,11 +129,11 @@ public abstract class AbstractScoringSchemeImpl implements ScoringScheme {
         // needs to compare net points; therefore, divide the total points by the column factor for comparison:
         List<Double> o1NetScores = new ArrayList<>();
         for (com.sap.sse.common.Util.Pair<RaceColumn, Double> o1ColumnAndScore : o1Scores) {
-            o1NetScores.add(o1ColumnAndScore.getB()/getScoreFactor(o1ColumnAndScore.getA()));
+            o1NetScores.add(o1ColumnAndScore.getB() / getScoreFactor(o1ColumnAndScore.getA()));
         }
         List<Double> o2NetScores = new ArrayList<>();
         for (com.sap.sse.common.Util.Pair<RaceColumn, Double> o2ColumnAndScore : o2Scores) {
-            o2NetScores.add(o2ColumnAndScore.getB()/getScoreFactor(o2ColumnAndScore.getA()));
+            o2NetScores.add(o2ColumnAndScore.getB() / getScoreFactor(o2ColumnAndScore.getA()));
         }
         Collections.sort(o1NetScores, pureScoreComparator);
         Collections.sort(o2NetScores, pureScoreComparator);

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/LeaderboardTotalRankComparator.java

@@ -211,8 +211,7 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
         // break tie by sorting scores and looking for the first score difference.
         int result = compareByNumberOfRacesScored(o1Scores.size(), o2Scores.size());
         if (result == 0) {
-            if(scoringScheme.isMedalWinAmountCriteria()) {
-                //FIXME somehere carry values must be obtained and added here, if compeitor was in carry
+            if (scoringScheme.isMedalWinAmountCriteria()) {
                 result = compareByMedalRacesWon(numberOfMedalRacesWonO1, numberOfMedalRacesWonO2);
             }
             if (result == 0) {
@@ -220,12 +219,15 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
                 if (result == 0) {
                     result = compareByMedalRaceScore(o1MedalRaceScore, o2MedalRaceScore);
                     if (result == 0) {
-                        result = compareByBetterScore(o1, Collections.unmodifiableList(o1Scores), o2, Collections.unmodifiableList(o2Scores), timePoint);
+                        result = compareByBetterScore(o1, Collections.unmodifiableList(o1Scores), o2,
+                                Collections.unmodifiableList(o2Scores), timePoint);
                         if (result == 0) {
                             // compare by last race:
-                            result = scoringScheme.compareByLastRace(o1TotalPoints, o2TotalPoints, nullScoresAreBetter, o1, o2);
+                            result = scoringScheme.compareByLastRace(o1TotalPoints, o2TotalPoints, nullScoresAreBetter,
+                                    o1, o2);
                             if (result == 0) {
-                                result = scoringScheme.compareByLatestRegattaInMetaLeaderboard(getLeaderboard(), o1, o2, timePoint);
+                                result = scoringScheme.compareByLatestRegattaInMetaLeaderboard(getLeaderboard(), o1, o2,
+                                        timePoint);
                                 if (result == 0) {
                                     result = compareByArbitraryButStableCriteria(o1, o2);
                                 }
@@ -233,21 +235,22 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
                         }
                     }
                 }
-            }else {
+            } else {
                 System.out.println("chjeck me");
             }
-           
+
         }
         return result;
     }
 
     private int compareByMedalRacesWon(int numberOfMedalRacesWonO1, int numberOfMedalRacesWonO2) {
         int targetAmount = scoringScheme.getTargetAmountOfMedalRaceWins();
-        //if one reaches the targetamount, this has precendece, else proceed with normal low points scoring (eg not enough races yet)
-        if(numberOfMedalRacesWonO1 == targetAmount) {
+        // if one reaches the targetamount, this has priority, else proceed with normal low points scoring (eg. not
+        // enough races yet)
+        if (numberOfMedalRacesWonO1 == targetAmount) {
             return -1;
         }
-        if(numberOfMedalRacesWonO2 == targetAmount) {
+        if (numberOfMedalRacesWonO2 == targetAmount) {
             return 1;
         }
         return 0;

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java

@@ -2602,7 +2602,8 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
                     }
                 }    
                 final FleetDTO fleetDTO = baseDomainFactory.convertToFleetDTO(fleet);
-                RaceColumnDTO raceColumnDTO = leaderboardDTO.addRace(raceColumn.getName(), raceColumn.getExplicitFactor(), leaderboard.getScoringScheme().getScoreFactor(raceColumn),
+                RaceColumnDTO raceColumnDTO = leaderboardDTO.addRace(raceColumn.getName(),
+                        raceColumn.getExplicitFactor(), leaderboard.getScoringScheme().getScoreFactor(raceColumn),
                         raceColumn instanceof RaceColumnInSeries ? ((RaceColumnInSeries) raceColumn).getRegatta().getName() : null,
                         raceColumn instanceof RaceColumnInSeries ? ((RaceColumnInSeries) raceColumn).getSeries().getName() : null,
                         fleetDTO, raceColumn.isMedalRace(), raceIdentifier, raceDTO, raceColumn instanceof MetaLeaderboardColumn);

java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/impl/rc/RaceGroupFactory.java

@@ -75,8 +75,9 @@ public class RaceGroupFactory {
         Map<Series, List<RaceColumn>> seriesToRaceColumns = getSeriesToRaceColumns(leaderboard);
         Collection<SeriesWithRows> seriesWithRows = new ArrayList<>();
         for (Series series : getSeriesIterable(leaderboard, seriesToRaceColumns)) {
-            seriesWithRows.add(new SeriesWithRowsImpl(series.getName(), series.isMedal(), series.isFleetsCanRunInParallel(), getRows(series,
-                    seriesToRaceColumns.get(series), leaderboard.getScoringScheme())));
+            seriesWithRows
+                    .add(new SeriesWithRowsImpl(series.getName(), series.isMedal(), series.isFleetsCanRunInParallel(),
+                            getRows(series, seriesToRaceColumns.get(series), leaderboard.getScoringScheme())));
         }
         return seriesWithRows;
     }
@@ -90,15 +91,17 @@ public class RaceGroupFactory {
     }
 
     /**
-     * @param raceColumns must be provided in the same order in which they appear in the series / leaderboard
-     * @param scoringScheme 
+     * @param raceColumns
+     *            must be provided in the same order in which they appear in the series / leaderboard
+     * @param scoringScheme
      */
     private Collection<RaceRow> getRows(Series series, List<RaceColumn> raceColumns, ScoringScheme scoringScheme) {
         Collection<RaceRow> rows = new ArrayList<>();
         for (Fleet fleet : series.getFleets()) {
             // We are taking the fleet name because there might be several "default fleet"
             // objects when TrackedRaces are linked onto this Leaderboard
-                rows.add(new RaceRowImpl(fleet, getCells(fleet.getName(), raceColumns, isFirstRaceColumnVirtual(series), scoringScheme)));
+            rows.add(new RaceRowImpl(fleet,
+                    getCells(fleet.getName(), raceColumns, isFirstRaceColumnVirtual(series), scoringScheme)));
         }
         return rows;
     }
@@ -133,7 +136,8 @@ public class RaceGroupFactory {
                         targetTime = null;
                     }
                     cells.add(new RaceCellImpl(raceColumn.getName(), raceColumn.getRaceLog(fleet),
-                            scoringScheme.getScoreFactor(raceColumn), raceColumn.getExplicitFactor(), zeroBasedIndexOfRaceInFleet++, targetTime));
+                            scoringScheme.getScoreFactor(raceColumn), raceColumn.getExplicitFactor(),
+                            zeroBasedIndexOfRaceInFleet++, targetTime));
                 }
             }
         }

java/com.sap.sailing.server.test/src/com/sap/sailing/server/test/MasterDataImportTest.java

@@ -423,10 +423,8 @@ public class MasterDataImportTest {
                 scoreCorrection,
                 leaderboardOnTarget.getScoreCorrection().getExplicitScoreCorrection(competitorOnTarget,
                         raceColumnOnTarget));
-        Assert.assertEquals(
-                maxPointsReason,
-                leaderboardOnTarget.getScoreCorrection().getMaxPointsReason(competitorOnTarget, raceColumnOnTarget,
-                        MillisecondsTimePoint.now()));
+        Assert.assertEquals(maxPointsReason, leaderboardOnTarget.getScoreCorrection()
+                .getMaxPointsReason(competitorOnTarget, raceColumnOnTarget, MillisecondsTimePoint.now()));
 
         // Check for carried points
         Assert.assertEquals(carriedPoints, leaderboardOnTarget.getCarriedPoints(competitorOnTarget));
@@ -2296,10 +2294,8 @@ public class MasterDataImportTest {
                 scoreCorrection,
                 leaderboardOnTarget.getScoreCorrection().getExplicitScoreCorrection(competitorOnTarget,
                         raceColumnOnTarget));
-        Assert.assertEquals(
-                maxPointsReason,
-                leaderboardOnTarget.getScoreCorrection().getMaxPointsReason(competitorOnTarget, raceColumnOnTarget,
-                        MillisecondsTimePoint.now()));
+        Assert.assertEquals(maxPointsReason, leaderboardOnTarget.getScoreCorrection()
+                .getMaxPointsReason(competitorOnTarget, raceColumnOnTarget, MillisecondsTimePoint.now()));
 
         // Check for carried points
         Assert.assertEquals(carriedPoints, leaderboardOnTarget.getCarriedPoints(competitorOnTarget));