Update dependencies (#139)

* adjust to AutomataLib refactorings

* bump basic depdency versions

* bump checkstyle + cleanups

* bump spotbugs + cleanups

* bump pmd + cleanups

* bump checkerframework + cleanups

* fix wrong simplification

* improve comments

* cleanups

* do not fail on javadoc warnings

completness of documentation is now checked by checkstyle and we would have to disable failing anyways when moving on to JDK 17

Author: mtf90

CHANGELOG.md

@@ -24,6 +24,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
     * The `OTUtils` class no longer provides the `displayHTMLInBrowser` methods in order to not depend on `java.desktop`. If you relied on this functionality, use the `writeHTMLToFile` methods instead and call `Desktop.getDesktop().open(file.toURI())` yourself.
     * The classes in the `learnlib-learning-examples` artifact have their package renamed to `de.learnlib.testsupport.example`.
 * Some other refactorings include:
+  * The `AbstractVisualizationTest` has been refactored into the `VisualizationUtils` factory. 
   * The `learnlib-datastructure-ot`, `learnlib-datastructure-dt`, `learnlib-datastructure-list`, and `learnlib-datastructure-pta` artifacts have been merged into a new `learnlib-datastructures` artifact.
   * The `learnlib-oml` artifact (including its packages and class names) has been renamed to `learnlib-lambda`.
   * Various counters (especially `*Counter*SUL`s) have been streamlined. In most cases there now exists a single counter that tracks multiple properties.

algorithms/active/aaar/src/main/java/de/learnlib/algorithm/aaar/AbstractAAARLearner.java

@@ -116,15 +116,15 @@ public boolean refineHypothesis(DefaultQuery<CI, D> query) {
             final D outOld = oracle.answerQuery(testOld);
             final D outNew = oracle.answerQuery(testNew);
 
-            if (!Objects.equals(outOld, outNew)) { // add new abstraction
+            if (Objects.equals(outOld, outNew)) {
+                prefix = prefix.append(r);
+                wb.append(r);
+            } else { // add new abstraction
                 final AI newA = tree.splitLeaf(r, cur, prefix, suffix, outOld);
                 abs.addSymbol(newA);
                 rep.addSymbol(cur);
                 learner.addAlphabetSymbol(cur);
                 return true;
-            } else {
-                prefix = prefix.append(r);
-                wb.append(r);
             }
         }
 
@@ -182,8 +182,8 @@ public L getLearner() {
         return this.learner;
     }
 
-    protected <S1, S2, SP, TP> void copyAbstract(UniversalDeterministicAutomaton<S1, CI, ?, SP, TP> src,
-                                                 MutableDeterministic<S2, AI, ?, SP, TP> tgt) {
+    protected <S1, S2, T, SP, TP> void copyAbstract(UniversalDeterministicAutomaton<S1, CI, T, SP, TP> src,
+                                                    MutableDeterministic<S2, AI, ?, SP, TP> tgt) {
         // states
         final Map<S2, S1> states = new HashMap<>();
         final Map<S1, S2> statesRev = new HashMap<>();
@@ -200,12 +200,15 @@ protected <S1, S2, SP, TP> void copyAbstract(UniversalDeterministicAutomaton<S1,
         // transitions
         for (Entry<S2, S1> e : states.entrySet()) {
             for (CI r : rep) {
-                final AbstractAbstractionTree<AI, CI, D> tree = getTreeForRepresentative(r);
-                final AI a = tree.getAbstractSymbol(r);
-                tgt.setTransition(e.getKey(),
-                                  a,
-                                  statesRev.get(src.getSuccessor(e.getValue(), r)),
-                                  src.getTransitionProperty(e.getValue(), r));
+                final T trans = src.getTransition(e.getValue(), r);
+                if (trans != null) {
+                    final AbstractAbstractionTree<AI, CI, D> tree = getTreeForRepresentative(r);
+                    final AI a = tree.getAbstractSymbol(r);
+                    tgt.setTransition(e.getKey(),
+                                      a,
+                                      statesRev.get(src.getSuccessor(trans)),
+                                      src.getTransitionProperty(trans));
+                }
             }
         }
     }

algorithms/active/aaar/src/main/java/module-info.java

@@ -35,7 +35,7 @@
     requires net.automatalib.common.util;
     requires net.automatalib.core;
 
-    // make non-static once https://github.com/typetools/checker-framework/issues/4559 is implemented
+    // annotations are 'provided'-scoped and do not need to be loaded at runtime
     requires static org.checkerframework.checker.qual;
 
     exports de.learnlib.algorithm.aaar;

algorithms/active/adt/src/main/java/de/learnlib/algorithm/adt/ads/DefensiveADS.java

@@ -194,11 +194,11 @@ private Optional<ADTNode<S, I, O>> compute(Map<S, S> mapping) {
                     final O nextOutput = automaton.getOutput(current, i);
 
                     final Map<S, S> nextMapping;
-                    if (!successors.containsKey(nextOutput)) {
+                    if (successors.containsKey(nextOutput)) {
+                        nextMapping = successors.get(nextOutput);
+                    } else {
                         nextMapping = new HashMap<>();
                         successors.put(nextOutput, nextMapping);
-                    } else {
-                        nextMapping = successors.get(nextOutput);
                     }
 
                     // invalid input

algorithms/active/adt/src/main/java/de/learnlib/algorithm/adt/learner/ADTLearner.java

@@ -162,7 +162,9 @@ public boolean refineHypothesis(DefaultQuery<I, Word<O>> ce) {
                 final DefaultQuery<I, Word<O>> currentCE = this.openCounterExamples.poll();
                 this.allCounterExamples.add(currentCE);
 
-                while (this.refineHypothesisInternal(currentCE)) {}
+                while (this.refineHypothesisInternal(currentCE)) {
+                    // refine exhaustively
+                }
             }
 
             // subtree replacements may reactivate old CEs

algorithms/active/adt/src/main/java/module-info.java

@@ -41,8 +41,8 @@
     requires net.automatalib.util;
     requires org.slf4j;
 
+    // annotations are 'provided'-scoped and do not need to be loaded at runtime
     requires static de.learnlib.tooling.annotation;
-    // make non-static once https://github.com/typetools/checker-framework/issues/4559 is implemented
     requires static org.checkerframework.checker.qual;
 
     exports de.learnlib.algorithm.adt.ads;

algorithms/active/adt/src/test/java/de/learnlib/algorithm/adt/learner/ADTVisualizationTest.java

@@ -16,36 +16,36 @@
 package de.learnlib.algorithm.adt.learner;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.StringWriter;
 
 import de.learnlib.oracle.membership.SULAdaptiveOracle;
-import de.learnlib.sul.SUL;
-import de.learnlib.testsupport.AbstractVisualizationTest;
+import de.learnlib.testsupport.VisualizationUtils;
 import de.learnlib.testsupport.example.mealy.ExampleCoffeeMachine.Input;
-import net.automatalib.alphabet.Alphabet;
+import net.automatalib.common.util.IOUtil;
 import net.automatalib.serialization.dot.GraphDOT;
-import org.checkerframework.checker.initialization.qual.UnderInitialization;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
-public class ADTVisualizationTest extends AbstractVisualizationTest<ADTLearner<Input, String>> {
+public class ADTVisualizationTest {
 
-    @Override
-    protected ADTLearner<Input, String> getLearnerBuilder(@UnderInitialization ADTVisualizationTest this,
-                                                          Alphabet<Input> alphabet,
-                                                          SUL<Input, String> sul) {
-        return new ADTLearnerBuilder<Input, String>().withAlphabet(alphabet)
-                                                     .withOracle(new SULAdaptiveOracle<>(sul))
-                                                     .create();
+    private final ADTLearner<Input, String> learner;
+
+    public ADTVisualizationTest() {
+        this.learner =
+                VisualizationUtils.runExperiment((alphabet, sul) -> new ADTLearnerBuilder<Input, String>().withAlphabet(
+                        alphabet).withOracle(new SULAdaptiveOracle<>(sul)).create());
     }
 
     @Test
     public void testVisualization() throws IOException {
-        final String expectedADT = resourceAsString("/adt.dot");
+        try (InputStream is = ADTVisualizationTest.class.getResourceAsStream("/adt.dot")) {
+            final String expectedADT = IOUtil.toString(IOUtil.asBufferedUTF8Reader(is));
+            final StringWriter actualADT = new StringWriter();
 
-        final StringWriter actualADT = new StringWriter();
-        GraphDOT.write(super.learner.getADT().getRoot(), actualADT);
+            GraphDOT.write(this.learner.getADT().getRoot(), actualADT);
 
-        Assert.assertEquals(actualADT.toString(), expectedADT);
+            Assert.assertEquals(actualADT.toString(), expectedADT);
+        }
     }
 }

algorithms/active/dhc/src/main/java/module-info.java

@@ -36,8 +36,8 @@
     requires net.automatalib.common.util;
     requires net.automatalib.core;
 
+    // annotations are 'provided'-scoped and do not need to be loaded at runtime
     requires static de.learnlib.tooling.annotation;
-    // make non-static once https://github.com/typetools/checker-framework/issues/4559 is implemented
     requires static org.checkerframework.checker.qual;
 
     exports de.learnlib.algorithm.dhc.mealy;

algorithms/active/dhc/src/test/java/de/learnlib/algorithm/dhc/mealy/MealyDHCTest.java

@@ -69,7 +69,7 @@ public void testMealyDHCGrid() {
         dhc.startLearning();
         MealyMachine<?, Character, ?, Integer> hypo = dhc.getHypothesisModel();
 
-        Assert.assertEquals(hypo.size(), (xsize * ysize), "Mismatch in size of learned hypothesis");
+        Assert.assertEquals(hypo.size(), xsize * ysize, "Mismatch in size of learned hypothesis");
 
     }
 

algorithms/active/kearns-vazirani/src/main/java/de/learnlib/algorithm/kv/dfa/KearnsVaziraniDFA.java

@@ -106,7 +106,9 @@ public boolean refineHypothesis(DefaultQuery<I, Boolean> ceQuery) {
             return false;
         }
         if (repeatedCounterexampleEvaluation) {
-            while (refineHypothesisSingle(input, output)) {}
+            while (refineHypothesisSingle(input, output)) {
+                // refine exhaustively
+            }
         }
         return true;
     }
@@ -188,7 +190,7 @@ private void updateTransitions(List<Long> transList,
             long encodedTrans = transList.get(i);
 
             int sourceState = (int) (encodedTrans >> Integer.SIZE);
-            int transIdx = (int) (encodedTrans);
+            int transIdx = (int) encodedTrans;
 
             StateInfo<I, Boolean> sourceInfo = stateInfos.get(sourceState);
             I symbol = alphabet.getSymbol(transIdx);
@@ -202,7 +204,7 @@ private void updateTransitions(List<Long> transList,
             long encodedTrans = transList.get(i);
 
             int sourceState = (int) (encodedTrans >> Integer.SIZE);
-            int transIdx = (int) (encodedTrans);
+            int transIdx = (int) encodedTrans;
 
             setTransition(sourceState, transIdx, succs.get(i));
         }
@@ -309,8 +311,8 @@ public void addAlphabetSymbol(I symbol) {
 
         // check if we already have information about the symbol (then the transition is defined) so we don't post
         // redundant queries
-        if (this.hypothesis.getInitialState() != null &&
-            this.hypothesis.getSuccessor(this.hypothesis.getInitialState(), symbol) == null) {
+        final Integer init = this.hypothesis.getInitialState();
+        if (init != null && this.hypothesis.getSuccessor(init, symbol) == null) {
             // use new list to prevent concurrent modification exception
             final List<Word<I>> transAs = new ArrayList<>(this.stateInfos.size());
             for (StateInfo<I, Boolean> si : this.stateInfos) {