6660471831

Committed 26 Oct 2023 10:29PM UTC coverage: 93.327% (-0.001%) from 93.328%

Build # 6660471831

Build Type

push

github

Committed by

mtf90

Commit Message

cleanup statistics filters

Run Details

32 of 32 new or added lines in 7 files covered. (100.0%)

11734 of 12573 relevant lines covered (93.33%)

1.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.11

/oracles/membership-oracles/src/main/java/de/learnlib/oracle/membership/SimulatorOmegaOracle.java

/* Copyright (C) 2013-2023 TU Dortmund
 * This file is part of LearnLib, http://www.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.membership;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import de.learnlib.api.oracle.MembershipOracle;
import de.learnlib.api.oracle.MembershipOracle.DFAMembershipOracle;
import de.learnlib.api.oracle.MembershipOracle.MealyMembershipOracle;
import de.learnlib.api.oracle.OmegaMembershipOracle;
import de.learnlib.api.oracle.OmegaQueryAnswerer;
import de.learnlib.api.oracle.SingleQueryOmegaOracle;
import de.learnlib.api.query.OmegaQuery;
import de.learnlib.api.query.Query;
import de.learnlib.util.MQUtil;
import net.automatalib.automaton.concept.SuffixOutput;
import net.automatalib.automaton.fsa.DFA;
import net.automatalib.automaton.transducer.MealyMachine;
import net.automatalib.common.util.Pair;
import net.automatalib.ts.simple.SimpleDTS;
import net.automatalib.word.Word;
import net.automatalib.word.WordBuilder;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Answers {@link OmegaQuery}s by simulating an automaton.
 * <p>
 * <b>Implementation note</b>: Under the assumption that read-operations do not alter the internal state of the
 * automaton, this oracle is thread-safe.
 *
 * @see SimulatorOracle
 *
 * @param <S> the state type.
 * @param <I> the input type.
 * @param <D> the output type.
 */
public class SimulatorOmegaOracle<S extends Object, I, D> implements SingleQueryOmegaOracle<S, I, D> {

    /**
     * The automaton to simulate.
     */
    private final SimpleDTS<S, I> simpleDTS;

    /**
     * @see #getMembershipOracle()
     */
    private final SimulatorOracle<I, D> simulatorOracle;

    /**
     * Constructs a new {@link SimulatorOmegaOracle}.
     *
     * @param automaton the automaton to simulate.
     * @param simulatorOracle the {@link SimulatorOracle} used to answer {@link Query}s.
     * @param <A> the automaton type.
     */
    public <A extends SuffixOutput<I, D> & SimpleDTS<S, I>> SimulatorOmegaOracle(A automaton, SimulatorOracle<I, D> simulatorOracle) {
        this.simpleDTS = automaton;
        this.simulatorOracle = simulatorOracle;
    }

    /**
     * Gets the {@link SimulatorOracle} used to answer {@link de.learnlib.api.query.Query}s.
     *
     * @return the SimulatorOracle.
     */
    @Override
    public MembershipOracle<I, D> getMembershipOracle() {
        return simulatorOracle;
    }

    /**
     * Test for state equivalence by simply invoking {@link Object#equals(Object)}.
     *
     * @see OmegaMembershipOracle#isSameState(Word, Object, Word, Object)
     */
    @Override
    public boolean isSameState(Word<I> input1, S s1, Word<I> input2, S s2) {
        return s1.equals(s2);
    }

    @Override
    public void processQueries(Collection<? extends OmegaQuery<I, D>> queries) {
        MQUtil.answerOmegaQueries(this, queries);
    }

    /**
     * Returns an answer for an {@link OmegaQuery}.
     * <p>
     * The output is obtained through the {@link SimulatorOracle}, while the states are obtained by means of creating
     * two access sequences to states in the simulated automaton.
     *
     * @see OmegaQueryAnswerer#answerQuery(Word, Word, int)
     */
    @Override
    public Pair<@Nullable D, Integer> answerQuery(Word<I> prefix, Word<I> loop, int repeat) {
        assert repeat > 0;

        final WordBuilder<I> wb = new WordBuilder<>(prefix.length() + loop.length() * repeat, prefix);

        S stateIter = simpleDTS.getState(wb);

        if (stateIter == null) {
            return Pair.of(null, -1);
        }

        final List<S> states = new ArrayList<>(repeat + 1);
        states.add(stateIter);

        for (int i = 0; i < repeat; i++) {
            final S nextState = simpleDTS.getSuccessor(stateIter, loop);

            if (nextState == null) {
                return Pair.of(null, -1);
            }

            wb.append(loop);

            int prefixLength = prefix.length();
            for (S s : states) {
                if (isSameState(wb.toWord(0, prefixLength), s, wb.toWord(), nextState)) {
                    return Pair.of(simulatorOracle.answerQuery(wb.toWord()), i + 1);
                }
                prefixLength += loop.length();
            }

            states.add(nextState);
            stateIter = nextState;
        }

        return Pair.of(null, -1);
    }

    public static class DFASimulatorOmegaOracle<S extends Object, I>
            extends SimulatorOmegaOracle<S, I, Boolean>
            implements SingleQueryOmegaOracleDFA<S, I> {

        private final DFA<S, I> automaton;

        public DFASimulatorOmegaOracle(DFA<S, I> automaton) {
            super(automaton, new DFASimulatorOracle<>(automaton));
            this.automaton = automaton;
        }

        @Override
        public DFAMembershipOracle<I> getMembershipOracle() {
            return new DFASimulatorOracle<>(automaton);
        }
    }

    public static class MealySimulatorOmegaOracle<S extends Object, I, O>
            extends SimulatorOmegaOracle<S, I, Word<O>>
            implements SingleQueryOmegaOracleMealy<S, I, O> {

        private final MealyMachine<?, I, ?, O> automaton;

        public MealySimulatorOmegaOracle(MealyMachine<S, I, ?, O> automaton) {
            super(automaton, new MealySimulatorOracle<>(automaton));
            this.automaton = automaton;
        }

        @Override
        public MealyMembershipOracle<I, O> getMembershipOracle() {
            return new MealySimulatorOracle<>(automaton);
        }
    }
}

1	/* Copyright (C) 2013-2023 TU Dortmund
2	* This file is part of LearnLib, http://www.learnlib.de/.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package de.learnlib.oracle.membership;
17
18	import java.util.ArrayList;
19	import java.util.Collection;
20	import java.util.List;
21
22	import de.learnlib.api.oracle.MembershipOracle;
23	import de.learnlib.api.oracle.MembershipOracle.DFAMembershipOracle;
24	import de.learnlib.api.oracle.MembershipOracle.MealyMembershipOracle;
25	import de.learnlib.api.oracle.OmegaMembershipOracle;
26	import de.learnlib.api.oracle.OmegaQueryAnswerer;
27	import de.learnlib.api.oracle.SingleQueryOmegaOracle;
28	import de.learnlib.api.query.OmegaQuery;
29	import de.learnlib.api.query.Query;
30	import de.learnlib.util.MQUtil;
31	import net.automatalib.automaton.concept.SuffixOutput;
32	import net.automatalib.automaton.fsa.DFA;
33	import net.automatalib.automaton.transducer.MealyMachine;
34	import net.automatalib.common.util.Pair;
35	import net.automatalib.ts.simple.SimpleDTS;
36	import net.automatalib.word.Word;
37	import net.automatalib.word.WordBuilder;
38	import org.checkerframework.checker.nullness.qual.Nullable;
39
40	/**
41	* Answers {@link OmegaQuery}s by simulating an automaton.
42	* <p>
43	* <b>Implementation note</b>: Under the assumption that read-operations do not alter the internal state of the
44	* automaton, this oracle is thread-safe.
45	*
46	* @see SimulatorOracle
47	*
48	* @param <S> the state type.
49	* @param <I> the input type.
50	* @param <D> the output type.
51	*/
52	public class SimulatorOmegaOracle<S extends Object, I, D> implements SingleQueryOmegaOracle<S, I, D> {	2✔
53
54	/**
55	* The automaton to simulate.
56	*/
57	private final SimpleDTS<S, I> simpleDTS;
58
59	/**
60	* @see #getMembershipOracle()
61	*/
62	private final SimulatorOracle<I, D> simulatorOracle;
63
64	/**
65	* Constructs a new {@link SimulatorOmegaOracle}.
66	*
67	* @param automaton the automaton to simulate.
68	* @param simulatorOracle the {@link SimulatorOracle} used to answer {@link Query}s.
69	* @param <A> the automaton type.
70	*/
71	public <A extends SuffixOutput<I, D> & SimpleDTS<S, I>> SimulatorOmegaOracle(A automaton, SimulatorOracle<I, D> simulatorOracle) {	2✔
72	this.simpleDTS = automaton;	2✔
73	this.simulatorOracle = simulatorOracle;	2✔
74	}	2✔
75
76	/**
77	* Gets the {@link SimulatorOracle} used to answer {@link de.learnlib.api.query.Query}s.
78	*
79	* @return the SimulatorOracle.
80	*/
81	@Override
82	public MembershipOracle<I, D> getMembershipOracle() {
83	return simulatorOracle;	×
84	}
85
86	/**
87	* Test for state equivalence by simply invoking {@link Object#equals(Object)}.
88	*
89	* @see OmegaMembershipOracle#isSameState(Word, Object, Word, Object)
90	*/
91	@Override
92	public boolean isSameState(Word<I> input1, S s1, Word<I> input2, S s2) {
93	return s1.equals(s2);	2✔
94	}
95
96	@Override
97	public void processQueries(Collection<? extends OmegaQuery<I, D>> queries) {
98	MQUtil.answerOmegaQueries(this, queries);	2✔
99	}	2✔
100
101	/**
102	* Returns an answer for an {@link OmegaQuery}.
103	* <p>
104	* The output is obtained through the {@link SimulatorOracle}, while the states are obtained by means of creating
105	* two access sequences to states in the simulated automaton.
106	*
107	* @see OmegaQueryAnswerer#answerQuery(Word, Word, int)
108	*/
109	@Override
110	public Pair<@Nullable D, Integer> answerQuery(Word<I> prefix, Word<I> loop, int repeat) {
111	assert repeat > 0;	2✔
112
113	final WordBuilder<I> wb = new WordBuilder<>(prefix.length() + loop.length() * repeat, prefix);	2✔
114
115	S stateIter = simpleDTS.getState(wb);	2✔
116
117	if (stateIter == null) {	2✔
118	return Pair.of(null, -1);	×
119	}
120
121	final List<S> states = new ArrayList<>(repeat + 1);	2✔
122	states.add(stateIter);	2✔
123
124	for (int i = 0; i < repeat; i++) {	2✔
125	final S nextState = simpleDTS.getSuccessor(stateIter, loop);	2✔
126
127	if (nextState == null) {	2✔
128	return Pair.of(null, -1);	×
129	}
130
131	wb.append(loop);	2✔
132
133	int prefixLength = prefix.length();	2✔
134	for (S s : states) {	2✔
135	if (isSameState(wb.toWord(0, prefixLength), s, wb.toWord(), nextState)) {	2✔
136	return Pair.of(simulatorOracle.answerQuery(wb.toWord()), i + 1);	2✔
137	}
138	prefixLength += loop.length();	2✔
139	}	2✔
140
141	states.add(nextState);	2✔
142	stateIter = nextState;	2✔
143	}
144
145	return Pair.of(null, -1);	2✔
146	}
147
148	public static class DFASimulatorOmegaOracle<S extends Object, I>
149	extends SimulatorOmegaOracle<S, I, Boolean>
150	implements SingleQueryOmegaOracleDFA<S, I> {
151
152	private final DFA<S, I> automaton;
153
154	public DFASimulatorOmegaOracle(DFA<S, I> automaton) {
155	super(automaton, new DFASimulatorOracle<>(automaton));	2✔
156	this.automaton = automaton;	2✔
157	}	2✔
158
159	@Override
160	public DFAMembershipOracle<I> getMembershipOracle() {
161	return new DFASimulatorOracle<>(automaton);	1✔
162	}
163	}
164
165	public static class MealySimulatorOmegaOracle<S extends Object, I, O>
166	extends SimulatorOmegaOracle<S, I, Word<O>>
167	implements SingleQueryOmegaOracleMealy<S, I, O> {
168
169	private final MealyMachine<?, I, ?, O> automaton;
170
171	public MealySimulatorOmegaOracle(MealyMachine<S, I, ?, O> automaton) {
172	super(automaton, new MealySimulatorOracle<>(automaton));	1✔
173	this.automaton = automaton;	1✔
174	}	1✔
175
176	@Override
177	public MealyMembershipOracle<I, O> getMembershipOracle() {
178	return new MealySimulatorOracle<>(automaton);	1✔
179	}
180	}
181	}

LearnLib / learnlib / 6660471831

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous