equivalence-oracles: add EarlyExitEQOracle

mtf90 · mtf90 · commit e5e6d3913fe5 · 2025-07-31T19:21:15.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,9 +6,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 [Full changelog](https://github.com/LearnLib/learnlib/compare/learnlib-0.18.0...HEAD)
 
+### Added
+
+* Added an `EarlyExitEQOracle` which for a given `AdaptiveMembershipOracle` and `TestWordGenerator` stops the evaluation of (potentially long) Mealy-based equivalence tests as soon as a mismatch with the hypothesis is detected, potentially improving the symbol performance of the given equivalence oracle.
+
 ### Changed
 
 * LearnLib now requires Java 11 at runtime.
+* The `generateTestWords` method of `AbstractTestWordEQOracle` now needs to be public.
 
 ### Fixed
 
diff --git a/api/src/main/java/de/learnlib/TestWordGenerator.java b/api/src/main/java/de/learnlib/TestWordGenerator.java
@@ -0,0 +1,47 @@
+/* Copyright (C) 2013-2025 TU Dortmund University
+ * This file is part of LearnLib <https://learnlib.de>.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.learnlib;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+
+import de.learnlib.oracle.EquivalenceOracle;
+import net.automatalib.word.Word;
+
+/**
+ * A markup interface for generators of testing sequences (such as {@link EquivalenceOracle} implementations).
+ *
+ * @param <A>
+ *         automaton type
+ * @param <I>
+ *         input symbol type
+ */
+public interface TestWordGenerator<A, I> {
+
+    /**
+     * Generate the stream of words that should be evaluated for the given hypothesis.
+     *
+     * @param hypothesis
+     *         the current hypothesis
+     * @param inputs
+     *         the collection of inputs to consider
+     *
+     * @return the stream of test words used for (equivalence) testing
+     *
+     * @see EquivalenceOracle#findCounterExample(Object, Collection)
+     */
+    Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs);
+}
diff --git a/oracles/equivalence-oracles/pom.xml b/oracles/equivalence-oracles/pom.xml
@@ -76,6 +76,11 @@ limitations under the License.
         </dependency>
 
         <!-- test -->
+        <dependency>
+            <groupId>de.learnlib</groupId>
+            <artifactId>learnlib-drivers-simulator</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>de.learnlib</groupId>
             <artifactId>learnlib-membership-oracles</artifactId>
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/AbstractTestWordEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/AbstractTestWordEQOracle.java
@@ -20,6 +20,7 @@
 import java.util.Objects;
 import java.util.stream.Stream;
 
+import de.learnlib.TestWordGenerator;
 import de.learnlib.logging.Category;
 import de.learnlib.oracle.EquivalenceOracle;
 import de.learnlib.oracle.MembershipOracle;
@@ -33,7 +34,7 @@
 
 /**
  * An abstract equivalence oracle that takes care of query batching and hypothesis checking and allows extending classes
- * to solely focus on test word generation by implementing {@link #generateTestWords(Output, Collection)}.
+ * to solely focus on test word generation by implementing {@link #generateTestWords(Object, Collection)}}.
  * <p>
  * Being {@link Stream stream}-based, this oracle encourages the lazy computation of counterexamples, so that all
  * counterexamples do not have to be computed upfront, but only until the first valid counterexample is found.
@@ -45,7 +46,8 @@
  * @param <D>
  *         output (domain) type
  */
-public abstract class AbstractTestWordEQOracle<A extends Output<I, D>, I, D> implements EquivalenceOracle<A, I, D> {
+public abstract class AbstractTestWordEQOracle<A extends Output<I, D>, I, D>
+        implements EquivalenceOracle<A, I, D>, TestWordGenerator<A, I> {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AbstractTestWordEQOracle.class);
 
@@ -82,20 +84,6 @@ public AbstractTestWordEQOracle(MembershipOracle<I, D> membershipOracle, int bat
         return ceStream.findFirst().orElse(null);
     }
 
-    /**
-     * Generate the stream of test words that should be used for the current equivalence check cycle.
-     *
-     * @param hypothesis
-     *         the current hypothesis of the learning algorithm
-     * @param inputs
-     *         the collection of inputs to consider
-     *
-     * @return the stream of test words used for equivalence testing
-     *
-     * @see EquivalenceOracle#findCounterExample(Object, Collection)
-     */
-    protected abstract Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs);
-
     private Stream<DefaultQuery<I, D>> answerQueries(Stream<DefaultQuery<I, D>> stream) {
         if (isBatched()) {
             return IteratorUtil.stream(IteratorUtil.batch(stream.iterator(), this.batchSize))
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/CompleteExplorationEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/CompleteExplorationEQOracle.java
@@ -126,7 +126,7 @@ public CompleteExplorationEQOracle(MembershipOracle<I, D> sulOracle, int minDept
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         return IterableUtil.stream(IterableUtil.allTuples(inputs, minDepth, maxDepth)).map(Word::fromList);
     }
 }
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/IncrementalWMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/IncrementalWMethodEQOracle.java
@@ -102,7 +102,7 @@ public void setMaxDepth(int maxDepth) {
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         // FIXME: warn about inputs being ignored?
         incrementalWMethodIt.update(hypothesis);
 
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWMethodEQOracle.java
@@ -185,7 +185,7 @@ public RandomWMethodEQOracle(MembershipOracle<I, D> sulOracle,
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         UniversalDeterministicAutomaton<?, I, ?, ?, ?> aut = hypothesis;
         return doGenerateTestWords(aut, inputs);
     }
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWordsEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWordsEQOracle.java
@@ -103,7 +103,7 @@ public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle,
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
 
         final List<? extends I> symbolList = CollectionUtil.randomAccessList(inputs);
 
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWpMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWpMethodEQOracle.java
@@ -186,7 +186,7 @@ public RandomWpMethodEQOracle(MembershipOracle<I, D> sulOracle,
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         UniversalDeterministicAutomaton<?, I, ?, ?, ?> aut = hypothesis;
         return doGenerateTestWords(aut, inputs);
     }
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/WMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/WMethodEQOracle.java
@@ -151,7 +151,7 @@ public WMethodEQOracle(MembershipOracle<I, D> sulOracle, int lookahead, int expe
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         return IteratorUtil.stream(new WMethodTestsIterator<>(hypothesis,
                                                               inputs,
                                                               Math.max(lookahead, expectedSize - hypothesis.size())));
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/WpMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/WpMethodEQOracle.java
@@ -151,7 +151,7 @@ public WpMethodEQOracle(MembershipOracle<I, D> sulOracle, int lookahead, int exp
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         return IteratorUtil.stream(new WpMethodTestsIterator<>(hypothesis,
                                                                inputs,
                                                                Math.max(lookahead, expectedSize - hypothesis.size())));
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/mealy/EarlyExitEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/mealy/EarlyExitEQOracle.java
@@ -0,0 +1,129 @@
+/* Copyright (C) 2013-2025 TU Dortmund University
+ * This file is part of LearnLib <https://learnlib.de>.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.learnlib.oracle.equivalence.mealy;
+
+import java.util.Collection;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import de.learnlib.TestWordGenerator;
+import de.learnlib.oracle.AdaptiveMembershipOracle;
+import de.learnlib.oracle.EquivalenceOracle.MealyEquivalenceOracle;
+import de.learnlib.query.AdaptiveQuery;
+import de.learnlib.query.DefaultQuery;
+import net.automatalib.automaton.transducer.MealyMachine;
+import net.automatalib.word.Word;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * This {@link MealyEquivalenceOracle} evaluates test words generated by the given {@link TestWordGenerator} on a
+ * symbol-by-symbol basis (via the provided {@link AdaptiveMembershipOracle}) and returns a counterexample on the first
+ * observed mismatch. It can be used to improve the symbol performance of equivalence oracles which tend to generate
+ * long testing sequences.
+ * <p>
+ * Note that this implementation does not support query parallelization via batching, even if the provided
+ * {@link AdaptiveMembershipOracle} does.
+ *
+ * @param <I>
+ *         input symbol type
+ * @param <O>
+ *         output symbol type
+ */
+public class EarlyExitEQOracle<I, O> implements MealyEquivalenceOracle<I, O> {
+
+    private final AdaptiveMembershipOracle<I, O> oracle;
+    private final TestWordGenerator<? super MealyMachine<?, I, ?, O>, I> delegate;
+
+    public EarlyExitEQOracle(AdaptiveMembershipOracle<I, O> oracle,
+                             TestWordGenerator<? super MealyMachine<?, I, ?, O>, I> delegate) {
+        this.oracle = oracle;
+        this.delegate = delegate;
+    }
+
+    @Override
+    public @Nullable DefaultQuery<I, Word<O>> findCounterExample(MealyMachine<?, I, ?, O> hypothesis,
+                                                                 Collection<? extends I> inputs) {
+
+        final Stream<Word<I>> testWords = delegate.generateTestWords(hypothesis, inputs);
+        final QueryWrapper<?, I, ?, O> wrapper = testWords.map(w -> new QueryWrapper<>(hypothesis, w))
+                                                          .peek(oracle::processQuery)
+                                                          .filter(QueryWrapper::hasMismatch)
+                                                          .findFirst()
+                                                          .orElse(null);
+        return wrapper == null ? null : wrapper.buildQuery();
+    }
+
+    private static final class QueryWrapper<S, I, T, O> implements AdaptiveQuery<I, O> {
+
+        private final MealyMachine<S, I, T, O> hypothesis;
+        private final Word<I> input;
+
+        private int currSymIdx;
+        private @Nullable S currState;
+        private boolean hasMismatch;
+        private O mismatchOutput;
+
+        QueryWrapper(MealyMachine<S, I, T, O> hypothesis, Word<I> input) {
+            this.hypothesis = hypothesis;
+            this.input = input;
+            this.currState = hypothesis.getInitialState();
+            this.currSymIdx = 0;
+        }
+
+        @Override
+        public I getInput() {
+            return input.getSymbol(currSymIdx);
+        }
+
+        @Override
+        public Response processOutput(O out) {
+            if (currState == null) {
+                return handleError(out);
+            }
+
+            final T t = this.hypothesis.getTransition(currState, getInput());
+
+            if (t == null) {
+                return handleError(out);
+            } else {
+                final O hypOut = this.hypothesis.getTransitionOutput(t);
+                if (Objects.equals(out, hypOut)) {
+                    this.currState = this.hypothesis.getSuccessor(t);
+                    this.currSymIdx++;
+                    return this.currSymIdx == input.length() ? Response.FINISHED : Response.SYMBOL;
+                } else {
+                    return handleError(out);
+                }
+            }
+        }
+
+        Response handleError(O out) {
+            this.hasMismatch = true;
+            this.mismatchOutput = out;
+            return Response.FINISHED;
+        }
+
+        boolean hasMismatch() {
+            return hasMismatch;
+        }
+
+        DefaultQuery<I, Word<O>> buildQuery() {
+            return new DefaultQuery<>(this.input.prefix(currSymIdx),
+                                      Word.fromLetter(this.input.getSymbol(currSymIdx)),
+                                      Word.fromLetter(mismatchOutput));
+        }
+    }
+}
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/sba/WMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/sba/WMethodEQOracle.java
@@ -104,7 +104,7 @@ public WMethodEQOracle(MembershipOracle<I, Boolean> sulOracle, int lookahead, in
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(SBA<?, I> hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(SBA<?, I> hypothesis, Collection<? extends I> inputs) {
         if (!(inputs instanceof ProceduralInputAlphabet)) {
             throw new IllegalArgumentException("Inputs are not a procedural alphabet");
         }
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/spa/WMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/spa/WMethodEQOracle.java
@@ -104,7 +104,7 @@ public WMethodEQOracle(MembershipOracle<I, Boolean> sulOracle, int lookahead, in
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(SPA<?, I> hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(SPA<?, I> hypothesis, Collection<? extends I> inputs) {
         if (!(inputs instanceof ProceduralInputAlphabet)) {
             throw new IllegalArgumentException("Inputs are not a procedural alphabet");
         }
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/spa/WpMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/spa/WpMethodEQOracle.java
@@ -105,7 +105,7 @@ public WpMethodEQOracle(MembershipOracle<I, Boolean> sulOracle, int lookahead, i
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(SPA<?, I> hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(SPA<?, I> hypothesis, Collection<? extends I> inputs) {
         if (!(inputs instanceof ProceduralInputAlphabet)) {
             throw new IllegalArgumentException("Inputs are not a procedural alphabet");
         }
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/spmm/WMethodEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/spmm/WMethodEQOracle.java
@@ -105,7 +105,7 @@ public WMethodEQOracle(MembershipOracle<I, Word<O>> sulOracle, int lookahead, in
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(SPMM<?, I, ?, O> hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(SPMM<?, I, ?, O> hypothesis, Collection<? extends I> inputs) {
         if (!(inputs instanceof ProceduralInputAlphabet)) {
             throw new IllegalArgumentException("Inputs are not a procedural alphabet");
         }
diff --git a/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/vpa/RandomWellMatchedWordsEQOracle.java b/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/vpa/RandomWellMatchedWordsEQOracle.java
@@ -70,7 +70,7 @@ public RandomWellMatchedWordsEQOracle(Random random,
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(Output<I, Boolean> hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(Output<I, Boolean> hypothesis, Collection<? extends I> inputs) {
 
         if (!(inputs instanceof VPAlphabet)) {
             throw new IllegalArgumentException(
diff --git a/oracles/equivalence-oracles/src/test/java/de/learnlib/oracle/equivalence/TestWordEQOracleBatchTest.java b/oracles/equivalence-oracles/src/test/java/de/learnlib/oracle/equivalence/TestWordEQOracleBatchTest.java
@@ -94,7 +94,7 @@ int getGeneratedWordsCounter() {
         }
 
         @Override
-        protected Stream<Word<I>> generateTestWords(Output<I, Boolean> hypothesis, Collection<? extends I> inputs) {
+        public Stream<Word<I>> generateTestWords(Output<I, Boolean> hypothesis, Collection<? extends I> inputs) {
             final I sym = inputs.iterator().next();
             return Stream.generate(() -> Word.fromLetter(sym)).peek(w-> generatedWordsCounter++).limit(MAX_QUERIES);
         }
diff --git a/oracles/equivalence-oracles/src/test/java/de/learnlib/oracle/equivalence/mealy/EarlyExitEQOracleTest.java b/oracles/equivalence-oracles/src/test/java/de/learnlib/oracle/equivalence/mealy/EarlyExitEQOracleTest.java

Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ public CompleteExplorationEQOracle(MembershipOracle<I, D> sulOracle, int minDept`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`@Override`
`129`		`- protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
	`129`	`+ public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
`130`	`130`	`return IterableUtil.stream(IterableUtil.allTuples(inputs, minDepth, maxDepth)).map(Word::fromList);`
`131`	`131`	`}`
`132`	`132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ public void setMaxDepth(int maxDepth) {`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`@Override`
`105`		`- protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
	`105`	`+ public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
`106`	`106`	`// FIXME: warn about inputs being ignored?`
`107`	`107`	`incrementalWMethodIt.update(hypothesis);`
`108`	`108`
Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ public RandomWMethodEQOracle(MembershipOracle<I, D> sulOracle,`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`@Override`
`188`		`- protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
	`188`	`+ public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
`189`	`189`	`UniversalDeterministicAutomaton<?, I, ?, ?, ?> aut = hypothesis;`
`190`	`190`	`return doGenerateTestWords(aut, inputs);`
`191`	`191`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle,`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`@Override`
`106`		`- protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
	`106`	`+ public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
`107`	`107`
`108`	`108`	`final List<? extends I> symbolList = CollectionUtil.randomAccessList(inputs);`
`109`	`109`
Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ public RandomWpMethodEQOracle(MembershipOracle<I, D> sulOracle,`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`@Override`
`189`		`- protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
	`189`	`+ public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
`190`	`190`	`UniversalDeterministicAutomaton<?, I, ?, ?, ?> aut = hypothesis;`
`191`	`191`	`return doGenerateTestWords(aut, inputs);`
`192`	`192`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ public WMethodEQOracle(MembershipOracle<I, D> sulOracle, int lookahead, int expe`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`@Override`
`154`		`- protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
	`154`	`+ public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {`
`155`	`155`	`return IteratorUtil.stream(new WMethodTestsIterator<>(hypothesis,`
`156`	`156`	`inputs,`
`157`	`157`	`Math.max(lookahead, expectedSize - hypothesis.size())));`