PLANNER-401: Renamed methods in BenchmarkResult

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/PlannerBenchmarkRunner.java

@@ -265,7 +265,7 @@ protected void runSingleBenchmarks() {
                 // Explicitly returning it in the Callable guarantees memory visibility
                 subSingleBenchmarkRunner = future.get();
                 // TODO WORKAROUND Remove when PLANNER-46 is fixed.
-                if (subSingleBenchmarkRunner.getSubSingleBenchmarkResult().getScore() == null) {
+                if (subSingleBenchmarkRunner.getSubSingleBenchmarkResult().getAverageScore() == null) {
                     throw new IllegalStateException("Score is null. TODO fix PLANNER-46.");
                 }
             } catch (InterruptedException e) {

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/SubSingleBenchmarkRunner.java

@@ -74,7 +74,7 @@ public SubSingleBenchmarkRunner call() {
 
         // Intentionally create a fresh solver for every SingleBenchmarkResult to reset Random, tabu lists, ...
         // TODO PLANNER-440 Use a classLoader argument buildSolver()
-        Solver solver = subSingleBenchmarkResult.getSolverBenchmarkResult().getSolverConfig().buildSolver();
+        Solver solver = subSingleBenchmarkResult.getSingleBenchmarkResult().getSolverBenchmarkResult().getSolverConfig().buildSolver();
 
         for (SubSingleStatistic subSingleStatistic : subSingleBenchmarkResult.getEffectiveSubSingleStatisticMap().values()) {
             subSingleStatistic.open(solver);

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/ranking/SingleBenchmarkRankingComparator.java

@@ -30,7 +30,7 @@ public class SingleBenchmarkRankingComparator implements Comparator<SingleBenchm
     @Override
     public int compare(SingleBenchmarkResult a, SingleBenchmarkResult b) {
         return new CompareToBuilder()
-                .append(b.isFailure(), a.isFailure()) // Reverse, less is better (redundant: failed benchmarks don't get ranked at all)
+                .append(b.hasAnyFailure(), a.hasAnyFailure()) // Reverse, less is better (redundant: failed benchmarks don't get ranked at all)
                 .append(b.getAverageUninitializedVariableCount(), a.getAverageUninitializedVariableCount()) // Reverse, less is better
                 .append(a.getAverageScore(), b.getAverageScore(), resilientScoreComparator)
                 .toComparison();

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/ranking/SubSingleBenchmarkRankingComparator.java

@@ -20,7 +20,6 @@
 import java.util.Comparator;
 
 import org.apache.commons.lang3.builder.CompareToBuilder;
-import org.optaplanner.benchmark.impl.result.SingleBenchmarkResult;
 import org.optaplanner.benchmark.impl.result.SubSingleBenchmarkResult;
 import org.optaplanner.core.api.score.Score;
 
@@ -31,9 +30,9 @@ public class SubSingleBenchmarkRankingComparator implements Comparator<SubSingle
     @Override
     public int compare(SubSingleBenchmarkResult a, SubSingleBenchmarkResult b) {
         return new CompareToBuilder()
-                .append(b.isFailure(), a.isFailure()) // Reverse, less is better (redundant: failed benchmarks don't get ranked at all)
+                .append(b.hasAnyFailure(), a.hasAnyFailure()) // Reverse, less is better (redundant: failed benchmarks don't get ranked at all)
                 .append(b.getUninitializedVariableCount(), a.getUninitializedVariableCount()) // Reverse, less is better
-                .append(a.getScore(), b.getScore(), resilientScoreComparator)
+                .append(a.getAverageScore(), b.getAverageScore(), resilientScoreComparator)
                 .toComparison();
     }
 

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/report/BenchmarkReport.java

@@ -266,7 +266,7 @@ public void writeReport() {
                     problemStatistic.writeGraphFiles(this);
                 }
                 for (SingleBenchmarkResult singleBenchmarkResult : problemBenchmarkResult.getSingleBenchmarkResultList()) {
-                    if (singleBenchmarkResult.isSuccess()) {
+                    if (singleBenchmarkResult.hasAnySuccess()) {
                         for (PureSubSingleStatistic pureSubSingleStatistic : singleBenchmarkResult.getMedian().getPureSubSingleStatisticList()) {
                             pureSubSingleStatistic.writeGraphFiles(this);
                         }
@@ -314,7 +314,7 @@ private void writeBestScoreSummaryCharts() {
             String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
             for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
                 String planningProblemLabel = singleBenchmarkResult.getProblemBenchmarkResult().getName();
-                if (singleBenchmarkResult.isSuccess()) {
+                if (singleBenchmarkResult.hasAnySuccess()) {
                     double[] levelValues = ScoreUtils.extractLevelDoubles(singleBenchmarkResult.getAverageScore());
                     for (int i = 0; i < levelValues.length && i < CHARTED_SCORE_LEVEL_SIZE; i++) {
                         if (i >= datasetList.size()) {
@@ -345,7 +345,7 @@ private void writeBestScoreScalabilitySummaryChart() {
         for (SolverBenchmarkResult solverBenchmarkResult : plannerBenchmarkResult.getSolverBenchmarkResultList()) {
             String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
             for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
-                if (singleBenchmarkResult.isSuccess()) {
+                if (singleBenchmarkResult.hasAnySuccess()) {
                     long problemScale = singleBenchmarkResult.getProblemBenchmarkResult().getProblemScale();
                     double[] levelValues = ScoreUtils.extractLevelDoubles(singleBenchmarkResult.getAverageScore());
                     for (int i = 0; i < levelValues.length && i < CHARTED_SCORE_LEVEL_SIZE; i++) {
@@ -385,7 +385,7 @@ private void writeWinningScoreDifferenceSummaryChart() {
             String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
             for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
                 String planningProblemLabel = singleBenchmarkResult.getProblemBenchmarkResult().getName();
-                if (singleBenchmarkResult.isSuccess()) {
+                if (singleBenchmarkResult.hasAnySuccess()) {
                     double[] levelValues = ScoreUtils.extractLevelDoubles(singleBenchmarkResult.getWinningScoreDifference());
                     for (int i = 0; i < levelValues.length && i < CHARTED_SCORE_LEVEL_SIZE; i++) {
                         if (i >= datasetList.size()) {
@@ -417,7 +417,7 @@ private void writeWorstScoreDifferencePercentageSummaryChart() {
             String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
             for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
                 String planningProblemLabel = singleBenchmarkResult.getProblemBenchmarkResult().getName();
-                if (singleBenchmarkResult.isSuccess()) {
+                if (singleBenchmarkResult.hasAnySuccess()) {
                     double[] levelValues = singleBenchmarkResult.getWorstScoreDifferencePercentage().getPercentageLevels();
                     for (int i = 0; i < levelValues.length && i < CHARTED_SCORE_LEVEL_SIZE; i++) {
                         if (i >= datasetList.size()) {
@@ -449,7 +449,7 @@ private void writeAverageCalculateCountPerSecondSummaryChart() {
             String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
             XYSeries series = new XYSeries(solverLabel);
             for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
-                if (singleBenchmarkResult.isSuccess()) {
+                if (singleBenchmarkResult.hasAnySuccess()) {
                     long problemScale = singleBenchmarkResult.getProblemBenchmarkResult().getProblemScale();
                     long averageCalculateCountPerSecond = singleBenchmarkResult.getAverageCalculateCountPerSecond();
                     series.add((Long) problemScale, (Long) averageCalculateCountPerSecond);
@@ -471,7 +471,7 @@ private void writeTimeSpentSummaryChart() {
             String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
             for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
                 String planningProblemLabel = singleBenchmarkResult.getProblemBenchmarkResult().getName();
-                if (singleBenchmarkResult.isSuccess()) {
+                if (singleBenchmarkResult.hasAnySuccess()) {
                     long timeMillisSpent = singleBenchmarkResult.getTimeMillisSpent();
                     dataset.addValue(timeMillisSpent, solverLabel, planningProblemLabel);
                 }
@@ -489,7 +489,7 @@ private void writeTimeSpentScalabilitySummaryChart() {
             String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
             XYSeries series = new XYSeries(solverLabel);
             for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
-                if (singleBenchmarkResult.isSuccess()) {
+                if (singleBenchmarkResult.hasAnySuccess()) {
                     long problemScale = singleBenchmarkResult.getProblemBenchmarkResult().getProblemScale();
                     long timeMillisSpent = singleBenchmarkResult.getTimeMillisSpent();
                     series.add((Long) problemScale, (Long) timeMillisSpent);
@@ -513,7 +513,7 @@ private void writeBestScorePerTimeSpentSummaryChart() {
         for (SolverBenchmarkResult solverBenchmarkResult : plannerBenchmarkResult.getSolverBenchmarkResultList()) {
             String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
             for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
-                if (singleBenchmarkResult.isSuccess()) {
+                if (singleBenchmarkResult.hasAnySuccess()) {
                     long timeMillisSpent = singleBenchmarkResult.getTimeMillisSpent();
                     double[] levelValues = ScoreUtils.extractLevelDoubles(singleBenchmarkResult.getAverageScore());
                     for (int i = 0; i < levelValues.length && i < CHARTED_SCORE_LEVEL_SIZE; i++) {
@@ -583,8 +583,8 @@ private List<? extends BoxAndWhiskerCategoryDataset> generateSubSingleBenchmarkS
         for (SingleBenchmarkResult singleBenchmarkResult : problemBenchmarkResult.getSingleBenchmarkResultList()) {
             List<List<Double>> valueListList = new ArrayList<List<Double>>(CHARTED_SCORE_LEVEL_SIZE);
             for (SubSingleBenchmarkResult subSingleBenchmarkResult : singleBenchmarkResult.getSubSingleBenchmarkResultList()) {
-                if (subSingleBenchmarkResult.isSuccess() && subSingleBenchmarkResult.isInitialized()) {
-                    double[] levelValues = ScoreUtils.extractLevelDoubles(subSingleBenchmarkResult.getScore());
+                if (subSingleBenchmarkResult.hasAnySuccess() && subSingleBenchmarkResult.isInitialized()) {
+                    double[] levelValues = ScoreUtils.extractLevelDoubles(subSingleBenchmarkResult.getAverageScore());
                     for (int i = 0; i < levelValues.length && i < CHARTED_SCORE_LEVEL_SIZE; i++) {
                         if (i >= valueListList.size()) {
                             valueListList.add(new ArrayList<Double>(singleBenchmarkResult.getSuccessCount()));
@@ -715,7 +715,7 @@ private void determineDefaultShownScoreLevelIndex() {
                     differenceCount[i] = 0;
                 }
                 for (SingleBenchmarkResult singleBenchmarkResult : problemBenchmarkResult.getSingleBenchmarkResultList()) {
-                    if (singleBenchmarkResult.isSuccess()) {
+                    if (singleBenchmarkResult.hasAnySuccess()) {
                         double[] scoreLevels = ScoreUtils.extractLevelDoubles(singleBenchmarkResult.getAverageScore());
                         for (int i = 0; i < scoreLevels.length; i++) {
                             if (scoreLevels[i] != winningScoreLevels[i]) {

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/result/BenchmarkResult.java

@@ -23,20 +23,18 @@
 
 public interface BenchmarkResult {
 
-    public SolverBenchmarkResult getSolverBenchmarkResult();
+    public String getResultDirectoryPath();
 
-    public ProblemBenchmarkResult getProblemBenchmarkResult();
+    public File getResultDirectory();
 
-    public String getReportDirectoryPath();
+    public boolean hasAnyFailure();
 
-    public File getReportDirectory();
-
-    public boolean isFailure();
-
-    public boolean isSuccess();
+    public boolean hasAnySuccess();
 
     public String getName();
 
-    public Score getScore();
+    public Integer getAverageUninitializedVariableCount();
+
+    public Score getAverageScore();
 
 }

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/result/ProblemBenchmarkResult.java

@@ -282,7 +282,7 @@ public void writeOutputSolution(SubSingleBenchmarkResult subSingleBenchmarkResul
             return;
         }
         String filename = getName() + "." + solutionFileIO.getOutputFileExtension();
-        File outputSolutionFile = new File(subSingleBenchmarkResult.getReportDirectory(), filename);
+        File outputSolutionFile = new File(subSingleBenchmarkResult.getResultDirectory(), filename);
         solutionFileIO.write(outputSolution, outputSolutionFile);
     }
 
@@ -310,7 +310,7 @@ private void determineTotalsAndAveragesAndRanking() {
         // Do not rank a SingleBenchmarkResult that has a failure
         for (Iterator<SingleBenchmarkResult> it = successResultList.iterator(); it.hasNext(); ) {
             SingleBenchmarkResult singleBenchmarkResult = it.next();
-            if (singleBenchmarkResult.isFailure()) {
+            if (singleBenchmarkResult.hasAnyFailure()) {
                 failureCount++;
                 it.remove();
             } else {
@@ -354,7 +354,7 @@ private void determineRanking(List<SingleBenchmarkResult> rankedSingleBenchmarkR
 
     private void determineWinningScoreDifference() {
         for (SingleBenchmarkResult singleBenchmarkResult : singleBenchmarkResultList) {
-            if (singleBenchmarkResult.isFailure()) {
+            if (singleBenchmarkResult.hasAnyFailure()) {
                 continue;
             }
             singleBenchmarkResult.setWinningScoreDifference(

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/result/SingleBenchmarkResult.java

@@ -98,7 +98,6 @@ public void initSubSingleStatisticMap() {
         }
     }
 
-    @Override
     public SolverBenchmarkResult getSolverBenchmarkResult() {
         return solverBenchmarkResult;
     }
@@ -107,7 +106,6 @@ public void setSolverBenchmarkResult(SolverBenchmarkResult solverBenchmarkResult
         this.solverBenchmarkResult = solverBenchmarkResult;
     }
 
-    @Override
     public ProblemBenchmarkResult getProblemBenchmarkResult() {
         return problemBenchmarkResult;
     }
@@ -183,6 +181,7 @@ public void setRanking(Integer ranking) {
         this.ranking = ranking;
     }
 
+    @Override
     public Score getAverageScore() {
         return averageScore;
     }
@@ -207,6 +206,7 @@ public double[] getStandardDeviationDoubles() {
         return standardDeviationDoubles;
     }
 
+    @Override
     public Integer getAverageUninitializedVariableCount() {
         return averageUninitializedVariableCount;
     }
@@ -247,7 +247,7 @@ public File getBenchmarkReportDirectory() {
     }
 
     @Override
-    public boolean isSuccess() {
+    public boolean hasAnySuccess() {
         return failureCount != null && failureCount == 0;
     }
 
@@ -256,7 +256,7 @@ public boolean isInitialized() {
     }
 
     @Override
-    public boolean isFailure() {
+    public boolean hasAnyFailure() {
         return failureCount != null && failureCount != 0;
     }
 
@@ -299,25 +299,20 @@ public String getStandardDeviationString() {
         return StatisticUtils.getStandardDeviationString(standardDeviationDoubles);
     }
 
-    @Override
-    public Score getScore() {
-        return getAverageScore();
-    }
-
     // ************************************************************************
     // Accumulate methods
     // ************************************************************************
 
-    public String getReportDirectoryPath() {
+    public String getResultDirectoryPath() {
         return solverBenchmarkResult.getName();
     }
 
-    public File getReportDirectory() {
-        return new File(problemBenchmarkResult.getProblemReportDirectory(), getReportDirectoryPath());
+    public File getResultDirectory() {
+        return new File(problemBenchmarkResult.getProblemReportDirectory(), getResultDirectoryPath());
     }
 
     public void makeDirs() {
-        File singleReportDirectory = getReportDirectory();
+        File singleReportDirectory = getResultDirectory();
         singleReportDirectory.mkdirs();
         for (SubSingleBenchmarkResult subSingleBenchmarkResult : subSingleBenchmarkResultList) {
             subSingleBenchmarkResult.makeDirs();
@@ -343,7 +338,7 @@ private void determineRepresentativeSubSingleBenchmarkResult() {
             @Override
             public int compare(SubSingleBenchmarkResult o1, SubSingleBenchmarkResult o2) {
                 return new CompareToBuilder()
-                        .append(o1.isFailure(), o2.isFailure())
+                        .append(o1.hasAnyFailure(), o2.hasAnyFailure())
                         .append(o1.getRanking(), o2.getRanking())
                         .toComparison();
             }
@@ -369,7 +364,7 @@ private void determineTotalsAndAveragesAndRanking() {
         // Do not rank a SubSingleBenchmarkResult that has a failure
         for (Iterator<SubSingleBenchmarkResult> it = successResultList.iterator(); it.hasNext(); ) {
             SubSingleBenchmarkResult subSingleBenchmarkResult = it.next();
-            if (subSingleBenchmarkResult.isFailure()) {
+            if (subSingleBenchmarkResult.hasAnyFailure()) {
                 failureCount++;
                 it.remove();
             } else {
@@ -380,10 +375,10 @@ private void determineTotalsAndAveragesAndRanking() {
                     infeasibleScoreCount++;
                 }
                 if (firstNonFailure) {
-                    totalScore = subSingleBenchmarkResult.getScore();
+                    totalScore = subSingleBenchmarkResult.getAverageScore();
                     firstNonFailure = false;
                 } else {
-                    totalScore = totalScore.add(subSingleBenchmarkResult.getScore());
+                    totalScore = totalScore.add(subSingleBenchmarkResult.getAverageScore());
                 }
             }
         }

optaplanner-benchmark/src/main/java/org/optaplanner/benchmark/impl/result/SolverBenchmarkResult.java

@@ -298,7 +298,7 @@ protected void determineTotalsAndAverages() {
         totalUninitializedVariableCount = 0;
         infeasibleScoreCount = 0;
         for (SingleBenchmarkResult singleBenchmarkResult : singleBenchmarkResultList) {
-            if (singleBenchmarkResult.isFailure()) {
+            if (singleBenchmarkResult.hasAnyFailure()) {
                 failureCount++;
             } else {
                 if (!singleBenchmarkResult.isInitialized()) {