6433387082

Committed 06 Oct 2023 03:10PM UTC coverage: 92.296% (-0.007%) from 92.303%

Build # 6433387082

Build Type

push

github

Committed by

mtf90

Commit Message

update Falk's developer id

Run Details

11573 of 12539 relevant lines covered (92.3%)

1.67 hits per line

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

89.47

/oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWordsEQOracle.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.equivalence;

import java.util.Collection;
import java.util.List;
import java.util.Random;
import java.util.stream.Stream;

import de.learnlib.api.oracle.EquivalenceOracle.DFAEquivalenceOracle;
import de.learnlib.api.oracle.EquivalenceOracle.MealyEquivalenceOracle;
import de.learnlib.api.oracle.EquivalenceOracle.MooreEquivalenceOracle;
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.MembershipOracle.MooreMembershipOracle;
import de.learnlib.buildtool.refinement.annotation.GenerateRefinement;
import de.learnlib.buildtool.refinement.annotation.Generic;
import de.learnlib.buildtool.refinement.annotation.Interface;
import de.learnlib.buildtool.refinement.annotation.Map;
import net.automatalib.automata.concepts.Output;
import net.automatalib.automata.fsa.DFA;
import net.automatalib.automata.transducers.MealyMachine;
import net.automatalib.automata.transducers.MooreMachine;
import net.automatalib.commons.util.collections.CollectionsUtil;
import net.automatalib.words.Word;
import net.automatalib.words.WordBuilder;

@GenerateRefinement(name = "DFARandomWordsEQOracle",
                    generics = "I",
                    parentGenerics = {@Generic(clazz = DFA.class, generics = {"?", "I"}),
                                      @Generic("I"),
                                      @Generic(clazz = Boolean.class)},
                    parameterMapping = @Map(from = MembershipOracle.class,
                                            to = DFAMembershipOracle.class,
                                            withGenerics = "I"),
                    interfaces = @Interface(clazz = DFAEquivalenceOracle.class, generics = "I"))
@GenerateRefinement(name = "MealyRandomWordsEQOracle",
                    generics = {"I", "O"},
                    parentGenerics = {@Generic(clazz = MealyMachine.class, generics = {"?", "I", "?", "O"}),
                                      @Generic("I"),
                                      @Generic(clazz = Word.class, generics = "O")},
                    parameterMapping = @Map(from = MembershipOracle.class,
                                            to = MealyMembershipOracle.class,
                                            withGenerics = {"I", "O"}),
                    interfaces = @Interface(clazz = MealyEquivalenceOracle.class, generics = {"I", "O"}))
@GenerateRefinement(name = "MooreRandomWordsEQOracle",
                    generics = {"I", "O"},
                    parentGenerics = {@Generic(clazz = MooreMachine.class, generics = {"?", "I", "?", "O"}),
                                      @Generic("I"),
                                      @Generic(clazz = Word.class, generics = "O")},
                    parameterMapping = @Map(from = MembershipOracle.class,
                                            to = MooreMembershipOracle.class,
                                            withGenerics = {"I", "O"}),
                    interfaces = @Interface(clazz = MooreEquivalenceOracle.class, generics = {"I", "O"}))
public class RandomWordsEQOracle<A extends Output<I, D>, I, D> extends AbstractTestWordEQOracle<A, I, D> {

    private final Random random;
    private final int maxTests;
    private final int minLength;
    private final int maxLength;

    public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle, int minLength, int maxLength, int maxTests) {
        this(mqOracle, minLength, maxLength, maxTests, new Random());
    }

    public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle,
                               int minLength,
                               int maxLength,
                               int maxTests,
                               Random random) {
        this(mqOracle, minLength, maxLength, maxTests, random, 1);
    }

    public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle,
                               int minLength,
                               int maxLength,
                               int maxTests,
                               Random random,
                               int batchSize) {
        super(mqOracle, batchSize);
        this.maxTests = maxTests;
        this.minLength = minLength;
        this.maxLength = maxLength;
        this.random = random;
    }

    @Override
    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {

        final List<? extends I> symbolList = CollectionsUtil.randomAccessList(inputs);

        return Stream.generate(() -> generateTestWord(symbolList, symbolList.size())).limit(maxTests);
    }

    private Word<I> generateTestWord(List<? extends I> symbolList, int numSyms) {

        final int length = minLength + random.nextInt((maxLength - minLength) + 1);
        final WordBuilder<I> result = new WordBuilder<>(length);

        for (int j = 0; j < length; ++j) {
            int symidx = random.nextInt(numSyms);
            I sym = symbolList.get(symidx);
            result.append(sym);
        }

        return result.toWord();
    }
}

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.equivalence;
17
18	import java.util.Collection;
19	import java.util.List;
20	import java.util.Random;
21	import java.util.stream.Stream;
22
23	import de.learnlib.api.oracle.EquivalenceOracle.DFAEquivalenceOracle;
24	import de.learnlib.api.oracle.EquivalenceOracle.MealyEquivalenceOracle;
25	import de.learnlib.api.oracle.EquivalenceOracle.MooreEquivalenceOracle;
26	import de.learnlib.api.oracle.MembershipOracle;
27	import de.learnlib.api.oracle.MembershipOracle.DFAMembershipOracle;
28	import de.learnlib.api.oracle.MembershipOracle.MealyMembershipOracle;
29	import de.learnlib.api.oracle.MembershipOracle.MooreMembershipOracle;
30	import de.learnlib.buildtool.refinement.annotation.GenerateRefinement;
31	import de.learnlib.buildtool.refinement.annotation.Generic;
32	import de.learnlib.buildtool.refinement.annotation.Interface;
33	import de.learnlib.buildtool.refinement.annotation.Map;
34	import net.automatalib.automata.concepts.Output;
35	import net.automatalib.automata.fsa.DFA;
36	import net.automatalib.automata.transducers.MealyMachine;
37	import net.automatalib.automata.transducers.MooreMachine;
38	import net.automatalib.commons.util.collections.CollectionsUtil;
39	import net.automatalib.words.Word;
40	import net.automatalib.words.WordBuilder;
41
42	@GenerateRefinement(name = "DFARandomWordsEQOracle",
43	generics = "I",
44	parentGenerics = {@Generic(clazz = DFA.class, generics = {"?", "I"}),
45	@Generic("I"),
46	@Generic(clazz = Boolean.class)},
47	parameterMapping = @Map(from = MembershipOracle.class,
48	to = DFAMembershipOracle.class,
49	withGenerics = "I"),
50	interfaces = @Interface(clazz = DFAEquivalenceOracle.class, generics = "I"))
51	@GenerateRefinement(name = "MealyRandomWordsEQOracle",
52	generics = {"I", "O"},
53	parentGenerics = {@Generic(clazz = MealyMachine.class, generics = {"?", "I", "?", "O"}),
54	@Generic("I"),
55	@Generic(clazz = Word.class, generics = "O")},
56	parameterMapping = @Map(from = MembershipOracle.class,
57	to = MealyMembershipOracle.class,
58	withGenerics = {"I", "O"}),
59	interfaces = @Interface(clazz = MealyEquivalenceOracle.class, generics = {"I", "O"}))
60	@GenerateRefinement(name = "MooreRandomWordsEQOracle",
61	generics = {"I", "O"},
62	parentGenerics = {@Generic(clazz = MooreMachine.class, generics = {"?", "I", "?", "O"}),
63	@Generic("I"),
64	@Generic(clazz = Word.class, generics = "O")},
65	parameterMapping = @Map(from = MembershipOracle.class,
66	to = MooreMembershipOracle.class,
67	withGenerics = {"I", "O"}),
68	interfaces = @Interface(clazz = MooreEquivalenceOracle.class, generics = {"I", "O"}))
69	public class RandomWordsEQOracle<A extends Output<I, D>, I, D> extends AbstractTestWordEQOracle<A, I, D> {
70
71	private final Random random;
72	private final int maxTests;
73	private final int minLength;
74	private final int maxLength;
75
76	public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle, int minLength, int maxLength, int maxTests) {
77	this(mqOracle, minLength, maxLength, maxTests, new Random());	×
78	}	×
79
80	public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle,
81	int minLength,
82	int maxLength,
83	int maxTests,
84	Random random) {
85	this(mqOracle, minLength, maxLength, maxTests, random, 1);	2✔
86	}	2✔
87
88	public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle,
89	int minLength,
90	int maxLength,
91	int maxTests,
92	Random random,
93	int batchSize) {
94	super(mqOracle, batchSize);	2✔
95	this.maxTests = maxTests;	2✔
96	this.minLength = minLength;	2✔
97	this.maxLength = maxLength;	2✔
98	this.random = random;	2✔
99	}	2✔
100
101	@Override
102	protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
103
104	final List<? extends I> symbolList = CollectionsUtil.randomAccessList(inputs);	2✔
105
106	return Stream.generate(() -> generateTestWord(symbolList, symbolList.size())).limit(maxTests);	2✔
107	}
108
109	private Word<I> generateTestWord(List<? extends I> symbolList, int numSyms) {
110
111	final int length = minLength + random.nextInt((maxLength - minLength) + 1);	2✔
112	final WordBuilder<I> result = new WordBuilder<>(length);	2✔
113
114	for (int j = 0; j < length; ++j) {	2✔
115	int symidx = random.nextInt(numSyms);	2✔
116	I sym = symbolList.get(symidx);	2✔
117	result.append(sym);	2✔
118	}
119
120	return result.toWord();	2✔
121	}
122	}

LearnLib / learnlib / 6433387082

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