Merge branch 'checkstyle-11' into 'master'

fix issues found by Checkstyle 11

See merge request se2/scratch/litterbox/litterbox!741

Author: b-fein

src/main/java/de/uni_passau/fim/se2/litterbox/ast/parser/StringExprConverter.java

@@ -194,7 +194,7 @@ private static AttributeOf parseSensingOf(
         final String property = exprBlock.getFieldValueAsString(KnownFields.PROPERTY);
         final Attribute attribute = switch (property) {
             case "y position", "x position", "direction", "costume #", "costume name", "size", "volume",
-                 "backdrop name", "backdrop #" -> new AttributeFromFixed(new FixedAttribute(property));
+                    "backdrop name", "backdrop #" -> new AttributeFromFixed(new FixedAttribute(property));
             default -> new AttributeFromVariable(new Variable(new StrId(property)));
         };
 

src/main/java/de/uni_passau/fim/se2/litterbox/refactor/metaheuristics/algorithms/SearchAlgorithm.java

@@ -26,14 +26,11 @@
 public interface SearchAlgorithm<C> {
 
     /**
-     * <p>
      * Runs the search algorithm and returns a possible admissible solution of the encoded problem.
-     * </p>
-     * <p>
-     * Note: every run must perform a new search and must be independent of the previous one. In
+     *
+     * <p>Note: every run must perform a new search and must be independent of the previous one. In
      * particular, it must be possible to call this method multiple times in a row. Implementors
      * must ensure multiple runs do not interfere each other.
-     * </p>
      *
      * @return a solution
      */

src/main/java/de/uni_passau/fim/se2/litterbox/refactor/metaheuristics/fitness_functions/FitnessFunction.java

@@ -32,17 +32,14 @@ public interface FitnessFunction<C> extends ToDoubleFunction<C> {
     String DEFAULT_NAME = "fitness_function";
 
     /**
-     * <p>
      * Computes and returns the fitness value of the given solution {@code c}. Minimizing fitness
      * functions must return lower values for better solutions, whereas maximizing fitness
      * functions are expected to return higher values.
-     * </p>
-     * <p>
-     * When two solutions {@code c1} and {@code c2} are equal it is generally recommended to
+     *
+     * <p>When two solutions {@code c1} and {@code c2} are equal it is generally recommended to
      * return the same fitness value for both of them. That is, {@code c1.equals(c2)} implies {@code
      * getFitness(c1) == getFitness(c2)}. While this is not an absolute requirement implementations
      * that do not conform to this should clearly indicate this fact.
-     * </p>
      *
      * @param c the solution to rate
      * @return the fitness value of the given solutions
@@ -66,20 +63,19 @@ default String getName() {
      * Tells whether this function is a minimizing fitness function.
      *
      * @return {@code true} if this is a minimizing fitness function, {@code false} if this is a
-     * maximizing fitness function
+     *         maximizing fitness function
      */
     boolean isMinimizing();
 
     /**
-     * Returns the reference point of the fitness function for the hypervolume
+     * Returns the reference point of the fitness function for the hypervolume.
      *
      * @return {@code 1} if this is a minimizing fitness function, {@code 0} if this is a
-     * maximizing fitness function
+     *         maximizing fitness function
      */
     double getReferencePoint();
 
     /**
-     * <p>
      * Returns a comparator that compares two solutions by their fitness, taking into account
      * whether this is a maximizing or a minimizing fitness function. In other words, given two
      * solutions {@code c1} and {@code c2} with fitness values {@code f1} and {@code f2},
@@ -88,9 +84,8 @@ default String getName() {
      * {@code f1} is worse than {@code f2}. If this is a minimizing fitness function, smaller
      * fitness values are considered better, and, on the contrary, if this is a maximizing fitness
      * function, larger fitness values are considered better.
-     * </p>
-     * <p>
-     * Example usage:
+     *
+     * <p>Example usage:
      * <pre>{@code
      * FitnessFunction<C> ff = ...;
      * C c1 = ...; // first solution to compare
@@ -105,7 +100,6 @@ default String getName() {
      *     // c1 and c2 are equally good
      * }
      * }</pre>
-     * </p>
      *
      * @return a {@code Comparator<C>} that uses this fitness function as extractor for its sort key
      */

src/main/java/de/uni_passau/fim/se2/litterbox/refactor/metaheuristics/search_operators/RefactorSequenceMutation.java

@@ -38,18 +38,15 @@ public RefactorSequenceMutation(List<RefactoringFinder> refactoringFinders) {
     }
 
     /**
-     * <p>
      * Returns a mutated deep copy of the given refactoring sequence.
-     * </p>
-     * <p>
-     * Each integer in the production list mutates with a probability of one divided by the lists size.
-     * If a index inside the list mutates it executes one of the following mutations with equal probability:
+     *
+     * <p>Each integer in the production list mutates with a probability of one divided by the lists size.
+     * If an index inside the list mutates it executes one of the following mutations with equal probability:
      * <ol>
      *  <li>add a new production to the list at the index</li>
      *  <li>replace the current production at the index</li>
      *  <li>remove the current production at the index</li>
      * </ol>
-     * </p>
      *
      * @param refactorSequence The original RefactorSequence, that mutates.
      * @return A mutated deep copy of the given RefactorSequence object.
@@ -69,7 +66,13 @@ public RefactorSequence apply(RefactorSequence refactorSequence) {
             index++;
         }
 
-        return new RefactorSequence(refactorSequence.getOriginalProgram(), refactorSequence.getMutation(), refactorSequence.getCrossover(), mutatedProductions, refactoringFinders);
+        return new RefactorSequence(
+                refactorSequence.getOriginalProgram(),
+                refactorSequence.getMutation(),
+                refactorSequence.getCrossover(),
+                mutatedProductions,
+                refactoringFinders
+        );
     }
 
     /**

src/main/java/de/uni_passau/fim/se2/litterbox/utils/SelfTyped.java

@@ -33,14 +33,12 @@
 public interface SelfTyped<S extends SelfTyped<S>> {
 
     /**
-     * <p>
      * Returns the runtime type of the implementor (a.k.a. "self-type"). This method must only be
      * implemented in concrete, non-abstract subclasses by returning a reference to {@code this},
      * and nothing else. Returning a reference to any other runtime type other than {@code this}
      * breaks the contract.
-     * </p>
-     * <p>
-     * In other words, every concrete subclass {@code Foo} that implements the interface {@code
+     *
+     * <p>In other words, every concrete subclass {@code Foo} that implements the interface {@code
      * SelfTyped} must implement this method as follows:
      * <pre>{@code
      * public final class Foo implements SelfTyped<Foo> {
@@ -50,7 +48,6 @@ public interface SelfTyped<S extends SelfTyped<S>> {
      *     }
      * }
      * }</pre>
-     * </p>
      *
      * @return a reference to the self-type
      */