bump dependency versions

including necessary updates/refactorings

Author: mtf90

CHANGELOG.md

@@ -22,6 +22,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 * Removed the `learnlib.queries.parallel.threshold` property. Learning setups that want to use parallelism now need to explicitly setup parallel oracles.
 * Removed `MQUtil#answerQueries{Auto,Parallel}` and `MQUtil#answerOmegaQueries{Auto,Parallel}`)
+* Updated to [AutomataLib 0.10.0](https://github.com/LearnLib/automatalib/releases/tag/automatalib-0.10.0)
 
 ### Fixed
 

algorithms/active/adt/src/main/java/de/learnlib/algorithms/adt/automaton/ADTHypothesis.java

@@ -96,16 +96,18 @@ public O getTransitionOutput(final ADTTransition<I, O> transition) {
         return transition.getOutput();
     }
 
-    @SuppressWarnings("nullness") // hypothesis is always complete
     @Override
     public Word<I> transformAccessSequence(final Word<I> word) {
-        return this.getState(word).getAccessSequence();
+        final ADTState<I, O> state = this.getState(word);
+        assert state != null;
+        return state.getAccessSequence();
     }
 
-    @SuppressWarnings("nullness") // hypothesis is always complete
     @Override
     public boolean isAccessSequence(final Word<I> word) {
-        return this.getState(word).getAccessSequence().equals(word);
+        final ADTState<I, O> state = this.getState(word);
+        assert state != null;
+        return state.getAccessSequence().equals(word);
     }
 
 }

algorithms/active/adt/src/main/java/de/learnlib/algorithms/adt/config/model/extender/DefaultExtender.java

@@ -51,7 +51,8 @@ public <I, O> ExtensionResult<ADTState<I, O>, I, O> computeExtension(final ADTHy
                                                                          final PartialTransitionAnalyzer<ADTState<I, O>, I> partialTransitionAnalyzer,
                                                                          final ADTNode<ADTState<I, O>, I, O> ads) {
         // cannot compute extension for root node
-        if (ads.getParent() == null) {
+        final ADTNode<ADTState<I, O>, I, O> parent = ads.getParent();
+        if (parent == null) {
             return ExtensionResult.empty();
         }
 
@@ -62,7 +63,7 @@ public <I, O> ExtensionResult<ADTState<I, O>, I, O> computeExtension(final ADTHy
             return ExtensionResult.empty();
         }
 
-        final Pair<Word<I>, Word<O>> parentTrace = ADTUtil.buildTraceForNode(ads.getParent());
+        final Pair<Word<I>, Word<O>> parentTrace = ADTUtil.buildTraceForNode(parent);
 
         // as long as we encounter exceptions, repeat
         while (true) {

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

@@ -197,19 +197,25 @@ public boolean refineHypothesisInternal(DefaultQuery<I, Word<O>> ceQuery) {
 
         final ADTState<I, O> uState = this.hypothesis.getState(u);
         final ADTState<I, O> uaState = this.hypothesis.getState(ua);
+
+        assert uState != null && uaState != null;
+
         final Word<I> uAccessSequence = uState.getAccessSequence();
         final Word<I> uaAccessSequence = uaState.getAccessSequence();
         final Word<I> uAccessSequenceWithA = uAccessSequence.append(a);
 
         final ADTState<I, O> newState = this.hypothesis.addState();
         newState.setAccessSequence(uAccessSequenceWithA);
         final ADTTransition<I, O> oldTrans = this.hypothesis.getTransition(uState, a);
+
+        assert oldTrans != null;
+
         oldTrans.setTarget(newState);
         oldTrans.setIsSpanningTreeEdge(true);
 
         final Set<ADTNode<ADTState<I, O>, I, O>> finalNodes = ADTUtil.collectLeaves(this.adt.getRoot());
         final ADTNode<ADTState<I, O>, I, O> nodeToSplit = finalNodes.stream()
-                                                                    .filter(n -> n.getHypothesisState().equals(uaState))
+                                                                    .filter(n -> uaState.equals(n.getHypothesisState()))
                                                                     .findFirst()
                                                                     .orElseThrow(IllegalStateException::new);
 
@@ -347,6 +353,7 @@ private void closeTransition(final ADTTransition<I, O> transition) {
     public void closeTransition(ADTState<I, O> state, I input) {
 
         final ADTTransition<I, O> transition = this.hypothesis.getTransition(state, input);
+        assert transition != null;
 
         if (transition.needsSifting()) {
             final ADTNode<ADTState<I, O>, I, O> ads = transition.getSiftNode();
@@ -364,7 +371,9 @@ public void closeTransition(ADTState<I, O> state, I input) {
 
     @Override
     public boolean isTransitionDefined(ADTState<I, O> state, I input) {
-        return !this.hypothesis.getTransition(state, input).needsSifting();
+        final ADTTransition<I, O> transition = this.hypothesis.getTransition(state, input);
+        assert transition != null;
+        return !transition.needsSifting();
     }
 
     @Override
@@ -745,6 +754,7 @@ private void resolveAmbiguities(final ADTNode<ADTState<I, O>, I, O> nodeToReplac
         ADTNode<ADTState<I, O>, I, O> oldReference = null, newReference = null;
         for (final ADTNode<ADTState<I, O>, I, O> leaf : cachedLeaves) {
             final ADTState<I, O> hypState = leaf.getHypothesisState();
+            assert hypState != null;
 
             if (hypState.equals(iter.getHypothesisState())) {
                 oldReference = leaf;
@@ -774,10 +784,12 @@ private void resolveAmbiguities(final ADTNode<ADTState<I, O>, I, O> nodeToReplac
         }
 
         final ADTNode<ADTState<I, O>, I, O> reset = new ADTResetNode<>(oldTrace);
-        final O parentOutput = ADTUtil.getOutputForSuccessor(iter.getParent(), iter);
+        final ADTNode<ADTState<I, O>, I, O> parent = iter.getParent();
+        assert parent != null;
+        final O parentOutput = ADTUtil.getOutputForSuccessor(parent, iter);
 
-        iter.getParent().getChildren().put(parentOutput, reset);
-        reset.setParent(iter.getParent());
+        parent.getChildren().put(parentOutput, reset);
+        reset.setParent(parent);
         oldTrace.setParent(reset);
     }
 

algorithms/active/adt/src/main/java/de/learnlib/algorithms/adt/model/ObservationTree.java

@@ -184,6 +184,7 @@ public void addState(final S newState, final Word<I> accessSequence, final O out
                 this.observationTree.getSuccessor(this.observationTree.getInitialState(), prefix);
         final FastMealyState<O> target;
 
+        assert pred != null;
         if (pred.getTransitionObject(alphabet.getSymbolIndex(sym)) == null) {
             target = this.observationTree.addState();
             this.observationTree.addTransition(pred, sym, target, output);

algorithms/active/adt/src/main/java/de/learnlib/algorithms/adt/util/ADTUtil.java

@@ -18,6 +18,7 @@
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 
 import de.learnlib.algorithms.adt.adt.ADTLeafNode;
@@ -153,7 +154,7 @@ public static <S, I, O> Pair<Word<I>, Word<O>> buildTraceForNode(final ADTNode<S
 
     public static <S, I, O> O getOutputForSuccessor(final ADTNode<S, I, O> node, final ADTNode<S, I, O> successor) {
 
-        if (!successor.getParent().equals(node)) {
+        if (!node.equals(successor.getParent())) {
             throw new IllegalArgumentException("No parent relationship");
         }
 
@@ -325,7 +326,7 @@ public static <S, I, O> boolean mergeADS(final ADTNode<S, I, O> parent, final AD
 
         while (!(ADTUtil.isLeafNode(parentIter) || ADTUtil.isResetNode(parentIter)) && !ADTUtil.isLeafNode(childIter)) {
 
-            if (!parentIter.getSymbol().equals(childIter.getSymbol())) {
+            if (!Objects.equals(parentIter.getSymbol(), childIter.getSymbol())) {
                 return false;
             }
 

algorithms/active/adt/src/main/java/de/learnlib/algorithms/adt/util/SQOOTBridge.java

@@ -16,13 +16,14 @@
 package de.learnlib.algorithms.adt.util;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 import de.learnlib.algorithms.adt.model.ObservationTree;
 import de.learnlib.api.oracle.SymbolQueryOracle;
 import net.automatalib.automata.transducers.impl.FastMealy;
 import net.automatalib.automata.transducers.impl.FastMealyState;
-import org.checkerframework.checker.nullness.qual.Nullable;
 
 /**
  * A utility class that links an observation tree with a symbol query oracle, meaning that all queries to the symbol
@@ -44,7 +45,7 @@ public class SQOOTBridge<I, O> implements SymbolQueryOracle<I, O> {
 
     private final boolean enableCache;
 
-    private final @Nullable List<I> currentTrace;
+    private final List<I> currentTrace;
 
     private FastMealyState<O> currentState;
 
@@ -56,7 +57,7 @@ public SQOOTBridge(final ObservationTree<?, I, O> observationTree,
         this.observationTree = observationTree.getObservationTree();
         this.delegate = delegate;
         this.enableCache = enableCache;
-        this.currentTrace = enableCache ? new ArrayList<>() : null;
+        this.currentTrace = enableCache ? new ArrayList<>() : Collections.emptyList();
     }
 
     public void initialize() {
@@ -98,7 +99,7 @@ public O query(I i) {
                 this.observationTree.addTransition(this.currentState, i, newState, output);
             }
         } else {
-            assert output.equals(this.observationTree.getOutput(this.currentState, i)) : "Inconsistent observations";
+            assert Objects.equals(output, this.observationTree.getOutput(this.currentState, i)) : "Inconsistent observations";
             nextState = succ;
         }
 

algorithms/active/adt/src/test/java/de/learnlib/algorithms/adt/automaton/ADTHypothesisTest.java

@@ -46,31 +46,33 @@ public void testAutomaton() {
 
         final StateIDs<ADTState<Character, Integer>> stateIds = automaton.stateIDs();
 
+        final ADTState<Character, Integer> init = automaton.getInitialState();
+        Assert.assertNotNull(init);
+
         for (int s = 0; s < automaton.size(); s++) {
             for (final Character i : alphabet) {
-                automaton.addTransition(stateIds.getState(s), i, automaton.getInitialState(), 0);
+                automaton.addTransition(stateIds.getState(s), i, init, 0);
             }
         }
 
-        Assert.assertEquals(states * alphabet.size(), automaton.getInitialState().getIncomingTransitions().size());
+        Assert.assertEquals(states * alphabet.size(), init.getIncomingTransitions().size());
 
         final ADTState<Character, Integer> s1 = stateIds.getState(1), s2 = stateIds.getState(2), s3 =
                 stateIds.getState(3);
 
         automaton.removeAllTransitions(s1);
 
-        Assert.assertEquals((states - 1) * alphabet.size(),
-                            automaton.getInitialState().getIncomingTransitions().size());
+        Assert.assertEquals((states - 1) * alphabet.size(), init.getIncomingTransitions().size());
 
         automaton.removeAllTransitions(s2, alphabet.getSymbol(0));
 
-        Assert.assertEquals((states - 1) * alphabet.size() - 1,
-                            automaton.getInitialState().getIncomingTransitions().size());
+        Assert.assertEquals((states - 1) * alphabet.size() - 1, init.getIncomingTransitions().size());
 
         automaton.addTransition(s2, alphabet.getSymbol(0), s1, 0);
 
         for (int i = 1; i < alphabet.size(); i++) {
             ADTTransition<Character, Integer> transition = automaton.getTransition(s2, alphabet.getSymbol(i));
+            Assert.assertNotNull(transition);
             transition.setTarget(s1);
         }
 

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

@@ -24,6 +24,7 @@
 import de.learnlib.testsupport.AbstractVisualizationTest;
 import net.automatalib.serialization.dot.GraphDOT;
 import net.automatalib.words.Alphabet;
+import org.checkerframework.checker.initialization.qual.UnderInitialization;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
@@ -33,7 +34,9 @@
 public class ADTVisualizationTest extends AbstractVisualizationTest<ADTLearner<Input, String>> {
 
     @Override
-    protected ADTLearner<Input, String> getLearnerBuilder(Alphabet<Input> alphabet, SUL<Input, String> sul) {
+    protected ADTLearner<Input, String> getLearnerBuilder(@UnderInitialization ADTVisualizationTest this,
+                                                          Alphabet<Input> alphabet,
+                                                          SUL<Input, String> sul) {
         return new ADTLearnerBuilder<Input, String>().withAlphabet(alphabet)
                                                      .withOracle(new SULSymbolQueryOracle<>(sul))
                                                      .create();

algorithms/active/dhc/pom.xml

@@ -64,6 +64,11 @@ limitations under the License.
             <artifactId>automata-commons-util</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>org.checkerframework</groupId>
+            <artifactId>checker-qual</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>