parallelism: add tests for adaptive SULs

Author: mtf90

oracles/parallelism/src/test/java/de/learnlib/oracle/parallelism/AbstractDynamicParallelAdaptiveOracleTest.java

@@ -19,8 +19,6 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
-import java.util.UUID;
-import java.util.concurrent.atomic.AtomicInteger;
 
 import de.learnlib.oracle.AdaptiveMembershipOracle;
 import de.learnlib.oracle.ParallelAdaptiveOracle;
@@ -55,7 +53,7 @@ public void testDistinctQueries(PoolPolicy poolPolicy) {
             oracle.processQueries(queries);
 
             for (AnswerOnceQuery<D> query : queries) {
-                Assert.assertEquals(query.counter.get(), 0);
+                Assert.assertEquals(query.counter, 0);
             }
         } finally {
             oracle.shutdown();
@@ -101,31 +99,20 @@ public void processQueries(Collection<? extends AdaptiveQuery<Void, Void>> adapt
         }
     }
 
-    static final class AnswerOnceQuery<D> implements AdaptiveQuery<Void, D> {
+    abstract static class AbstractAdaptiveQuery<I, D> implements AdaptiveQuery<I, D> {
 
-        private final AtomicInteger counter;
-        private final List<D> outputs;
-        private final UUID id;
+        int counter;
+        final List<D> outputs;
 
-        AnswerOnceQuery(int count) {
-            this(count, null);
-        }
-
-        AnswerOnceQuery(int count, UUID id) {
-            this.counter = new AtomicInteger(count);
-            this.id = id;
+        AbstractAdaptiveQuery(int count) {
+            this.counter = count;
             this.outputs = Collections.synchronizedList(new ArrayList<>(count));
         }
 
-        @Override
-        public Void getInput() {
-            return null;
-        }
-
         @Override
         public Response processOutput(D out) {
             this.outputs.add(out);
-            final int i = counter.decrementAndGet();
+            final int i = --counter;
 
             if (i == 0) {
                 return Response.FINISHED;
@@ -139,9 +126,17 @@ public Response processOutput(D out) {
         public List<D> getOutputs() {
             return outputs;
         }
+    }
+
+    static final class AnswerOnceQuery<D> extends AbstractAdaptiveQuery<Void, D> {
+
+        AnswerOnceQuery(int count) {
+            super(count);
+        }
 
-        public UUID getId() {
-            return id;
+        @Override
+        public Void getInput() {
+            return null;
         }
     }
 

oracles/parallelism/src/test/java/de/learnlib/oracle/parallelism/AbstractStaticParallelAdaptiveOracleTest.java

@@ -21,23 +21,27 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import de.learnlib.oracle.AdaptiveMembershipOracle;
 import de.learnlib.oracle.ThreadPool.PoolPolicy;
-import de.learnlib.oracle.parallelism.AbstractDynamicParallelAdaptiveOracleTest.AnswerOnceQuery;
+import de.learnlib.oracle.parallelism.AbstractDynamicParallelAdaptiveOracleTest.AbstractAdaptiveQuery;
 import de.learnlib.oracle.parallelism.Utils.Analysis;
+import de.learnlib.oracle.parallelism.Utils.TestSULOutput;
 import de.learnlib.query.AdaptiveQuery;
+import de.learnlib.sul.SUL;
+import net.automatalib.word.Word;
+import net.automatalib.word.WordBuilder;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
 public abstract class AbstractStaticParallelAdaptiveOracleTest<D> {
 
-    private static final int NUM_ANSWERS = 1;
+    private static final int NUM_ANSWERS = 3;
 
     @Test(dataProvider = "policies", dataProviderClass = Utils.class)
     public void testZeroQueries(PoolPolicy policy) {
-        StaticParallelAdaptiveOracle<Void, D> oracle = getOracle(policy);
+        StaticParallelAdaptiveOracle<Integer, D> oracle = getOracle(policy);
         oracle.processQueries(Collections.emptyList());
         Analysis ana = analyze(Collections.emptyList());
         Utils.sanityCheck(ana);
@@ -47,7 +51,7 @@ public void testZeroQueries(PoolPolicy policy) {
 
     @Test(dataProvider = "policies", dataProviderClass = Utils.class)
     public void testLessThanMin(PoolPolicy policy) {
-        StaticParallelAdaptiveOracle<Void, D> oracle = getOracle(policy);
+        StaticParallelAdaptiveOracle<Integer, D> oracle = getOracle(policy);
         List<AnswerOnceQuery<D>> queries = createQueries(Utils.MIN_BATCH_SIZE - 1);
         oracle.processQueries(queries);
         Analysis ana = analyze(queries);
@@ -58,7 +62,7 @@ public void testLessThanMin(PoolPolicy policy) {
 
     @Test(dataProvider = "policies", dataProviderClass = Utils.class)
     public void testMin(PoolPolicy policy) {
-        StaticParallelAdaptiveOracle<Void, D> oracle = getOracle(policy);
+        StaticParallelAdaptiveOracle<Integer, D> oracle = getOracle(policy);
         List<AnswerOnceQuery<D>> queries = createQueries(Utils.MIN_BATCH_SIZE);
         oracle.processQueries(queries);
         Analysis ana = analyze(queries);
@@ -69,7 +73,7 @@ public void testMin(PoolPolicy policy) {
 
     @Test(dataProvider = "policies", dataProviderClass = Utils.class)
     public void testLessThanTwoBatches(PoolPolicy policy) {
-        StaticParallelAdaptiveOracle<Void, D> oracle = getOracle(policy);
+        StaticParallelAdaptiveOracle<Integer, D> oracle = getOracle(policy);
         List<AnswerOnceQuery<D>> queries = createQueries(2 * Utils.MIN_BATCH_SIZE - 1);
         oracle.processQueries(queries);
         Analysis ana = analyze(queries);
@@ -80,7 +84,7 @@ public void testLessThanTwoBatches(PoolPolicy policy) {
 
     @Test(dataProvider = "policies", dataProviderClass = Utils.class)
     public void testLessThanSixBatches(PoolPolicy policy) {
-        StaticParallelAdaptiveOracle<Void, D> oracle = getOracle(policy);
+        StaticParallelAdaptiveOracle<Integer, D> oracle = getOracle(policy);
         List<AnswerOnceQuery<D>> queries = createQueries(5 * Utils.MIN_BATCH_SIZE + Utils.MIN_BATCH_SIZE / 2);
         oracle.processQueries(queries);
         Analysis ana = analyze(queries);
@@ -91,7 +95,7 @@ public void testLessThanSixBatches(PoolPolicy policy) {
 
     @Test(dataProvider = "policies", dataProviderClass = Utils.class)
     public void testFullLoad(PoolPolicy policy) {
-        StaticParallelAdaptiveOracle<Void, D> oracle = getOracle(policy);
+        StaticParallelAdaptiveOracle<Integer, D> oracle = getOracle(policy);
         List<AnswerOnceQuery<D>> queries = createQueries(2 * Utils.NUM_ORACLES * Utils.MIN_BATCH_SIZE);
         oracle.processQueries(queries);
         Analysis ana = analyze(queries);
@@ -100,9 +104,9 @@ public void testFullLoad(PoolPolicy policy) {
         oracle.shutdown();
     }
 
-    protected abstract StaticParallelAdaptiveOracleBuilder<Void, D> getBuilder();
+    protected abstract StaticParallelAdaptiveOracleBuilder<Integer, D> getBuilder();
 
-    protected abstract TestOutput extractTestOutput(D output);
+    protected abstract TestSULOutput extractTestOutput(D output);
 
     protected TestMembershipOracle[] getOracles() {
         TestMembershipOracle[] oracles = new TestMembershipOracle[Utils.NUM_ORACLES];
@@ -113,7 +117,7 @@ protected TestMembershipOracle[] getOracles() {
         return oracles;
     }
 
-    private StaticParallelAdaptiveOracle<Void, D> getOracle(PoolPolicy poolPolicy) {
+    private StaticParallelAdaptiveOracle<Integer, D> getOracle(PoolPolicy poolPolicy) {
         return getBuilder().withMinBatchSize(Utils.MIN_BATCH_SIZE)
                            .withNumInstances(Utils.NUM_ORACLES)
                            .withPoolPolicy(poolPolicy)
@@ -123,7 +127,7 @@ private StaticParallelAdaptiveOracle<Void, D> getOracle(PoolPolicy poolPolicy) {
     private List<AnswerOnceQuery<D>> createQueries(int num) {
         List<AnswerOnceQuery<D>> result = new ArrayList<>(num);
         for (int i = 0; i < num; i++) {
-            result.add(new AnswerOnceQuery<>(NUM_ANSWERS, UUID.randomUUID()));
+            result.add(new AnswerOnceQuery<>(NUM_ANSWERS));
         }
         return result;
     }
@@ -135,24 +139,30 @@ private Analysis analyze(Collection<AnswerOnceQuery<D>> queries) {
 
         for (AnswerOnceQuery<D> qry : queries) {
             List<D> outputs = qry.getOutputs();
+            Word<Integer> inputs = qry.getInputs();
             Assert.assertEquals(outputs.size(), NUM_ANSWERS);
-            D output = outputs.get(0);
-            TestOutput out = extractTestOutput(output);
-            Assert.assertNotNull(out);
-            int oracleId = out.oracleId;
-            List<Integer> seqIdList = seqIds.get(oracleId);
-            if (seqIdList == null) {
-                oracles.add(oracleId);
-                seqIdList = new ArrayList<>();
-                seqIds.put(oracleId, seqIdList);
-                incorrectAnswers.put(oracleId, 0);
-            }
+            Assert.assertEquals(inputs.size(), NUM_ANSWERS);
+
+            for (int i = 0; i < outputs.size(); i++) {
+                D output = outputs.get(i);
+                TestSULOutput out = extractTestOutput(output);
+                Assert.assertNotNull(out);
+                int oracleId = out.oracleId;
+                List<Integer> seqIdList = seqIds.get(oracleId);
+                if (seqIdList == null) {
+                    oracles.add(oracleId);
+                    seqIdList = new ArrayList<>();
+                    seqIds.put(oracleId, seqIdList);
+                    incorrectAnswers.put(oracleId, 0);
+                }
 
-            int seqId = out.batchSeqId;
-            seqIdList.add(seqId);
+                int seqId = out.batchSeqId;
+                seqIdList.add(seqId);
 
-            if (!qry.getId().equals(out.id)) {
-                incorrectAnswers.put(oracleId, incorrectAnswers.get(oracleId) + 1);
+                Assert.assertEquals(out.word.size(), 1);
+                if (!inputs.getSymbol(i).equals(out.word.firstSymbol())) {
+                    incorrectAnswers.put(oracleId, incorrectAnswers.get(oracleId) + 1);
+                }
             }
         }
 
@@ -175,20 +185,7 @@ private Analysis analyze(Collection<AnswerOnceQuery<D>> queries) {
         return new Analysis(oracles, seqIds, incorrectAnswers, minBatchSize, maxBatchSize);
     }
 
-    static final class TestOutput {
-
-        public final int oracleId;
-        public final int batchSeqId;
-        public final UUID id;
-
-        TestOutput(int oracleId, int batchSeqId, UUID id) {
-            this.oracleId = oracleId;
-            this.batchSeqId = batchSeqId;
-            this.id = id;
-        }
-    }
-
-    static final class TestMembershipOracle implements AdaptiveMembershipOracle<Void, TestOutput> {
+    static final class TestMembershipOracle implements AdaptiveMembershipOracle<Integer, TestSULOutput> {
 
         private final int oracleId;
 
@@ -197,14 +194,66 @@ static final class TestMembershipOracle implements AdaptiveMembershipOracle<Void
         }
 
         @Override
-        public void processQueries(Collection<? extends AdaptiveQuery<Void, TestOutput>> queries) {
+        public void processQueries(Collection<? extends AdaptiveQuery<Integer, TestSULOutput>> queries) {
             int batchSeqId = 0;
-            for (AdaptiveQuery<Void, TestOutput> q : queries) {
+            for (AdaptiveQuery<Integer, TestSULOutput> q : queries) {
                 for (int i = 0; i < NUM_ANSWERS; i++) {
-                    q.processOutput(new TestOutput(oracleId, batchSeqId++, ((AnswerOnceQuery<TestOutput>) q).getId()));
+                    q.processOutput(new TestSULOutput(oracleId, batchSeqId++, Word.fromLetter(q.getInput())));
                 }
             }
         }
     }
 
+    static final class TestSUL implements SUL<Integer, TestSULOutput> {
+
+        private final AtomicInteger atomicInteger;
+        private final int oracleId;
+        private int batchSeqId;
+
+        TestSUL(AtomicInteger atomicInteger) {
+            this.atomicInteger = atomicInteger;
+            this.oracleId = atomicInteger.getAndIncrement();
+        }
+
+        @Override
+        public void pre() {}
+
+        @Override
+        public void post() {}
+
+        @Override
+        public TestSULOutput step(Integer in) {
+            return new TestSULOutput(oracleId, batchSeqId++, Word.fromLetter(in));
+        }
+
+        @Override
+        public boolean canFork() {
+            return true;
+        }
+
+        @Override
+        public TestSUL fork() {
+            return new TestSUL(this.atomicInteger);
+        }
+    }
+
+    static final class AnswerOnceQuery<D> extends AbstractAdaptiveQuery<Integer, D> {
+
+        final WordBuilder<Integer> wb;
+
+        AnswerOnceQuery(int count) {
+            super(count);
+            this.wb = new WordBuilder<>(count);
+        }
+
+        @Override
+        public Integer getInput() {
+            this.wb.append(super.counter);
+            return super.counter;
+        }
+
+        public Word<Integer> getInputs() {
+            return wb.toWord();
+        }
+    }
 }

oracles/parallelism/src/test/java/de/learnlib/oracle/parallelism/AbstractStaticParallelOmegaOracleTest.java

@@ -104,7 +104,7 @@ public void testFullLoad(PoolPolicy policy) {
 
     protected abstract StaticParallelOmegaOracleBuilder<?, Integer, D> getBuilder();
 
-    protected abstract TestOutput extractTestOutput(D output);
+    protected abstract TestSULOutput extractTestOutput(D output);
 
     protected TestMembershipOracle[] getOracles() {
         TestMembershipOracle[] oracles = new TestMembershipOracle[Utils.NUM_ORACLES];
@@ -142,7 +142,7 @@ private Analysis analyze(Collection<OmegaQuery<Integer, D>> queries) {
         Map<Integer, Integer> incorrectAnswers = new HashMap<>();
 
         for (OmegaQuery<Integer, D> qry : queries) {
-            TestOutput out = extractTestOutput(qry.getOutput());
+            TestSULOutput out = extractTestOutput(qry.getOutput());
             Assert.assertNotNull(out);
             int oracleId = out.oracleId;
             List<Integer> seqIdList = seqIds.get(oracleId);
@@ -156,7 +156,7 @@ private Analysis analyze(Collection<OmegaQuery<Integer, D>> queries) {
             int seqId = out.batchSeqId;
             seqIdList.add(seqId);
 
-            if (!qry.asDefaultQuery().getInput().equals(out.input)) {
+            if (!qry.asDefaultQuery().getInput().equals(out.word)) {
                 incorrectAnswers.put(oracleId, incorrectAnswers.get(oracleId) + 1);
             }
         }
@@ -180,20 +180,7 @@ private Analysis analyze(Collection<OmegaQuery<Integer, D>> queries) {
         return new Analysis(oracles, seqIds, incorrectAnswers, minBatchSize, maxBatchSize);
     }
 
-    static final class TestOutput {
-
-        public final int oracleId;
-        public final int batchSeqId;
-        public final Word<Integer> input;
-
-        TestOutput(int oracleId, int batchSeqId, Word<Integer> input) {
-            this.oracleId = oracleId;
-            this.batchSeqId = batchSeqId;
-            this.input = input;
-        }
-    }
-
-    static final class TestMembershipOracle implements OmegaMembershipOracle<Integer, Integer, TestOutput> {
+    static final class TestMembershipOracle implements OmegaMembershipOracle<Integer, Integer, TestSULOutput> {
 
         private final int oracleId;
 
@@ -202,16 +189,16 @@ static final class TestMembershipOracle implements OmegaMembershipOracle<Integer
         }
 
         @Override
-        public void processQueries(Collection<? extends OmegaQuery<Integer, TestOutput>> queries) {
+        public void processQueries(Collection<? extends OmegaQuery<Integer, TestSULOutput>> queries) {
             int batchSeqId = 0;
-            for (OmegaQuery<Integer, TestOutput> qry : queries) {
-                qry.answer(new TestOutput(oracleId, batchSeqId++, qry.asDefaultQuery().getInput()),
+            for (OmegaQuery<Integer, TestSULOutput> qry : queries) {
+                qry.answer(new TestSULOutput(oracleId, batchSeqId++, qry.asDefaultQuery().getInput()),
                            qry.getPeriodicity());
             }
         }
 
         @Override
-        public MembershipOracle<Integer, TestOutput> getMembershipOracle() {
+        public MembershipOracle<Integer, TestSULOutput> getMembershipOracle() {
             throw new OmegaException();
         }