check canonicity in integration tests

* make sure that automata are not only equivalent but also minimal
* for the state local input ITs this requires an additional minimization step before computing the enabled symbols

Author: mtf90

test-support/learner-it-support/src/main/java/de/learnlib/testsupport/it/learner/LearnerVariantITCase.java

@@ -52,10 +52,11 @@ public void testLearning() {
         LearningAlgorithm<? extends M, I, D> learner = variant.getLearner();
 
         Alphabet<I> alphabet = example.getAlphabet();
+        M reference = example.getReferenceAutomaton();
 
         int maxRounds = variant.getMaxRounds();
         if (maxRounds < 0) {
-            maxRounds = example.getReferenceAutomaton().size();
+            maxRounds = reference.size();
         }
 
         long start = System.nanoTime();
@@ -75,9 +76,10 @@ public void testLearning() {
             Assert.assertTrue(refined, "Real counterexample " + ceQuery.getInput() + " did not refine hypothesis");
         }
 
-        Assert.assertNull(Automata.findSeparatingWord(example.getReferenceAutomaton(),
-                                                      learner.getHypothesisModel(),
-                                                      alphabet), "Final hypothesis does not match reference automaton");
+        M hypothesis = learner.getHypothesisModel();
+        Assert.assertEquals(hypothesis.size(), reference.size());
+        Assert.assertNull(Automata.findSeparatingWord(reference, hypothesis, alphabet),
+                          "Final hypothesis does not match reference automaton");
 
         long duration = (System.nanoTime() - start) / NANOS_PER_MILLISECOND;
         LOGGER.info("Passed learner integration test {} ... took [{}]",

test-support/learner-it-support/src/main/java/de/learnlib/testsupport/it/learner/VPDALearnerITCase.java

@@ -62,7 +62,9 @@ public void testLearning() {
             Assert.assertTrue(refined, "Real counterexample " + ceQuery.getInput() + " did not refine hypothesis");
         }
 
-        Assert.assertTrue(Automata.testEquivalence(reference, learner.getHypothesisModel(), alphabet),
+        OneSEVPA<?, I> hypothesis = learner.getHypothesisModel();
+        Assert.assertEquals(hypothesis.size(), reference.size());
+        Assert.assertTrue(Automata.testEquivalence(reference, hypothesis, alphabet),
                           "Final hypothesis does not match reference automaton");
 
         long duration = (System.nanoTime() - start) / NANOS_PER_MILLISECOND;

test-support/learning-examples/src/main/java/de/learnlib/examples/mealy/ExampleRandomStateLocalInputMealy.java

@@ -17,10 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashSet;
+import java.util.Objects;
 import java.util.Random;
-import java.util.Set;
 
 import de.learnlib.examples.LearningExample.StateLocalInputMealyLearningExample;
 import net.automatalib.automata.transducers.MealyMachine;
@@ -29,6 +28,7 @@
 import net.automatalib.commons.util.mappings.Mapping;
 import net.automatalib.commons.util.mappings.MutableMapping;
 import net.automatalib.commons.util.random.RandomUtil;
+import net.automatalib.util.automata.Automata;
 import net.automatalib.util.automata.random.RandomAutomata;
 import net.automatalib.words.Alphabet;
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -56,38 +56,40 @@ public ExampleRandomStateLocalInputMealy(Random random,
 
         this.alphabet = alphabet;
         this.undefinedOutput = undefinedOutput;
-        CompactMealy<I, O> source = RandomAutomata.randomDeterministic(random,
-                                                                       size,
-                                                                       alphabet,
-                                                                       Collections.emptyList(),
-                                                                       Arrays.asList(outputs),
-                                                                       new CompactMealy<>(alphabet));
+        CompactMealy<I, O> source = RandomAutomata.randomMealy(random, size, alphabet, Arrays.asList(outputs));
 
         final int alphabetSize = alphabet.size();
 
         final Collection<Integer> oldStates = source.getStates();
         final Integer sink = source.addState();
-        final MutableMapping<Integer, Collection<I>> enabledInputs = source.createDynamicStateMapping();
 
         for (final Integer s : oldStates) {
-
-            final Set<I> stateInputs = new HashSet<>(alphabet);
             // randomly remove (redirect to sink) transitions
             for (int idx : RandomUtil.distinctIntegers(random.nextInt(alphabetSize), alphabetSize, random)) {
-                final I sym = alphabet.getSymbol(idx);
-                stateInputs.remove(sym);
-                source.setTransition(s, sym, sink, undefinedOutput);
+                source.setTransition(s, idx, sink, undefinedOutput);
             }
-            enabledInputs.put(s, stateInputs);
         }
-
         // configure sink
         for (final I i : alphabet) {
             source.addTransition(sink, i, sink, undefinedOutput);
         }
-        enabledInputs.put(sink, Collections.emptyList());
 
-        this.referenceAutomaton = new MockedSLIMealy<>(source, enabledInputs);
+        final CompactMealy<I, O> minimized = Automata.invasiveMinimize(source, alphabet);
+        final MutableMapping<Integer, Collection<I>> enabledInputs = source.createStaticStateMapping();
+
+        for (Integer s : minimized) {
+            final Collection<I> stateInputs = new HashSet<>(alphabet);
+
+            for (I i : alphabet) {
+                if (Objects.equals(undefinedOutput, minimized.getOutput(s, i))) {
+                    stateInputs.remove(i);
+                }
+            }
+
+            enabledInputs.put(s, stateInputs);
+        }
+
+        this.referenceAutomaton = new MockedSLIMealy<>(minimized, enabledInputs);
     }
 
     @SafeVarargs