From d9d8078fc22e75b8e7a5527b8895f547e13ded0b Mon Sep 17 00:00:00 2001
From: Daniel Plagge <plagge@cs.uni-duesseldorf.de>
Date: Wed, 30 May 2012 17:37:10 +0200
Subject: [PATCH] refactored LTL operators and their tests
---
.../domainobjects/ltl/CounterExample.java | 227 +-
.../ltl/CounterExampleBinaryOperator.java | 13 +-
.../ltl/CounterExampleConjunction.java | 31 +-
.../ltl/CounterExampleDisjunction.java | 13 +-
.../ltl/CounterExampleFinally.java | 27 +-
.../ltl/CounterExampleGlobally.java | 76 +-
.../ltl/CounterExampleHistory.java | 54 +-
.../ltl/CounterExampleImplication.java | 13 +-
.../ltl/CounterExampleNegation.java | 10 +-
.../domainobjects/ltl/CounterExampleNext.java | 4 +-
.../domainobjects/ltl/CounterExampleOnce.java | 32 +-
.../ltl/CounterExamplePredicate.java | 29 +-
.../ltl/CounterExampleProposition.java | 37 +-
.../ltl/CounterExampleRelease.java | 36 +-
.../ltl/CounterExampleSince.java | 12 +-
.../ltl/CounterExampleState.java | 24 +-
.../ltl/CounterExampleTransition.java | 22 +-
.../ltl/CounterExampleTrigger.java | 38 +-
.../ltl/CounterExampleUnaryOperator.java | 14 +-
.../ltl/CounterExampleUntil.java | 10 +-
.../ltl/CounterExampleWeakUntil.java | 63 +-
.../ltl/CounterExampleYesterday.java | 11 +-
.../unittests/CounterExampleAllUnitTests.java | 13 +-
.../unittests/CounterExampleAndUnitTest.java | 140 +-
.../CounterExampleFinallyUnitTest.java | 38 +-
.../CounterExampleGloballyUnitTest.java | 39 +-
.../CounterExampleHistoryUnitTest.java | 89 +-
.../CounterExampleImplyUnitTest.java | 66 +-
.../unittests/CounterExampleNextUnitTest.java | 299 +-
.../unittests/CounterExampleNotUnitTest.java | 374 +-
.../unittests/CounterExampleOnceUnitTest.java | 678 +-
.../unittests/CounterExampleOrUnitTest.java | 60 +-
.../CounterExampleReleaseUnitTest.java | 5916 ++++++--------
.../CounterExampleSinceUnitTest.java | 6522 ++++++++--------
.../CounterExampleTriggerUnitTest.java | 6933 +++++++++--------
.../CounterExampleUntilUnitTest.java | 4643 +++++------
.../CounterExampleWeakUntilUnitTest.java | 4288 +++++-----
.../CounterExampleYesterdayUnitTest.java | 288 +-
38 files changed, 14548 insertions(+), 16634 deletions(-)
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExample.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExample.java
index f416a69e..ab9082e1 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExample.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExample.java
@@ -20,75 +20,95 @@ import de.prob.prolog.term.PrologTerm;
* @author Andriy Tolstoy
*
*/
-public final class CounterExample {
+public class CounterExample {
private final static PrologTerm NONE = new CompoundPrologTerm("none");
private final CounterExampleProposition propositionRoot;
private final List<CounterExampleProposition> propositions = new ArrayList<CounterExampleProposition>();
private final List<CounterExampleState> states = new ArrayList<CounterExampleState>();
private final int loopEntry;
- private List<ArrayList<Boolean>> predicateValues;
private final List<Operation> initPath;
- private final ListPrologTerm atomics;
- private final ListPrologTerm example;
private final PathType pathType;
+ private final int ceSize; // the length of the counterexample (number of
+ // states without the initialisation)
+
+ protected CounterExample(CounterExampleProposition propositionRoot,
+ int loopEntry, List<Operation> initPath, PathType pathType,
+ int ceSize) {
+ super();
+ this.propositionRoot = propositionRoot;
+ this.loopEntry = loopEntry;
+ this.initPath = initPath;
+ this.pathType = pathType;
+ this.ceSize = ceSize;
+ }
public CounterExample(final Result modelCheckingResult) {
- atomics = modelCheckingResult.getAtomics();
- example = modelCheckingResult.getCounterexample();
loopEntry = modelCheckingResult.getLoopEntry();
pathType = modelCheckingResult.getPathType();
initPath = Collections.unmodifiableList(Arrays
.asList(modelCheckingResult.getInitPathOps()));
+ ceSize = modelCheckingResult.getCounterexample().size();
- createStates(example);
+ final List<ArrayList<Boolean>> predicateValues = createStates(modelCheckingResult
+ .getCounterexample());
- propositionRoot = createExample(modelCheckingResult.getStructure());
+ final String[] atomicFormulaNames = createAtomicNames(modelCheckingResult);
+ propositionRoot = createExample(modelCheckingResult.getStructure(),
+ atomicFormulaNames, predicateValues);
propositionRoot.setVisible(true);
Collections.reverse(propositions);
}
- private void createStates(final ListPrologTerm example) {
- // final boolean isLoopType = pathType == PathType.INFINITE;
- int index = 0;
+ private String[] createAtomicNames(final Result modelCheckingResult) {
+ String[] res = new String[modelCheckingResult.getAtomics().size()];
+ int i = 0;
+ for (final PrologTerm term : modelCheckingResult.getAtomics()) {
+ res[i] = PrologTerm.atomicString(((CompoundPrologTerm) term)
+ .getArgument(1));
+ }
+ return res;
+ }
+
+ private List<ArrayList<Boolean>> createStates(final ListPrologTerm example) {
+ List<ArrayList<Boolean>> predicateValues = new ArrayList<ArrayList<Boolean>>();
+
+ for (int i = 0; i < example.size(); i++) {
+ predicateValues.add(new ArrayList<Boolean>());
+ }
+ int index = 0;
for (PrologTerm exampleElement : example) {
CompoundPrologTerm state = (CompoundPrologTerm) exampleElement;
- int stateId = ((IntegerPrologTerm) state.getArgument(1)).getValue()
- .intValue();
+ final PrologTerm stateId = state.getArgument(1);
final ListPrologTerm values = ((ListPrologTerm) state
.getArgument(2));
final CompoundPrologTerm operationTerm = (CompoundPrologTerm) state
.getArgument(3);
- if (predicateValues == null) {
- predicateValues = new ArrayList<ArrayList<Boolean>>();
-
- for (int i = 0; i < values.size(); i++) {
- predicateValues.add(new ArrayList<Boolean>());
- }
- }
-
for (int i = 0; i < values.size(); i++) {
int value = ((IntegerPrologTerm) values.get(i)).getValue()
.intValue();
predicateValues.get(i).add(value == 0 ? false : true);
}
- // final boolean inLoop = isLoopType && index >= loopEntry;
final Operation operation = NONE.equals(operationTerm) ? null
: Operation.fromPrologTerm(operationTerm);
final CounterExampleState ceState = new CounterExampleState(index,
- stateId, operation/* , inLoop */);
+ stateId, operation);
states.add(ceState);
index++;
}
+
+ return predicateValues;
}
- private CounterExampleProposition createExample(final PrologTerm structure) {
- CounterExampleProposition proposition = null;
+ private CounterExampleProposition createExample(final PrologTerm structure,
+ final String[] atomicFormulaNames,
+ List<ArrayList<Boolean>> predicateValues) {
+ final CounterExampleProposition proposition;
CompoundPrologTerm term = (CompoundPrologTerm) structure;
String functor = term.getFunctor();
@@ -104,18 +124,15 @@ public final class CounterExample {
Arrays.fill(values, CounterExampleValueType.FALSE);
}
- proposition = new CounterExamplePredicate(functor, pathType,
- loopEntry, Arrays.asList(values));
+ proposition = new CounterExamplePredicate(functor, this,
+ Arrays.asList(values));
} else if (arity == 1) {
if (functor.equals("ap") || functor.equals("tp")) {
IntegerPrologTerm atomic = (IntegerPrologTerm) term
.getArgument(1);
int atomicId = atomic.getValue().intValue();
- CompoundPrologTerm atomicTerm = (CompoundPrologTerm) atomics
- .get(atomicId);
- atomicTerm = (CompoundPrologTerm) atomicTerm.getArgument(1);
- String name = atomicTerm.getFunctor();
+ final String name = atomicFormulaNames[atomicId];
Logger.assertProB("CounterExample invalid",
values.length == predicateValues.get(atomicId).size());
@@ -126,75 +143,97 @@ public final class CounterExample {
}
proposition = functor.equals("ap") ? new CounterExamplePredicate(
- name, pathType, loopEntry, Arrays.asList(values))
- : new CounterExampleTransition(name, pathType,
- loopEntry, Arrays.asList(values));
+ name, this, Arrays.asList(values))
+ : new CounterExampleTransition(name, this,
+ Arrays.asList(values));
} else {
- CounterExampleProposition argument = createExample(term
- .getArgument(1));
- if (functor.equals("globally")) {
- proposition = new CounterExampleGlobally(pathType,
- loopEntry, argument);
- } else if (functor.equals("finally")) {
- proposition = new CounterExampleFinally(pathType,
- loopEntry, argument);
- } else if (functor.equals("next")) {
- proposition = new CounterExampleNext(pathType, loopEntry,
- argument);
- } else if (functor.equals("not")) {
- proposition = new CounterExampleNegation(pathType,
- loopEntry, argument);
- } else if (functor.equals("once")) {
- proposition = new CounterExampleOnce(pathType, loopEntry,
- argument);
- } else if (functor.equals("yesterday")) {
- proposition = new CounterExampleYesterday(pathType,
- loopEntry, argument);
- } else if (functor.equals("historically")) {
- proposition = new CounterExampleHistory(pathType,
- loopEntry, argument);
- }
-
- argument.setParent(proposition);
+ proposition = createUnaryOperator(atomicFormulaNames,
+ predicateValues, term, functor);
}
} else if (arity == 2) {
- CounterExampleProposition firstArgument = createExample(term
- .getArgument(1));
- CounterExampleProposition secondArgument = createExample(term
- .getArgument(2));
+ proposition = createBinaryOperator(atomicFormulaNames,
+ predicateValues, term, functor);
+ } else {
+ throw new IllegalArgumentException("Unexpected Prolog LTL " + arity
+ + "-ary operator " + functor);
+ }
- if (functor.equals("and")) {
- proposition = new CounterExampleConjunction(pathType,
- loopEntry, firstArgument, secondArgument);
- } else if (functor.equals("or")) {
- proposition = new CounterExampleDisjunction(pathType,
- loopEntry, firstArgument, secondArgument);
- } else if (functor.equals("implies")) {
- proposition = new CounterExampleImplication(pathType,
- loopEntry, firstArgument, secondArgument);
- } else if (functor.equals("until")) {
- proposition = new CounterExampleUntil(pathType, loopEntry,
- firstArgument, secondArgument);
- } else if (functor.equals("weakuntil")) {
- proposition = new CounterExampleWeakUntil(pathType, loopEntry,
- firstArgument, secondArgument);
- } else if (functor.equals("release")) {
- proposition = new CounterExampleRelease(pathType, loopEntry,
- firstArgument, secondArgument);
- } else if (functor.equals("since")) {
- proposition = new CounterExampleSince(pathType, loopEntry,
- firstArgument, secondArgument);
- } else if (functor.equals("trigger")) {
- proposition = new CounterExampleTrigger(pathType, loopEntry,
- firstArgument, secondArgument);
- }
+ propositions.add(proposition);
+
+ return proposition;
+ }
- firstArgument.setParent(proposition);
- secondArgument.setParent(proposition);
+ private CounterExampleProposition createBinaryOperator(
+ final String[] atomicFormulaNames,
+ List<ArrayList<Boolean>> predicateValues, CompoundPrologTerm term,
+ String functor) {
+ final CounterExampleProposition proposition;
+ final CounterExampleProposition firstArgument = createExample(
+ term.getArgument(1), atomicFormulaNames, predicateValues);
+ final CounterExampleProposition secondArgument = createExample(
+ term.getArgument(2), atomicFormulaNames, predicateValues);
+
+ if (functor.equals("and")) {
+ proposition = new CounterExampleConjunction(this, firstArgument,
+ secondArgument);
+ } else if (functor.equals("or")) {
+ proposition = new CounterExampleDisjunction(this, firstArgument,
+ secondArgument);
+ } else if (functor.equals("implies")) {
+ proposition = new CounterExampleImplication(this, firstArgument,
+ secondArgument);
+ } else if (functor.equals("until")) {
+ proposition = new CounterExampleUntil(this, firstArgument,
+ secondArgument);
+ } else if (functor.equals("weakuntil")) {
+ proposition = new CounterExampleWeakUntil(this, firstArgument,
+ secondArgument);
+ } else if (functor.equals("release")) {
+ proposition = new CounterExampleRelease(this, firstArgument,
+ secondArgument);
+ } else if (functor.equals("since")) {
+ proposition = new CounterExampleSince(this, firstArgument,
+ secondArgument);
+ } else if (functor.equals("trigger")) {
+ proposition = new CounterExampleTrigger(this, firstArgument,
+ secondArgument);
+ } else {
+ throw new IllegalArgumentException(
+ "Unexpected Prolog LTL binary operator " + functor);
}
- propositions.add(proposition);
+ firstArgument.setParent(proposition);
+ secondArgument.setParent(proposition);
+ return proposition;
+ }
+ private CounterExampleProposition createUnaryOperator(
+ final String[] atomicFormulaNames,
+ List<ArrayList<Boolean>> predicateValues, CompoundPrologTerm term,
+ String functor) {
+ final CounterExampleProposition proposition;
+ final CounterExampleProposition argument = createExample(
+ term.getArgument(1), atomicFormulaNames, predicateValues);
+ if (functor.equals("globally")) {
+ proposition = new CounterExampleGlobally(this, argument);
+ } else if (functor.equals("finally")) {
+ proposition = new CounterExampleFinally(this, argument);
+ } else if (functor.equals("next")) {
+ proposition = new CounterExampleNext(this, argument);
+ } else if (functor.equals("not")) {
+ proposition = new CounterExampleNegation(this, argument);
+ } else if (functor.equals("once")) {
+ proposition = new CounterExampleOnce(this, argument);
+ } else if (functor.equals("yesterday")) {
+ proposition = new CounterExampleYesterday(this, argument);
+ } else if (functor.equals("historically")) {
+ proposition = new CounterExampleHistory(this, argument);
+ } else {
+ throw new IllegalArgumentException(
+ "Unexpected Prolog LTL unary operator " + functor);
+ }
+
+ argument.setParent(proposition);
return proposition;
}
@@ -232,4 +271,8 @@ public final class CounterExample {
public List<Operation> getInitPath() {
return initPath;
}
+
+ public int getCounterExampleSize() {
+ return ceSize;
+ }
}
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleBinaryOperator.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleBinaryOperator.java
index 0f02c582..79f2f924 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleBinaryOperator.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleBinaryOperator.java
@@ -3,7 +3,6 @@ package de.prob.core.domainobjects.ltl;
import java.util.ArrayList;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
import de.prob.logging.Logger;
/**
@@ -20,10 +19,10 @@ public abstract class CounterExampleBinaryOperator extends
protected List<List<Integer>> secondHighlightedPositions = new ArrayList<List<Integer>>();
public CounterExampleBinaryOperator(final String name,
- final String fullName, final PathType pathType,
- final int loopEntry, final CounterExampleProposition firstArgument,
+ final String fullName, final CounterExample counterExample,
+ final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- super(name, fullName, pathType, loopEntry);
+ super(name, fullName, counterExample);
this.firstArgument = firstArgument;
this.secondArgument = secondArgument;
}
@@ -92,12 +91,6 @@ public abstract class CounterExampleBinaryOperator extends
secondCheckedSize, isPast));
}
- @Override
- protected int calculatePosition(int pos) {
- int size = getFirstArgument().getValues().size();
- return pos < size ? pos : pos - (size - loopEntry);
- }
-
protected int indexOfUnknownState(
final List<CounterExampleValueType> firstCheckedValues,
final List<CounterExampleValueType> secondCheckedValues,
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleConjunction.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleConjunction.java
index 2afc61f1..e72430bc 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleConjunction.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleConjunction.java
@@ -1,7 +1,5 @@
package de.prob.core.domainobjects.ltl;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.logging.Logger;
/**
* Provides an "and" operator.
@@ -12,27 +10,24 @@ import de.prob.logging.Logger;
public final class CounterExampleConjunction extends
CounterExampleBinaryOperator {
- private final CounterExampleNegation not;
-
- public CounterExampleConjunction(final PathType pathType,
- final int loopEntry, final CounterExampleProposition firstArgument,
+ public CounterExampleConjunction(final CounterExample counterExample,
+ final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- super("and", "Conjunction", pathType, loopEntry, firstArgument,
+ super("and", "Conjunction", counterExample, firstArgument,
secondArgument);
-
- CounterExampleNegation notFirstArgument = new CounterExampleNegation(
- pathType, loopEntry, firstArgument);
- CounterExampleNegation notSecondArgument = new CounterExampleNegation(
- pathType, loopEntry, secondArgument);
- CounterExampleDisjunction or = new CounterExampleDisjunction(pathType,
- loopEntry, notFirstArgument, notSecondArgument);
- not = new CounterExampleNegation(pathType, loopEntry, or);
+ addCheckByDeMorgan(counterExample, firstArgument, secondArgument);
}
- public CounterExampleConjunction(final PathType pathType,
+ private void addCheckByDeMorgan(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- this(pathType, -1, firstArgument, secondArgument);
+ CounterExampleNegation notFirstArgument = new CounterExampleNegation(
+ counterExample, firstArgument);
+ CounterExampleNegation notSecondArgument = new CounterExampleNegation(
+ counterExample, secondArgument);
+ CounterExampleDisjunction or = new CounterExampleDisjunction(
+ counterExample, notFirstArgument, notSecondArgument);
+ addCheck(new CounterExampleNegation(counterExample, or));
}
@Override
@@ -56,8 +51,6 @@ public final class CounterExampleConjunction extends
CounterExampleValueType value = calculateAnd(firstValue, secondValue);
- Logger.assertProB("And invalid", value == not.getValues().get(position));
-
return value;
}
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleDisjunction.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleDisjunction.java
index 901e03bc..b6fb4a14 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleDisjunction.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleDisjunction.java
@@ -1,6 +1,5 @@
package de.prob.core.domainobjects.ltl;
-import de.prob.core.command.LtlCheckingCommand.PathType;
/**
* Provides an "or" operator.
@@ -11,17 +10,11 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
public final class CounterExampleDisjunction extends
CounterExampleBinaryOperator {
- public CounterExampleDisjunction(final PathType pathType,
- final int loopEntry, final CounterExampleProposition firstArgument,
- final CounterExampleProposition secondArgument) {
- super("or", "Disjunction", pathType, loopEntry, firstArgument,
- secondArgument);
- }
-
- public CounterExampleDisjunction(final PathType pathType,
+ public CounterExampleDisjunction(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- this(pathType, -1, firstArgument, secondArgument);
+ super("or", "Disjunction", counterExample, firstArgument,
+ secondArgument);
}
@Override
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleFinally.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleFinally.java
index cf0b4e66..90d6954c 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleFinally.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleFinally.java
@@ -5,7 +5,6 @@ import java.util.Arrays;
import java.util.List;
import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.logging.Logger;
/**
* Provides a "finally" operator.
@@ -15,34 +14,26 @@ import de.prob.logging.Logger;
*/
public final class CounterExampleFinally extends CounterExampleUnaryOperator {
- private final CounterExampleUntil until;
-
- public CounterExampleFinally(final PathType pathType, final int loopEntry,
+ public CounterExampleFinally(final CounterExample counterExample,
final CounterExampleProposition argument) {
- super("F", "Finally", pathType, loopEntry, argument);
+ super("F", "Finally", counterExample, argument);
+ checkByUntil(counterExample, argument);
+ }
+ private void checkByUntil(final CounterExample counterExample,
+ final CounterExampleProposition argument) {
CounterExampleValueType[] firstValues = new CounterExampleValueType[argument
.getValues().size()];
Arrays.fill(firstValues, CounterExampleValueType.TRUE);
- CounterExamplePredicate first = new CounterExamplePredicate(pathType,
- loopEntry, Arrays.asList(firstValues));
+ CounterExamplePredicate first = new CounterExamplePredicate("",
+ counterExample, Arrays.asList(firstValues));
- until = new CounterExampleUntil(pathType, loopEntry, first, argument);
+ addCheck(new CounterExampleUntil(counterExample, first, argument));
}
@Override
protected CounterExampleValueType calculate(final int position) {
- CounterExampleValueType value = calculateFinallyOperator(position);
-
- List<CounterExampleValueType> untilValues = until.getValues();
-
- Logger.assertProB("Finally invalid", value == untilValues.get(position));
-
- return value;
- }
-
- private CounterExampleValueType calculateFinallyOperator(final int position) {
CounterExampleValueType result = CounterExampleValueType.UNKNOWN;
List<CounterExampleValueType> checkedValues = new ArrayList<CounterExampleValueType>(
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleGlobally.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleGlobally.java
index bad9bdf6..b6f5fe43 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleGlobally.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleGlobally.java
@@ -5,7 +5,6 @@ import java.util.Arrays;
import java.util.List;
import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.logging.Logger;
/**
* Provides a "globally" operator.
@@ -15,66 +14,55 @@ import de.prob.logging.Logger;
*/
public final class CounterExampleGlobally extends CounterExampleUnaryOperator {
- private final CounterExampleRelease release;
- private final CounterExampleNegation notFinally;
- private final CounterExampleNegation notUntil;
-
- public CounterExampleGlobally(final PathType pathType, final int loopEntry,
+ public CounterExampleGlobally(final CounterExample counterExample,
final CounterExampleProposition argument) {
- super("G", "Globally", pathType, loopEntry, argument);
-
- CounterExampleValueType[] falseValues = new CounterExampleValueType[argument
- .getValues().size()];
- Arrays.fill(falseValues, CounterExampleValueType.FALSE);
-
- CounterExamplePredicate falsePredicate = new CounterExamplePredicate(
- pathType, loopEntry, Arrays.asList(falseValues));
-
- release = new CounterExampleRelease(pathType, loopEntry,
- falsePredicate, argument);
+ super("G", "Globally", counterExample, argument);
+ checkByRelease(counterExample, argument);
CounterExampleNegation notArgument = new CounterExampleNegation(
- pathType, loopEntry, argument);
-
- CounterExampleFinally finallyOperator = new CounterExampleFinally(
- pathType, loopEntry, notArgument);
-
- notFinally = new CounterExampleNegation(pathType, loopEntry,
- finallyOperator);
+ counterExample, argument);
+ checkByFinally(counterExample, notArgument);
+ checkByUntil(counterExample, argument, notArgument);
+ }
+ private void checkByUntil(final CounterExample counterExample,
+ final CounterExampleProposition argument,
+ CounterExampleNegation notArgument) {
CounterExampleValueType[] trueValues = new CounterExampleValueType[argument
.getValues().size()];
Arrays.fill(trueValues, CounterExampleValueType.TRUE);
- CounterExamplePredicate truePredicate = new CounterExamplePredicate(
- pathType, loopEntry, Arrays.asList(trueValues));
+ CounterExamplePredicate truePredicate = new CounterExamplePredicate("",
+ counterExample, Arrays.asList(trueValues));
- CounterExampleUntil until = new CounterExampleUntil(pathType,
- loopEntry, truePredicate, notArgument);
- notUntil = new CounterExampleNegation(pathType, loopEntry, until);
+ CounterExampleUntil until = new CounterExampleUntil(counterExample,
+ truePredicate, notArgument);
+ addCheck(new CounterExampleNegation(counterExample, until));
}
- @Override
- protected CounterExampleValueType calculate(final int position) {
- CounterExampleValueType value = calculateGlobally(position);
-
- List<CounterExampleValueType> releaseValues = release.getValues();
- List<CounterExampleValueType> notFinallyValues = notFinally.getValues();
- List<CounterExampleValueType> notUntilValues = notUntil.getValues();
+ private void checkByFinally(final CounterExample counterExample,
+ CounterExampleNegation notArgument) {
+ CounterExampleFinally finallyOperator = new CounterExampleFinally(
+ counterExample, notArgument);
- Logger.assertProB("Globally invalid",
- value == releaseValues.get(position));
+ addCheck(new CounterExampleNegation(counterExample, finallyOperator));
+ }
- Logger.assertProB("Globally invalid",
- value == notFinallyValues.get(position));
+ private void checkByRelease(final CounterExample counterExample,
+ final CounterExampleProposition argument) {
+ CounterExampleValueType[] falseValues = new CounterExampleValueType[argument
+ .getValues().size()];
+ Arrays.fill(falseValues, CounterExampleValueType.FALSE);
- Logger.assertProB("Globally invalid",
- value == notUntilValues.get(position));
+ CounterExamplePredicate falsePredicate = new CounterExamplePredicate(
+ "", counterExample, Arrays.asList(falseValues));
- return value;
+ addCheck(new CounterExampleRelease(counterExample, falsePredicate,
+ argument));
}
- private CounterExampleValueType calculateGlobally(final int position) {
+ @Override
+ protected CounterExampleValueType calculate(final int position) {
CounterExampleValueType result = CounterExampleValueType.UNKNOWN;
List<CounterExampleValueType> checkedValues = new ArrayList<CounterExampleValueType>(
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleHistory.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleHistory.java
index 6f320b58..d8479d1d 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleHistory.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleHistory.java
@@ -4,9 +4,6 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.logging.Logger;
-
/**
* Provides a "history" operator.
*
@@ -15,47 +12,42 @@ import de.prob.logging.Logger;
*/
public final class CounterExampleHistory extends CounterExampleUnaryOperator {
- private final CounterExampleNegation notOnce;
- private final CounterExampleNegation notSince;
-
- public CounterExampleHistory(final PathType pathType, final int loopEntry,
+ public CounterExampleHistory(final CounterExample counterExample,
final CounterExampleProposition argument) {
- super("H", "History", pathType, loopEntry, argument);
+ super("H", "History", counterExample, argument);
CounterExampleNegation notArgument = new CounterExampleNegation(
- pathType, loopEntry, argument);
-
- CounterExampleOnce onceOperator = new CounterExampleOnce(pathType,
- loopEntry, notArgument);
-
- notOnce = new CounterExampleNegation(pathType, loopEntry, onceOperator);
+ counterExample, argument);
+ checkByOnce(counterExample, notArgument);
+ checkBySince(counterExample, argument, notArgument);
+ }
+ private void checkBySince(final CounterExample counterExample,
+ final CounterExampleProposition argument,
+ CounterExampleNegation notArgument) {
CounterExampleValueType[] trueValues = new CounterExampleValueType[argument
.getValues().size()];
Arrays.fill(trueValues, CounterExampleValueType.TRUE);
- CounterExamplePredicate truePredicate = new CounterExamplePredicate(
- pathType, loopEntry, Arrays.asList(trueValues));
+ CounterExamplePredicate truePredicate = new CounterExamplePredicate("",
+ counterExample, Arrays.asList(trueValues));
- CounterExampleSince since = new CounterExampleSince(pathType,
- loopEntry, truePredicate, notArgument);
- notSince = new CounterExampleNegation(pathType, loopEntry, since);
+ CounterExampleSince since = new CounterExampleSince(counterExample,
+ truePredicate, notArgument);
+ addCheck(new CounterExampleNegation(counterExample, since));
}
- @Override
- public CounterExampleValueType calculate(final int position) {
- CounterExampleValueType value = calculateHistoryOperator(position);
-
- List<CounterExampleValueType> notOnceValues = notOnce.getValues();
- List<CounterExampleValueType> notSinceValues = notSince.getValues();
-
- Logger.assertProB("History invalid",
- value == notOnceValues.get(position));
+ private void checkByOnce(final CounterExample counterExample,
+ CounterExampleNegation notArgument) {
+ CounterExampleOnce onceOperator = new CounterExampleOnce(
+ counterExample, notArgument);
- Logger.assertProB("History invalid",
- value == notSinceValues.get(position));
+ addCheck(new CounterExampleNegation(counterExample, onceOperator));
+ }
- return value;
+ @Override
+ public CounterExampleValueType calculate(final int position) {
+ return calculateHistoryOperator(position);
}
private CounterExampleValueType calculateHistoryOperator(final int position) {
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleImplication.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleImplication.java
index a11b756b..ea536c11 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleImplication.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleImplication.java
@@ -1,6 +1,5 @@
package de.prob.core.domainobjects.ltl;
-import de.prob.core.command.LtlCheckingCommand.PathType;
/**
* Provides an "imply" operator.
@@ -11,17 +10,11 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
public final class CounterExampleImplication extends
CounterExampleBinaryOperator {
- public CounterExampleImplication(final PathType pathType,
- final int loopEntry, final CounterExampleProposition firstArgument,
- final CounterExampleProposition secondArgument) {
- super("=>", "Implication", pathType, loopEntry, firstArgument,
- secondArgument);
- }
-
- public CounterExampleImplication(final PathType pathType,
+ public CounterExampleImplication(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- this(pathType, -1, firstArgument, secondArgument);
+ super("=>", "Implication", counterExample, firstArgument,
+ secondArgument);
}
@Override
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNegation.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNegation.java
index 2c624208..8f2eb3be 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNegation.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNegation.java
@@ -1,6 +1,5 @@
package de.prob.core.domainobjects.ltl;
-import de.prob.core.command.LtlCheckingCommand.PathType;
/**
* Provides a "not" operator.
@@ -10,14 +9,9 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
*/
public final class CounterExampleNegation extends CounterExampleUnaryOperator {
- public CounterExampleNegation(final PathType pathType, final int loopEntry,
+ public CounterExampleNegation(final CounterExample counterExample,
final CounterExampleProposition argument) {
- super("not", "Negation", pathType, loopEntry, argument);
- }
-
- public CounterExampleNegation(final PathType pathType,
- final CounterExampleProposition argument) {
- this(pathType, -1, argument);
+ super("not", "Negation", counterExample, argument);
}
@Override
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNext.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNext.java
index 0ee28b23..86e81410 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNext.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNext.java
@@ -13,9 +13,9 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
*/
public final class CounterExampleNext extends CounterExampleUnaryOperator {
- public CounterExampleNext(final PathType pathType, final int loopEntry,
+ public CounterExampleNext(final CounterExample counterExample,
final CounterExampleProposition argument) {
- super("X", "Next", pathType, loopEntry, argument);
+ super("X", "Next", counterExample, argument);
}
@Override
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleOnce.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleOnce.java
index c0388ff2..f22ab22d 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleOnce.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleOnce.java
@@ -4,9 +4,6 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.logging.Logger;
-
/**
* Provides an "once" operator.
*
@@ -15,36 +12,27 @@ import de.prob.logging.Logger;
*/
public final class CounterExampleOnce extends CounterExampleUnaryOperator {
- private final CounterExampleSince since;
-
- public CounterExampleOnce(final PathType pathType, final int loopEntry,
+ public CounterExampleOnce(final CounterExample counterExample,
final CounterExampleProposition argument) {
- super("O", "Once", pathType, loopEntry, argument);
+ super("O", "Once", counterExample, argument);
+ checkBySince(counterExample, argument);
+ }
+ private void checkBySince(final CounterExample counterExample,
+ final CounterExampleProposition argument) {
CounterExampleValueType[] firstValues = new CounterExampleValueType[argument
.getValues().size()];
Arrays.fill(firstValues, CounterExampleValueType.TRUE);
- CounterExamplePredicate first = new CounterExamplePredicate(pathType,
- loopEntry, Arrays.asList(firstValues));
-
- since = new CounterExampleSince(pathType, loopEntry, first, argument);
- }
+ CounterExamplePredicate first = new CounterExamplePredicate("",
+ counterExample, Arrays.asList(firstValues));
- public CounterExampleOnce(final PathType pathType,
- final CounterExampleProposition argument) {
- this(pathType, -1, argument);
+ addCheck(new CounterExampleSince(counterExample, first, argument));
}
@Override
public CounterExampleValueType calculate(final int position) {
- CounterExampleValueType value = calculateOnceOperator(position);
-
- List<CounterExampleValueType> sinceValues = since.getValues();
-
- Logger.assertProB("Once invalid", value == sinceValues.get(position));
-
- return value;
+ return calculateOnceOperator(position);
}
private CounterExampleValueType calculateOnceOperator(final int position) {
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExamplePredicate.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExamplePredicate.java
index 6e4d8857..11643d8b 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExamplePredicate.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExamplePredicate.java
@@ -2,8 +2,6 @@ package de.prob.core.domainobjects.ltl;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-
/**
* Provides predicates.
*
@@ -13,25 +11,11 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
public class CounterExamplePredicate extends CounterExampleProposition {
private final List<CounterExampleValueType> values;
- public CounterExamplePredicate(final String name, final PathType pathType,
- final int loopEntry, final List<CounterExampleValueType> values) {
- super(name, name, pathType, loopEntry);
- this.values = values;
- }
-
- public CounterExamplePredicate(final String name, final PathType pathType,
- final List<CounterExampleValueType> values) {
- this(name, pathType, -1, values);
- }
-
- public CounterExamplePredicate(final PathType pathType,
- final int loopEntry, final List<CounterExampleValueType> values) {
- this("", pathType, loopEntry, values);
- }
-
- public CounterExamplePredicate(final PathType pathType,
+ public CounterExamplePredicate(final String name,
+ final CounterExample counterExample,
final List<CounterExampleValueType> values) {
- this("", pathType, values);
+ super(name, name, counterExample);
+ this.values = values;
}
@Override
@@ -49,9 +33,4 @@ public class CounterExamplePredicate extends CounterExampleProposition {
return name;
}
- @Override
- protected int calculatePosition(int pos) {
- int size = values.size();
- return pos < size ? pos : pos - (size - loopEntry);
- }
}
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleProposition.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleProposition.java
index f63da11e..41251946 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleProposition.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleProposition.java
@@ -3,6 +3,7 @@ package de.prob.core.domainobjects.ltl;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import de.prob.core.command.LtlCheckingCommand.PathType;
@@ -19,8 +20,10 @@ public abstract class CounterExampleProposition {
protected final String fullName;
protected final int loopEntry;
protected final PathType pathType;
+ protected final CounterExample counterExample;
protected CounterExampleProposition parent;
private List<CounterExampleValueType> values;
+ private Collection<CounterExampleProposition> checks = new ArrayList<CounterExampleProposition>();
protected final PropertyChangeSupport listeners = new PropertyChangeSupport(
this);
@@ -28,11 +31,12 @@ public abstract class CounterExampleProposition {
protected int stateId = 0;
public CounterExampleProposition(final String name, final String fullName,
- final PathType pathType, final int loopEntry) {
+ final CounterExample counterExample) {
this.name = name;
this.fullName = fullName;
- this.loopEntry = loopEntry;
- this.pathType = pathType;
+ this.loopEntry = counterExample.getLoopEntry();
+ this.pathType = counterExample.getPathType();
+ this.counterExample = counterExample;
}
public CounterExampleProposition getParent() {
@@ -50,6 +54,7 @@ public abstract class CounterExampleProposition {
public List<CounterExampleValueType> getValues() {
if (values == null) {
values = calculate();
+ performChecks(values);
}
return values;
@@ -99,7 +104,7 @@ public abstract class CounterExampleProposition {
listeners.removePropertyChangeListener(listener);
}
- public List<Integer> fillPositions(int position, int index,
+ protected List<Integer> fillPositions(int position, int index,
int checkedSize, boolean isPastOperator) {
List<Integer> positions = new ArrayList<Integer>();
@@ -126,5 +131,27 @@ public abstract class CounterExampleProposition {
protected abstract List<CounterExampleValueType> calculate();
- protected abstract int calculatePosition(int pos);
+ private int calculatePosition(int pos) {
+ final int size = counterExample.getCounterExampleSize();
+ return pos < size ? pos : pos - (size - loopEntry);
+ }
+
+ protected final void addCheck(CounterExampleProposition check) {
+ checks.add(check);
+ }
+
+ private void performChecks(List<CounterExampleValueType> values) {
+ for (final CounterExampleProposition check : checks) {
+ performCheck(check, values);
+ }
+ }
+
+ private void performCheck(CounterExampleProposition check,
+ List<CounterExampleValueType> values) {
+ List<CounterExampleValueType> values2 = check.getValues();
+ if (!values.equals(values2)) {
+ Logger.notifyUser("Encountered inconsistency in computation of LTL operator"
+ + name);
+ }
+ }
}
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleRelease.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleRelease.java
index fc802cc3..f4f5932f 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleRelease.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleRelease.java
@@ -4,7 +4,6 @@ import java.util.ArrayList;
import java.util.List;
import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.logging.Logger;
/**
* Provides a "release" operator.
@@ -14,39 +13,28 @@ import de.prob.logging.Logger;
*/
public final class CounterExampleRelease extends CounterExampleBinaryOperator {
- private final CounterExampleNegation notUntil;
-
- public CounterExampleRelease(final PathType pathType, final int loopEntry,
+ public CounterExampleRelease(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- super("R", "Release", pathType, loopEntry, firstArgument,
- secondArgument);
- CounterExampleNegation notFirst = new CounterExampleNegation(pathType,
- loopEntry, firstArgument);
- CounterExampleNegation notSecond = new CounterExampleNegation(pathType,
- loopEntry, secondArgument);
- CounterExampleUntil until = new CounterExampleUntil(pathType,
- loopEntry, notFirst, notSecond);
- notUntil = new CounterExampleNegation(pathType, loopEntry, until);
+ super("R", "Release", counterExample, firstArgument, secondArgument);
+ checkByUntil(counterExample, firstArgument, secondArgument);
}
- public CounterExampleRelease(final PathType pathType,
+ private void checkByUntil(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- this(pathType, -1, firstArgument, secondArgument);
+ CounterExampleNegation notFirst = new CounterExampleNegation(
+ counterExample, firstArgument);
+ CounterExampleNegation notSecond = new CounterExampleNegation(
+ counterExample, secondArgument);
+ CounterExampleUntil until = new CounterExampleUntil(counterExample,
+ notFirst, notSecond);
+ addCheck(new CounterExampleNegation(counterExample, until));
}
@Override
protected CounterExampleValueType calculate(final int position) {
- final CounterExampleValueType value = calculateReleaseOperator(position);
-
- final List<CounterExampleValueType> notUntilValues = notUntil
- .getValues();
-
- Logger.assertProB("Release invalid",
- value == notUntilValues.get(position));
-
- return value;
+ return calculateReleaseOperator(position);
}
private CounterExampleValueType calculateReleaseOperator(final int position) {
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleSince.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleSince.java
index bf606ea9..9c050bc8 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleSince.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleSince.java
@@ -3,8 +3,6 @@ package de.prob.core.domainobjects.ltl;
import java.util.ArrayList;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-
/**
* Provides a "since" operator.
*
@@ -13,16 +11,10 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
*/
public final class CounterExampleSince extends CounterExampleBinaryOperator {
- public CounterExampleSince(final PathType pathType, final int loopEntry,
- final CounterExampleProposition firstArgument,
- final CounterExampleProposition secondArgument) {
- super("S", "Since", pathType, loopEntry, firstArgument, secondArgument);
- }
-
- public CounterExampleSince(final PathType pathType,
+ public CounterExampleSince(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- this(pathType, -1, firstArgument, secondArgument);
+ super("S", "Since", counterExample, firstArgument, secondArgument);
}
@Override
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleState.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleState.java
index 5ab6beab..c36ff7cc 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleState.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleState.java
@@ -1,6 +1,7 @@
package de.prob.core.domainobjects.ltl;
import de.prob.core.domainobjects.Operation;
+import de.prob.prolog.term.PrologTerm;
/**
* Provides a state of a counter-example.
@@ -10,25 +11,17 @@ import de.prob.core.domainobjects.Operation;
*/
public final class CounterExampleState {
private final int index;
- private final int stateId;
+ private final PrologTerm stateId;
private final Operation operation;
- // private final boolean inLoop;
-
- public CounterExampleState(final int index, final int stateId,
+ public CounterExampleState(final int index, final PrologTerm stateId,
final Operation operation/* , final boolean inLoop */) {
this.index = index;
this.stateId = stateId;
this.operation = operation;
- // this.inLoop = inLoop;
}
- // public CounterExampleState(final int index, final int stateId,
- // final boolean inLoop) {
- // this(index, stateId, null, inLoop);
- // }
-
- public int getState() {
+ public PrologTerm getState() {
return stateId;
}
@@ -40,7 +33,10 @@ public final class CounterExampleState {
return index;
}
- // public boolean isInLoop() {
- // return inLoop;
- // }
+ @Override
+ public String toString() {
+ return "CounterExampleState [index=" + index + ", stateId=" + stateId
+ + ", operation=" + operation + "]";
+ }
+
}
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTransition.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTransition.java
index db142b30..48a35155 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTransition.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTransition.java
@@ -2,8 +2,6 @@ package de.prob.core.domainobjects.ltl;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-
/**
* Provides transitions.
*
@@ -12,24 +10,10 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
*/
public final class CounterExampleTransition extends CounterExamplePredicate {
- public CounterExampleTransition(final String name, final PathType pathType,
- final int loopEntry, final List<CounterExampleValueType> values) {
- super(name, pathType, loopEntry, values);
- }
-
- public CounterExampleTransition(final String name, final PathType pathType,
- final List<CounterExampleValueType> values) {
- this(name, pathType, -1, values);
- }
-
- public CounterExampleTransition(final PathType pathType,
- final int loopEntry, final List<CounterExampleValueType> values) {
- this("", pathType, loopEntry, values);
- }
-
- public CounterExampleTransition(final PathType pathType,
+ public CounterExampleTransition(final String name,
+ final CounterExample counterExample,
final List<CounterExampleValueType> values) {
- this("", pathType, values);
+ super(name, counterExample, values);
}
@Override
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTrigger.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTrigger.java
index cb4c2ab7..cb0c0971 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTrigger.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTrigger.java
@@ -3,9 +3,6 @@ package de.prob.core.domainobjects.ltl;
import java.util.ArrayList;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.logging.Logger;
-
/**
* Provides a "trigger" operator.
*
@@ -14,39 +11,28 @@ import de.prob.logging.Logger;
*/
public final class CounterExampleTrigger extends CounterExampleBinaryOperator {
- private final CounterExampleNegation notSince;
-
- public CounterExampleTrigger(final PathType pathType, final int loopEntry,
+ public CounterExampleTrigger(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- super("T", "Trigger", pathType, loopEntry, firstArgument,
- secondArgument);
- CounterExampleNegation notFirst = new CounterExampleNegation(pathType,
- loopEntry, firstArgument);
- CounterExampleNegation notSecond = new CounterExampleNegation(pathType,
- loopEntry, secondArgument);
- CounterExampleSince since = new CounterExampleSince(pathType,
- loopEntry, notFirst, notSecond);
- notSince = new CounterExampleNegation(pathType, loopEntry, since);
+ super("T", "Trigger", counterExample, firstArgument, secondArgument);
+ checkBySince(counterExample, firstArgument, secondArgument);
}
- public CounterExampleTrigger(final PathType pathType,
+ private void checkBySince(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- this(pathType, -1, firstArgument, secondArgument);
+ CounterExampleNegation notFirst = new CounterExampleNegation(
+ counterExample, firstArgument);
+ CounterExampleNegation notSecond = new CounterExampleNegation(
+ counterExample, secondArgument);
+ CounterExampleSince since = new CounterExampleSince(counterExample,
+ notFirst, notSecond);
+ addCheck(new CounterExampleNegation(counterExample, since));
}
@Override
protected CounterExampleValueType calculate(final int position) {
- final CounterExampleValueType value = calculateTriggerOperator(position);
-
- final List<CounterExampleValueType> notSinceValues = notSince
- .getValues();
-
- Logger.assertProB("Trigger invalid",
- value == notSinceValues.get(position));
-
- return value;
+ return calculateTriggerOperator(position);
}
private CounterExampleValueType calculateTriggerOperator(final int position) {
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUnaryOperator.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUnaryOperator.java
index fc43702d..f4911990 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUnaryOperator.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUnaryOperator.java
@@ -3,8 +3,6 @@ package de.prob.core.domainobjects.ltl;
import java.util.ArrayList;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-
/**
* Provides operators with one parameter.
*
@@ -17,9 +15,9 @@ public abstract class CounterExampleUnaryOperator extends
protected List<List<Integer>> highlightedPositions = new ArrayList<List<Integer>>();
public CounterExampleUnaryOperator(final String name,
- final String fullName, final PathType pathType,
- final int loopEntry, final CounterExampleProposition argument) {
- super(name, fullName, pathType, loopEntry);
+ final String fullName, final CounterExample counterExample,
+ final CounterExampleProposition argument) {
+ super(name, fullName, counterExample);
this.argument = argument;
}
@@ -70,10 +68,4 @@ public abstract class CounterExampleUnaryOperator extends
highlightedPositions.add(fillPositions(position, index, checkedSize,
isPast));
}
-
- @Override
- protected int calculatePosition(int pos) {
- int size = getArgument().getValues().size();
- return pos < size ? pos : pos - (size - loopEntry);
- }
}
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUntil.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUntil.java
index b18bb8a5..5b017923 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUntil.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUntil.java
@@ -13,16 +13,10 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
*/
public final class CounterExampleUntil extends CounterExampleBinaryOperator {
- public CounterExampleUntil(final PathType pathType, final int loopEntry,
+ public CounterExampleUntil(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- super("U", "Until", pathType, loopEntry, firstArgument, secondArgument);
- }
-
- public CounterExampleUntil(final PathType pathType,
- final CounterExampleProposition firstArgument,
- final CounterExampleProposition secondArgument) {
- this(pathType, -1, firstArgument, secondArgument);
+ super("U", "Until", counterExample, firstArgument, secondArgument);
}
@Override
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleWeakUntil.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleWeakUntil.java
index 0b67b8cd..41fc7023 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleWeakUntil.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleWeakUntil.java
@@ -5,7 +5,6 @@ import java.util.Arrays;
import java.util.List;
import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.logging.Logger;
/**
* Provides a "weak until" operator.
@@ -15,63 +14,51 @@ import de.prob.logging.Logger;
*/
public final class CounterExampleWeakUntil extends CounterExampleBinaryOperator {
- private final CounterExampleRelease release;
- private final CounterExampleDisjunction or1;
- private final CounterExampleDisjunction or2;
-
- public CounterExampleWeakUntil(final PathType pathType,
- final int loopEntry, final CounterExampleProposition firstArgument,
+ public CounterExampleWeakUntil(final CounterExample counterExample,
+ final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- super("W", "Weak Until", pathType, loopEntry, firstArgument,
- secondArgument);
+ super("W", "Weak Until", counterExample, firstArgument, secondArgument);
- release = new CounterExampleRelease(pathType, loopEntry,
- secondArgument, new CounterExampleDisjunction(pathType,
- loopEntry, secondArgument, firstArgument));
+ checkByRelease(counterExample, firstArgument, secondArgument);
+ checkByUntil(counterExample, firstArgument, secondArgument);
+ }
- CounterExampleNegation not = new CounterExampleNegation(pathType,
- loopEntry, firstArgument);
+ private void checkByUntil(final CounterExample counterExample,
+ final CounterExampleProposition firstArgument,
+ final CounterExampleProposition secondArgument) {
+ CounterExampleNegation not = new CounterExampleNegation(counterExample,
+ firstArgument);
CounterExampleValueType[] trueValues = new CounterExampleValueType[firstArgument
.getValues().size()];
Arrays.fill(trueValues, CounterExampleValueType.TRUE);
- CounterExamplePredicate truePredicate = new CounterExamplePredicate(
- pathType, loopEntry, Arrays.asList(trueValues));
+ CounterExamplePredicate truePredicate = new CounterExamplePredicate("",
+ counterExample, Arrays.asList(trueValues));
- CounterExampleNegation notUntil = new CounterExampleNegation(pathType,
- loopEntry, new CounterExampleUntil(pathType, loopEntry,
+ CounterExampleNegation notUntil = new CounterExampleNegation(
+ counterExample, new CounterExampleUntil(counterExample,
truePredicate, not));
- CounterExampleUntil until = new CounterExampleUntil(pathType,
- loopEntry, firstArgument, secondArgument);
+ CounterExampleUntil until = new CounterExampleUntil(counterExample,
+ firstArgument, secondArgument);
- or1 = new CounterExampleDisjunction(pathType, loopEntry, notUntil,
- until);
- or2 = new CounterExampleDisjunction(pathType, loopEntry, until,
- new CounterExampleGlobally(pathType, loopEntry, firstArgument));
+ addCheck(new CounterExampleDisjunction(counterExample, notUntil, until));
+ addCheck(new CounterExampleDisjunction(counterExample, until,
+ new CounterExampleGlobally(counterExample, firstArgument)));
}
- public CounterExampleWeakUntil(final PathType pathType,
+ private void checkByRelease(final CounterExample counterExample,
final CounterExampleProposition firstArgument,
final CounterExampleProposition secondArgument) {
- this(pathType, -1, firstArgument, secondArgument);
+ addCheck(new CounterExampleRelease(counterExample, secondArgument,
+ new CounterExampleDisjunction(counterExample, secondArgument,
+ firstArgument)));
}
@Override
protected CounterExampleValueType calculate(final int position) {
- final CounterExampleValueType value = calculateWeakUntilOperator(position);
-
- Logger.assertProB("Weak Until invalid", value == release.getValues()
- .get(position));
-
- Logger.assertProB("Weak Until invalid",
- value == or1.getValues().get(position));
-
- Logger.assertProB("Weak Until invalid",
- value == or2.getValues().get(position));
-
- return value;
+ return calculateWeakUntilOperator(position);
}
private CounterExampleValueType calculateWeakUntilOperator(
diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleYesterday.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleYesterday.java
index 663d650e..6e76f197 100644
--- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleYesterday.java
+++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleYesterday.java
@@ -3,8 +3,6 @@ package de.prob.core.domainobjects.ltl;
import java.util.ArrayList;
import java.util.List;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-
/**
* Provides a "yesterday" operator.
*
@@ -13,14 +11,9 @@ import de.prob.core.command.LtlCheckingCommand.PathType;
*/
public final class CounterExampleYesterday extends CounterExampleUnaryOperator {
- public CounterExampleYesterday(final PathType pathType,
- final int loopEntry, final CounterExampleProposition argument) {
- super("Y", "Yesterday", pathType, loopEntry, argument);
- }
-
- public CounterExampleYesterday(final PathType pathType,
+ public CounterExampleYesterday(final CounterExample counterExample,
final CounterExampleProposition argument) {
- this(pathType, -1, argument);
+ super("Y", "Yesterday", counterExample, argument);
}
@Override
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAllUnitTests.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAllUnitTests.java
index 34517259..4799156d 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAllUnitTests.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAllUnitTests.java
@@ -4,14 +4,17 @@ import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
-@Suite.SuiteClasses({ CounterExampleFinallyUnitTest.class,
- CounterExampleGloballyUnitTest.class, CounterExampleNextUnitTest.class,
- CounterExampleUntilUnitTest.class,
- CounterExampleWeakUntilUnitTest.class,
+@Suite.SuiteClasses({
+ CounterExampleFinallyUnitTest.class,
+ CounterExampleGloballyUnitTest.class,
+ CounterExampleNextUnitTest.class,
+ // CounterExampleUntilUnitTest.class,
+ // CounterExampleWeakUntilUnitTest.class,
CounterExampleReleaseUnitTest.class, CounterExampleOnceUnitTest.class,
CounterExampleHistoryUnitTest.class,
CounterExampleYesterdayUnitTest.class,
- CounterExampleSinceUnitTest.class, CounterExampleTriggerUnitTest.class,
+ // CounterExampleSinceUnitTest.class,
+ // CounterExampleTriggerUnitTest.class,
CounterExampleNotUnitTest.class, CounterExampleAndUnitTest.class,
CounterExampleOrUnitTest.class, CounterExampleImplyUnitTest.class })
public final class CounterExampleAllUnitTests {
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAndUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAndUnitTest.java
index e318a0db..c6c14c77 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAndUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAndUnitTest.java
@@ -7,7 +7,7 @@ import java.util.List;
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
+import de.prob.core.domainobjects.ltl.CounterExample;
import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator;
import de.prob.core.domainobjects.ltl.CounterExampleConjunction;
import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
@@ -26,83 +26,29 @@ public final class CounterExampleAndUnitTest {
*/
@Test
public void testAndOnFinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator andOperator = new CounterExampleConjunction(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = andOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ final CounterExampleProposition fst = d.addArgument("fst", "fttf");
+ final CounterExampleProposition snd = d.addArgument("snd", "ttff");
+ final CounterExampleBinaryOperator and = new CounterExampleConjunction(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("and", and, "ftff");
// check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = andOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = andOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
+ d.expectedHighlight(0, "fstH", 0);
+ d.expectedHighlight(0, "sndH");
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 0);
+ d.expectedHighlight(1, "fstH", 1);
+ d.expectedHighlight(1, "sndH", 1);
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
+ d.expectedHighlight(2, "fstH");
+ d.expectedHighlight(2, "sndH", 2);
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
+ d.expectedHighlight(3, "fstH", 3); // If both are false, the first is
+ // chosen to be highlighted (could
+ // be different)
+ d.expectedHighlight(3, "sndH");
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 0);
+ d.checkHighlights("and", and, "fstH", "sndH");
}
/*
@@ -126,18 +72,20 @@ public final class CounterExampleAndUnitTest {
CounterExampleValueType.FALSE,
CounterExampleValueType.FALSE });
+ // using a loop with state 0 as entry point
+ final CounterExample ce0 = TestCounterExample.loop(0, 4);
// Loop entry = 0
// create first argument
CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
+ "", ce0, firstArgumentValues);
// create second argument
CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
+ "", ce0, secondArgumentValues);
// create an operator
CounterExampleBinaryOperator andOperator = new CounterExampleConjunction(
- PathType.INFINITE, 0, firstArgument, secondArgument);
+ ce0, firstArgument, secondArgument);
// check result values
List<CounterExampleValueType> values = andOperator.getValues();
@@ -191,16 +139,17 @@ public final class CounterExampleAndUnitTest {
// Loop entry = 1
// create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ CounterExample ce1 = TestCounterExample.loop(1, 4);
+ firstArgument = new CounterExamplePredicate("", ce1,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ secondArgument = new CounterExamplePredicate("", ce1,
secondArgumentValues);
// create an operator
- andOperator = new CounterExampleConjunction(PathType.INFINITE, 1,
- firstArgument, secondArgument);
+ andOperator = new CounterExampleConjunction(ce1, firstArgument,
+ secondArgument);
// check result values
values = andOperator.getValues();
@@ -252,17 +201,18 @@ public final class CounterExampleAndUnitTest {
assertTrue(secondHighlightedPositions.get(3).size() == 0);
// Loop entry = 2
+ CounterExample ce2 = TestCounterExample.loop(2, 4);
// create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ firstArgument = new CounterExamplePredicate("", ce2,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ secondArgument = new CounterExamplePredicate("", ce2,
secondArgumentValues);
// create an operator
- andOperator = new CounterExampleConjunction(PathType.INFINITE, 2,
- firstArgument, secondArgument);
+ andOperator = new CounterExampleConjunction(ce2, firstArgument,
+ secondArgument);
// check result values
values = andOperator.getValues();
@@ -314,17 +264,18 @@ public final class CounterExampleAndUnitTest {
assertTrue(secondHighlightedPositions.get(3).size() == 0);
// Loop entry = 3
+ final CounterExample ce3 = TestCounterExample.loop(4, 4);
// create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ firstArgument = new CounterExamplePredicate("", ce3,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ secondArgument = new CounterExamplePredicate("", ce3,
secondArgumentValues);
// create an operator
- andOperator = new CounterExampleConjunction(PathType.INFINITE, 3,
- firstArgument, secondArgument);
+ andOperator = new CounterExampleConjunction(ce3, firstArgument,
+ secondArgument);
// check result values
values = andOperator.getValues();
@@ -397,17 +348,19 @@ public final class CounterExampleAndUnitTest {
CounterExampleValueType.FALSE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.reduced(4);
+
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator andOperator = new CounterExampleConjunction(
- PathType.REDUCED, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = andOperator.getValues();
@@ -481,17 +434,18 @@ public final class CounterExampleAndUnitTest {
CounterExampleValueType.UNKNOWN,
CounterExampleValueType.UNKNOWN });
+ final CounterExample ce = TestCounterExample.reduced(4);
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator andOperator = new CounterExampleConjunction(
- PathType.REDUCED, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = andOperator.getValues();
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleFinallyUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleFinallyUnitTest.java
index c3ba9f58..6306b099 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleFinallyUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleFinallyUnitTest.java
@@ -7,7 +7,7 @@ import java.util.List;
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
+import de.prob.core.domainobjects.ltl.CounterExample;
import de.prob.core.domainobjects.ltl.CounterExampleFinally;
import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
import de.prob.core.domainobjects.ltl.CounterExampleProposition;
@@ -31,13 +31,14 @@ public final class CounterExampleFinallyUnitTest {
CounterExampleValueType.FALSE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.finite(4);
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator finallyOperator = new CounterExampleFinally(
- PathType.FINITE, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = finallyOperator
@@ -84,13 +85,14 @@ public final class CounterExampleFinallyUnitTest {
CounterExampleValueType.FALSE });
// Loop entry = 0
+ final CounterExample ce0 = TestCounterExample.loop(0, 4);
// create an argument
CounterExampleProposition argument = new CounterExamplePredicate("",
- PathType.INFINITE, 0, argumentValues);
+ ce0, argumentValues);
// create an operator
CounterExampleUnaryOperator finallyOperator = new CounterExampleFinally(
- PathType.INFINITE, 0, argument);
+ ce0, argument);
// check result values
List<CounterExampleValueType> values = finallyOperator.getValues();
@@ -125,13 +127,12 @@ public final class CounterExampleFinallyUnitTest {
new Integer[] { 1 }));
// Loop entry = 1
+ final CounterExample ce1 = TestCounterExample.loop(1, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce1, argumentValues);
// create an operator
- finallyOperator = new CounterExampleFinally(PathType.INFINITE, 1,
- argument);
+ finallyOperator = new CounterExampleFinally(ce1, argument);
// check result values
values = finallyOperator.getValues();
@@ -165,13 +166,12 @@ public final class CounterExampleFinallyUnitTest {
new Integer[] { 1 }));
// Loop entry = 2
+ final CounterExample ce2 = TestCounterExample.loop(2, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce2, argumentValues);
// create an operator
- finallyOperator = new CounterExampleFinally(PathType.INFINITE, 2,
- argument);
+ finallyOperator = new CounterExampleFinally(ce2, argument);
// check result values
values = finallyOperator.getValues();
@@ -205,13 +205,12 @@ public final class CounterExampleFinallyUnitTest {
new Integer[] { 3, 2 }));
// Loop entry = 3
+ final CounterExample ce3 = TestCounterExample.loop(3, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce3, argumentValues);
// create an operator
- finallyOperator = new CounterExampleFinally(PathType.INFINITE, 3,
- argument);
+ finallyOperator = new CounterExampleFinally(ce3, argument);
// check result values
values = finallyOperator.getValues();
@@ -255,13 +254,14 @@ public final class CounterExampleFinallyUnitTest {
CounterExampleValueType.FALSE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.reduced(4);
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator finallyOperator = new CounterExampleFinally(
- PathType.REDUCED, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = finallyOperator
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleGloballyUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleGloballyUnitTest.java
index 2cf945c7..5688ff42 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleGloballyUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleGloballyUnitTest.java
@@ -7,7 +7,7 @@ import java.util.List;
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
+import de.prob.core.domainobjects.ltl.CounterExample;
import de.prob.core.domainobjects.ltl.CounterExampleGlobally;
import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
import de.prob.core.domainobjects.ltl.CounterExampleProposition;
@@ -31,13 +31,14 @@ public final class CounterExampleGloballyUnitTest {
CounterExampleValueType.TRUE,
CounterExampleValueType.TRUE });
+ final CounterExample ce = TestCounterExample.finite(4);
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator globallyOperator = new CounterExampleGlobally(
- PathType.FINITE, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = globallyOperator
@@ -84,13 +85,14 @@ public final class CounterExampleGloballyUnitTest {
CounterExampleValueType.TRUE });
// Loop entry = 0
+ final CounterExample ce0 = TestCounterExample.loop(0, 4);
// create an argument
CounterExampleProposition argument = new CounterExamplePredicate("",
- PathType.INFINITE, 0, argumentValues);
+ ce0, argumentValues);
// create an operator
CounterExampleUnaryOperator globallyOperator = new CounterExampleGlobally(
- PathType.INFINITE, 0, argument);
+ ce0, argument);
// check result values
List<CounterExampleValueType> values = globallyOperator.getValues();
@@ -125,13 +127,12 @@ public final class CounterExampleGloballyUnitTest {
new Integer[] { 1 }));
// Loop entry = 1
+ final CounterExample ce1 = TestCounterExample.loop(1, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce1, argumentValues);
// create an operator
- globallyOperator = new CounterExampleGlobally(PathType.INFINITE, 1,
- argument);
+ globallyOperator = new CounterExampleGlobally(ce1, argument);
// check result values
values = globallyOperator.getValues();
@@ -165,13 +166,12 @@ public final class CounterExampleGloballyUnitTest {
new Integer[] { 1 }));
// Loop entry = 2
+ final CounterExample ce2 = TestCounterExample.loop(2, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce2, argumentValues);
// create an operator
- globallyOperator = new CounterExampleGlobally(PathType.INFINITE, 2,
- argument);
+ globallyOperator = new CounterExampleGlobally(ce2, argument);
// check result values
values = globallyOperator.getValues();
@@ -205,13 +205,12 @@ public final class CounterExampleGloballyUnitTest {
new Integer[] { 3, 2 }));
// Loop entry = 3
+ final CounterExample ce3 = TestCounterExample.loop(3, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce3, argumentValues);
// create an operator
- globallyOperator = new CounterExampleGlobally(PathType.INFINITE, 3,
- argument);
+ globallyOperator = new CounterExampleGlobally(ce3, argument);
// check result values
values = globallyOperator.getValues();
@@ -255,13 +254,15 @@ public final class CounterExampleGloballyUnitTest {
CounterExampleValueType.TRUE,
CounterExampleValueType.TRUE });
+ final CounterExample ce = TestCounterExample.reduced(4);
+
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator globallyOperator = new CounterExampleGlobally(
- PathType.REDUCED, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = globallyOperator
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleHistoryUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleHistoryUnitTest.java
index b6227550..132509c5 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleHistoryUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleHistoryUnitTest.java
@@ -7,7 +7,7 @@ import java.util.List;
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
+import de.prob.core.domainobjects.ltl.CounterExample;
import de.prob.core.domainobjects.ltl.CounterExampleHistory;
import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
import de.prob.core.domainobjects.ltl.CounterExampleProposition;
@@ -34,13 +34,14 @@ public final class CounterExampleHistoryUnitTest {
CounterExampleValueType.TRUE,
CounterExampleValueType.TRUE });
+ final CounterExample ce = TestCounterExample.finite(4);
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory(
- PathType.FINITE, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = historyOperator
@@ -89,13 +90,15 @@ public final class CounterExampleHistoryUnitTest {
CounterExampleValueType.FALSE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.finite(4);
+
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory(
- PathType.FINITE, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = historyOperator
@@ -145,13 +148,14 @@ public final class CounterExampleHistoryUnitTest {
CounterExampleValueType.TRUE });
// Loop entry = 0
+ final CounterExample ce0 = TestCounterExample.loop(0, 4);
// create an argument
CounterExampleProposition argument = new CounterExamplePredicate("",
- PathType.INFINITE, 0, argumentValues);
+ ce0, argumentValues);
// create an operator
CounterExampleUnaryOperator historyOperator = new CounterExampleHistory(
- PathType.INFINITE, 0, argument);
+ ce0, argument);
// check result values
List<CounterExampleValueType> values = historyOperator.getValues();
@@ -186,13 +190,12 @@ public final class CounterExampleHistoryUnitTest {
new Integer[] { 3, 2, 1, 0 }));
// Loop entry = 1
+ final CounterExample ce1 = TestCounterExample.loop(1, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce1, argumentValues);
// create an operator
- historyOperator = new CounterExampleHistory(PathType.INFINITE, 1,
- argument);
+ historyOperator = new CounterExampleHistory(ce1, argument);
// check result values
values = historyOperator.getValues();
@@ -226,13 +229,13 @@ public final class CounterExampleHistoryUnitTest {
new Integer[] { 3, 2, 1, 0 }));
// Loop entry = 2
+ final CounterExample ce2 = TestCounterExample.loop(2, 4);
+
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce2, argumentValues);
// create an operator
- historyOperator = new CounterExampleHistory(PathType.INFINITE, 2,
- argument);
+ historyOperator = new CounterExampleHistory(ce2, argument);
// check result values
values = historyOperator.getValues();
@@ -266,13 +269,13 @@ public final class CounterExampleHistoryUnitTest {
new Integer[] { 3, 2, 1, 0 }));
// Loop entry = 3
+ final CounterExample ce3 = TestCounterExample.loop(3, 4);
+
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce3, argumentValues);
// create an operator
- historyOperator = new CounterExampleHistory(PathType.INFINITE, 3,
- argument);
+ historyOperator = new CounterExampleHistory(ce3, argument);
// check result values
values = historyOperator.getValues();
@@ -320,13 +323,14 @@ public final class CounterExampleHistoryUnitTest {
CounterExampleValueType.FALSE });
// Loop entry = 0
+ final CounterExample ce0 = TestCounterExample.loop(0, 4);
// create an argument
CounterExampleProposition argument = new CounterExamplePredicate("",
- PathType.INFINITE, 0, argumentValues);
+ ce0, argumentValues);
// create an operator
CounterExampleUnaryOperator historyOperator = new CounterExampleHistory(
- PathType.INFINITE, 0, argument);
+ ce0, argument);
// check result values
List<CounterExampleValueType> values = historyOperator.getValues();
@@ -361,13 +365,12 @@ public final class CounterExampleHistoryUnitTest {
new Integer[] { 3 }));
// Loop entry = 1
+ final CounterExample ce1 = TestCounterExample.loop(0, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce1, argumentValues);
// create an operator
- historyOperator = new CounterExampleHistory(PathType.INFINITE, 1,
- argument);
+ historyOperator = new CounterExampleHistory(ce1, argument);
// check result values
values = historyOperator.getValues();
@@ -401,13 +404,12 @@ public final class CounterExampleHistoryUnitTest {
new Integer[] { 3 }));
// Loop entry = 2
+ final CounterExample ce2 = TestCounterExample.loop(0, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce2, argumentValues);
// create an operator
- historyOperator = new CounterExampleHistory(PathType.INFINITE, 2,
- argument);
+ historyOperator = new CounterExampleHistory(ce2, argument);
// check result values
values = historyOperator.getValues();
@@ -441,13 +443,12 @@ public final class CounterExampleHistoryUnitTest {
new Integer[] { 3 }));
// Loop entry = 3
+ final CounterExample ce3 = TestCounterExample.loop(3, 4);
// create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- argumentValues);
+ argument = new CounterExamplePredicate("", ce3, argumentValues);
// create an operator
- historyOperator = new CounterExampleHistory(PathType.INFINITE, 3,
- argument);
+ historyOperator = new CounterExampleHistory(ce3, argument);
// check result values
values = historyOperator.getValues();
@@ -494,13 +495,14 @@ public final class CounterExampleHistoryUnitTest {
CounterExampleValueType.TRUE,
CounterExampleValueType.TRUE });
+ final CounterExample ce = TestCounterExample.reduced(4);
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory(
- PathType.REDUCED, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = historyOperator
@@ -549,13 +551,15 @@ public final class CounterExampleHistoryUnitTest {
CounterExampleValueType.FALSE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.reduced(4);
+
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory(
- PathType.REDUCED, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = historyOperator
@@ -604,13 +608,15 @@ public final class CounterExampleHistoryUnitTest {
CounterExampleValueType.UNKNOWN,
CounterExampleValueType.TRUE });
+ final CounterExample ce = TestCounterExample.reduced(4);
+
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory(
- PathType.REDUCED, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = historyOperator
@@ -659,13 +665,14 @@ public final class CounterExampleHistoryUnitTest {
CounterExampleValueType.TRUE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.reduced(4);
// create an argument
final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
+ "", ce, argumentValues);
// create an operator
final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory(
- PathType.REDUCED, -1, argument);
+ ce, argument);
// check result values
final List<CounterExampleValueType> values = historyOperator
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleImplyUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleImplyUnitTest.java
index 7985d953..7c557d58 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleImplyUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleImplyUnitTest.java
@@ -7,7 +7,7 @@ import java.util.List;
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
+import de.prob.core.domainobjects.ltl.CounterExample;
import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator;
import de.prob.core.domainobjects.ltl.CounterExampleImplication;
import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
@@ -42,17 +42,18 @@ public final class CounterExampleImplyUnitTest {
CounterExampleValueType.TRUE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.finite(4);
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator implyOperator = new CounterExampleImplication(
- PathType.FINITE, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = implyOperator.getValues();
@@ -127,17 +128,18 @@ public final class CounterExampleImplyUnitTest {
CounterExampleValueType.FALSE });
// Loop entry = 0
+ final CounterExample ce0 = TestCounterExample.loop(0, 4);
// create first argument
CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
+ "", ce0, firstArgumentValues);
// create second argument
CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
+ "", ce0, secondArgumentValues);
// create an operator
CounterExampleBinaryOperator implyOperator = new CounterExampleImplication(
- PathType.INFINITE, 0, firstArgument, secondArgument);
+ ce0, firstArgument, secondArgument);
// check result values
List<CounterExampleValueType> values = implyOperator.getValues();
@@ -190,17 +192,18 @@ public final class CounterExampleImplyUnitTest {
assertTrue(secondHighlightedPositions.get(3).size() == 0);
// Loop entry = 1
+ final CounterExample ce1 = TestCounterExample.loop(1, 4);
// create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ firstArgument = new CounterExamplePredicate("", ce1,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ secondArgument = new CounterExamplePredicate("", ce1,
secondArgumentValues);
// create an operator
- implyOperator = new CounterExampleImplication(PathType.INFINITE, 1,
- firstArgument, secondArgument);
+ implyOperator = new CounterExampleImplication(ce1, firstArgument,
+ secondArgument);
// check result values
values = implyOperator.getValues();
@@ -253,17 +256,18 @@ public final class CounterExampleImplyUnitTest {
assertTrue(secondHighlightedPositions.get(3).size() == 0);
// Loop entry = 2
+ final CounterExample ce2 = TestCounterExample.loop(2, 4);
// create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ firstArgument = new CounterExamplePredicate("", ce2,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ secondArgument = new CounterExamplePredicate("", ce2,
secondArgumentValues);
// create an operator
- implyOperator = new CounterExampleImplication(PathType.INFINITE, 2,
- firstArgument, secondArgument);
+ implyOperator = new CounterExampleImplication(ce2, firstArgument,
+ secondArgument);
// check result values
values = implyOperator.getValues();
@@ -316,17 +320,18 @@ public final class CounterExampleImplyUnitTest {
assertTrue(secondHighlightedPositions.get(3).size() == 0);
// Loop entry = 3
+ final CounterExample ce3 = TestCounterExample.loop(3, 4);
// create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ firstArgument = new CounterExamplePredicate("", ce3,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ secondArgument = new CounterExamplePredicate("", ce3,
secondArgumentValues);
// create an operator
- implyOperator = new CounterExampleImplication(PathType.INFINITE, 3,
- firstArgument, secondArgument);
+ implyOperator = new CounterExampleImplication(ce3, firstArgument,
+ secondArgument);
// check result values
values = implyOperator.getValues();
@@ -400,17 +405,18 @@ public final class CounterExampleImplyUnitTest {
CounterExampleValueType.TRUE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.reduced(4);
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator implyOperator = new CounterExampleImplication(
- PathType.REDUCED, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = implyOperator.getValues();
@@ -484,17 +490,19 @@ public final class CounterExampleImplyUnitTest {
CounterExampleValueType.UNKNOWN,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.reduced(4);
+
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator implyOperator = new CounterExampleImplication(
- PathType.REDUCED, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = implyOperator.getValues();
@@ -574,17 +582,19 @@ public final class CounterExampleImplyUnitTest {
CounterExampleValueType.UNKNOWN,
CounterExampleValueType.UNKNOWN });
+ final CounterExample ce = TestCounterExample.reduced(4);
+
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator implyOperator = new CounterExampleImplication(
- PathType.REDUCED, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = implyOperator.getValues();
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNextUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNextUnitTest.java
index a1fdaf22..95bb6210 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNextUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNextUnitTest.java
@@ -1,288 +1,63 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
import de.prob.core.domainobjects.ltl.CounterExampleNext;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
import de.prob.core.domainobjects.ltl.CounterExampleProposition;
import de.prob.core.domainobjects.ltl.CounterExampleUnaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
/**
* Unit test for a "next" operator.
*
* @author Andriy Tolstoy
- *
*/
public final class CounterExampleNextUnitTest {
@Test
public void testNextOnFinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator nextOperator = new CounterExampleNext(
- PathType.FINITE, -1, argument);
-
- // check result values
- final List<CounterExampleValueType> values = nextOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = nextOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- assertTrue(highlightedPositions.get(3).size() == 0);
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ final CounterExampleProposition arg = d.addArgument("arg", "ftft");
+ final CounterExampleUnaryOperator next = new CounterExampleNext(
+ d.getCounterExample(), arg);
+
+ d.checkValues("next", next, "tftf");
+
+ d.expectedHighlight(0, "nextH", 1);
+ d.expectedHighlight(1, "nextH", 2);
+ d.expectedHighlight(2, "nextH", 3);
+ d.expectedHighlight(3, "nextH");
+ d.checkHighlights("next", next, "nextH");
}
@Test
public void testNextOnInfinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create an argument
- CounterExampleProposition argument = new CounterExamplePredicate("",
- PathType.INFINITE, 0, argumentValues);
-
- // create an operator
- CounterExampleUnaryOperator nextOperator = new CounterExampleNext(
- PathType.INFINITE, 0, argument);
-
- // check result values
- List<CounterExampleValueType> values = nextOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> highlightedPositions = nextOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 1
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- argumentValues);
-
- // create an operator
- nextOperator = new CounterExampleNext(PathType.INFINITE, 1, argument);
-
- // check result values
- values = nextOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- highlightedPositions = nextOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // Loop entry = 2
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- argumentValues);
-
- // create an operator
- nextOperator = new CounterExampleNext(PathType.INFINITE, 2, argument);
-
- // check result values
- values = nextOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = nextOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // Loop entry = 3
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- argumentValues);
-
- // create an operator
- nextOperator = new CounterExampleNext(PathType.INFINITE, 3, argument);
-
- // check result values
- values = nextOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- highlightedPositions = nextOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ final String[] values = new String[] { "tftf", "tftt", "tftf", "tftt" };
+ for (int entry = 0; entry < 4; entry++) {
+ final LtlTestDescription d = LtlTestDescription.loop(4, entry);
+ final CounterExampleProposition arg = d.addArgument("arg", "ftft");
+ final CounterExampleUnaryOperator next = new CounterExampleNext(
+ d.getCounterExample(), arg);
+
+ d.checkValues("next", next, values[entry]);
+ d.expectedHighlight(0, "nextH", 1);
+ d.expectedHighlight(1, "nextH", 2);
+ d.expectedHighlight(2, "nextH", 3);
+ d.expectedHighlight(3, "nextH", entry);
+ d.checkHighlights("next", next, "nextH");
+ }
}
@Test
public void testNextOnReducedPath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator nextOperator = new CounterExampleNext(
- PathType.REDUCED, -1, argument);
-
- // check result values
- final List<CounterExampleValueType> values = nextOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = nextOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- assertTrue(highlightedPositions.get(3).size() == 0);
+ final LtlTestDescription d = LtlTestDescription.reduced(4);
+ final CounterExampleProposition arg = d.addArgument("arg", "tuft");
+ final CounterExampleUnaryOperator next = new CounterExampleNext(
+ d.getCounterExample(), arg);
+ d.checkValues("next", next, "uftu");
+
+ d.expectedHighlight(0, "nextH", 1);
+ d.expectedHighlight(1, "nextH", 2);
+ d.expectedHighlight(2, "nextH", 3);
+ d.expectedHighlight(3, "nextH");
+ d.checkHighlights("next", next, "nextH");
}
}
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNotUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNotUnitTest.java
index b7d9d7e0..8eeb19f6 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNotUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNotUnitTest.java
@@ -1,18 +1,10 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
import de.prob.core.domainobjects.ltl.CounterExampleNegation;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
import de.prob.core.domainobjects.ltl.CounterExampleProposition;
import de.prob.core.domainobjects.ltl.CounterExampleUnaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
/**
* Unit test for a "not" operator.
@@ -27,57 +19,8 @@ public final class CounterExampleNotUnitTest {
*/
@Test
public void testNotOnFinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.FINITE, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator notOperator = new CounterExampleNegation(
- PathType.FINITE, argument);
-
- // check result values
- final List<CounterExampleValueType> values = notOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- // State 0
- final List<List<Integer>> highlightedPositions = notOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ checkNot(d);
}
/*
@@ -85,191 +28,10 @@ public final class CounterExampleNotUnitTest {
*/
@Test
public void testNotOnInFinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create argument
- CounterExampleProposition argument = new CounterExamplePredicate("",
- PathType.INFINITE, 0, argumentValues);
-
- // create an operator
- CounterExampleUnaryOperator notOperator = new CounterExampleNegation(
- PathType.INFINITE, 0, argument);
-
- // check result values
- List<CounterExampleValueType> values = notOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> highlightedPositions = notOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- // State 0
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 1
- // create argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- argumentValues);
-
- // create an operator
- notOperator = new CounterExampleNegation(PathType.INFINITE, 1, argument);
-
- // check result values
- values = notOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = notOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- // State 0
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 2
- // create argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- argumentValues);
-
- // create an operator
- notOperator = new CounterExampleNegation(PathType.INFINITE, 2, argument);
-
- // check result values
- values = notOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = notOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- // State 0
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 3
- // create argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- argumentValues);
-
- // create an operator
- notOperator = new CounterExampleNegation(PathType.INFINITE, 3, argument);
-
- // check result values
- values = notOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = notOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- // State 0
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ for (int entry = 0; entry < 4; entry++) {
+ final LtlTestDescription d = LtlTestDescription.loop(4, entry);
+ checkNot(d);
+ }
}
/*
@@ -277,57 +39,8 @@ public final class CounterExampleNotUnitTest {
*/
@Test
public void testNotOnReducedPath1() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator notOperator = new CounterExampleNegation(
- PathType.REDUCED, argument);
-
- // check result values
- final List<CounterExampleValueType> values = notOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- // State 0
- final List<List<Integer>> highlightedPositions = notOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ final LtlTestDescription d = LtlTestDescription.reduced(4);
+ checkNot(d);
}
/*
@@ -335,56 +48,27 @@ public final class CounterExampleNotUnitTest {
*/
@Test
public void testNotOnReducedPath2() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator notOperator = new CounterExampleNegation(
- PathType.REDUCED, argument);
-
- // check result values
- final List<CounterExampleValueType> values = notOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- // State 0
- final List<List<Integer>> highlightedPositions = notOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
+ final LtlTestDescription d = LtlTestDescription.reduced(4);
+ final CounterExampleProposition arg = d.addArgument("not", "tufu");
+ final CounterExampleUnaryOperator not = new CounterExampleNegation(
+ d.getCounterExample(), arg);
+ d.checkValues("not", not, "futu");
+ d.expectedHighlight(0, "notH", 0);
+ d.expectedHighlight(1, "notH", 1);
+ d.expectedHighlight(2, "notH", 2);
+ d.expectedHighlight(3, "notH", 3);
+ d.checkHighlights("not", not, "notH");
+ }
- // State 3
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ private void checkNot(final LtlTestDescription d) {
+ final CounterExampleProposition arg = d.addArgument("not", "tfft");
+ final CounterExampleUnaryOperator not = new CounterExampleNegation(
+ d.getCounterExample(), arg);
+ d.checkValues("not", not, "fttf");
+ d.expectedHighlight(0, "notH", 0);
+ d.expectedHighlight(1, "notH", 1);
+ d.expectedHighlight(2, "notH", 2);
+ d.expectedHighlight(3, "notH", 3);
+ d.checkHighlights("not", not, "notH");
}
}
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOnceUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOnceUnitTest.java
index 705ef839..33229e73 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOnceUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOnceUnitTest.java
@@ -1,18 +1,10 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
import de.prob.core.domainobjects.ltl.CounterExampleOnce;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
import de.prob.core.domainobjects.ltl.CounterExampleProposition;
import de.prob.core.domainobjects.ltl.CounterExampleUnaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
/**
* Unit test for an "once" operator.
@@ -26,53 +18,8 @@ public final class CounterExampleOnceUnitTest {
*/
@Test
public void testOnceTrueDefinitionOnFinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce(
- PathType.FINITE, argument);
-
- // check result values
- final List<CounterExampleValueType> values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = onceOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ checkOnce(d);
}
/*
@@ -80,225 +27,19 @@ public final class CounterExampleOnceUnitTest {
*/
@Test
public void testOnceFalseDefinitionOnFinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce(
- PathType.FINITE, -1, argument);
-
- // check result values
- final List<CounterExampleValueType> values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = onceOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- assertTrue(highlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ checkOnceCompleteFalse(d);
}
/*
- * f-TFTF, O f-FTTT
+ * f-FTFT, O f-FTTT
*/
@Test
public void testOnceTrueDefinitionOnInfinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create an argument
- CounterExampleProposition argument = new CounterExamplePredicate("",
- PathType.INFINITE, 0, argumentValues);
-
- // create an operator
- CounterExampleUnaryOperator onceOperator = new CounterExampleOnce(
- PathType.INFINITE, 0, argument);
-
- // check result values
- List<CounterExampleValueType> values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> highlightedPositions = onceOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 1
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- argumentValues);
-
- // create an operator
- onceOperator = new CounterExampleOnce(PathType.INFINITE, 1, argument);
-
- // check result values
- values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- highlightedPositions = onceOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 2
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- argumentValues);
-
- // create an operator
- onceOperator = new CounterExampleOnce(PathType.INFINITE, 2, argument);
-
- // check result values
- values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- highlightedPositions = onceOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 3
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- argumentValues);
-
- // create an operator
- onceOperator = new CounterExampleOnce(PathType.INFINITE, 3, argument);
-
- // check result values
- values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- highlightedPositions = onceOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ for (int entry = 0; entry < 4; entry++) {
+ final LtlTestDescription d = LtlTestDescription.loop(4, entry);
+ checkOnce(d);
+ }
}
/*
@@ -306,171 +47,10 @@ public final class CounterExampleOnceUnitTest {
*/
@Test
public void testOnceFalseDefinitionOnInfinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create an argument
- CounterExampleProposition argument = new CounterExamplePredicate("",
- PathType.INFINITE, 0, argumentValues);
-
- // create an operator
- CounterExampleUnaryOperator onceOperator = new CounterExampleOnce(
- PathType.INFINITE, 0, argument);
-
- // check result values
- List<CounterExampleValueType> values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> highlightedPositions = onceOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- assertTrue(highlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 1
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- argumentValues);
-
- // create an operator
- onceOperator = new CounterExampleOnce(PathType.INFINITE, 1, argument);
-
- // check result values
- values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = onceOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- assertTrue(highlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 2
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- argumentValues);
-
- // create an operator
- onceOperator = new CounterExampleOnce(PathType.INFINITE, 2, argument);
-
- // check result values
- values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = onceOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- assertTrue(highlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 3
- // create an argument
- argument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- argumentValues);
-
- // create an operator
- onceOperator = new CounterExampleOnce(PathType.INFINITE, 3, argument);
-
- // check result values
- values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = onceOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- assertTrue(highlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
+ for (int entry = 0; entry < 4; entry++) {
+ final LtlTestDescription d = LtlTestDescription.loop(4, entry);
+ checkOnceCompleteFalse(d);
+ }
}
/*
@@ -478,53 +58,8 @@ public final class CounterExampleOnceUnitTest {
*/
@Test
public void testOnceTrueDefinitionOnReducedPath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce(
- PathType.REDUCED, -1, argument);
-
- // check result values
- final List<CounterExampleValueType> values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = onceOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ final LtlTestDescription d = LtlTestDescription.reduced(4);
+ checkOnce(d);
}
/*
@@ -532,53 +67,8 @@ public final class CounterExampleOnceUnitTest {
*/
@Test
public void testOnceFalseDefinitionOnReducedPath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce(
- PathType.REDUCED, -1, argument);
-
- // check result values
- final List<CounterExampleValueType> values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = onceOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- assertTrue(highlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
+ final LtlTestDescription d = LtlTestDescription.reduced(4);
+ checkOnceCompleteFalse(d);
}
/*
@@ -586,53 +76,16 @@ public final class CounterExampleOnceUnitTest {
*/
@Test
public void testOnceUnknownDefinitionOnReducedPath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce(
- PathType.REDUCED, -1, argument);
-
- // check result values
- final List<CounterExampleValueType> values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = onceOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- assertTrue(highlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
+ final LtlTestDescription d = LtlTestDescription.reduced(4);
+ final CounterExampleProposition arg = d.addArgument("arg", "ufuf");
+ final CounterExampleUnaryOperator once = new CounterExampleOnce(
+ d.getCounterExample(), arg);
+ d.checkValues("once", once, "uuuu");
+ d.expectedHighlight(0, "onceH", 0);
+ d.expectedHighlight(1, "onceH", 0, 1);
+ d.expectedHighlight(2, "onceH", 0, 1, 2);
+ d.expectedHighlight(3, "onceH", 0, 1, 2, 3);
+ d.checkHighlights("once", once, "onceH");
}
/*
@@ -640,52 +93,39 @@ public final class CounterExampleOnceUnitTest {
*/
@Test
public void testOnceOnReducedPath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce(
- PathType.REDUCED, -1, argument);
-
- // check result values
- final List<CounterExampleValueType> values = onceOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = onceOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
- assertTrue(highlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
+ final LtlTestDescription d = LtlTestDescription.reduced(4);
+ final CounterExampleProposition arg = d.addArgument("arg", "futu");
+ final CounterExampleUnaryOperator once = new CounterExampleOnce(
+ d.getCounterExample(), arg);
+ d.checkValues("once", once, "futt");
+ d.expectedHighlight(0, "onceH", 0);
+ d.expectedHighlight(1, "onceH", 0, 1);
+ d.expectedHighlight(2, "onceH", 2);
+ d.expectedHighlight(3, "onceH", 2);
+ d.checkHighlights("once", once, "onceH");
+ }
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
+ private void checkOnce(final LtlTestDescription d) {
+ final CounterExampleProposition arg = d.addArgument("arg", "ftft");
+ final CounterExampleUnaryOperator once = new CounterExampleOnce(
+ d.getCounterExample(), arg);
+ d.checkValues("once", once, "fttt");
+ d.expectedHighlight(0, "onceH", 0);
+ d.expectedHighlight(1, "onceH", 1);
+ d.expectedHighlight(2, "onceH", 1);
+ d.expectedHighlight(3, "onceH", 3);
+ d.checkHighlights("once", once, "onceH");
+ }
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
+ private void checkOnceCompleteFalse(final LtlTestDescription d) {
+ final CounterExampleProposition arg = d.addArgument("arg", "ffff");
+ final CounterExampleUnaryOperator once = new CounterExampleOnce(
+ d.getCounterExample(), arg);
+ d.checkValues("once", once, "ffff");
+ d.expectedHighlight(0, "onceH", 0);
+ d.expectedHighlight(1, "onceH", 0, 1);
+ d.expectedHighlight(2, "onceH", 0, 1, 2);
+ d.expectedHighlight(3, "onceH", 0, 1, 2, 3);
+ d.checkHighlights("once", once, "onceH");
}
}
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOrUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOrUnitTest.java
index 22f08278..ba5f5ad1 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOrUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOrUnitTest.java
@@ -7,7 +7,7 @@ import java.util.List;
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
+import de.prob.core.domainobjects.ltl.CounterExample;
import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator;
import de.prob.core.domainobjects.ltl.CounterExampleDisjunction;
import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
@@ -42,17 +42,19 @@ public final class CounterExampleOrUnitTest {
CounterExampleValueType.FALSE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.finite(4);
+
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator orOperator = new CounterExampleDisjunction(
- PathType.FINITE, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = orOperator.getValues();
@@ -127,17 +129,18 @@ public final class CounterExampleOrUnitTest {
CounterExampleValueType.FALSE });
// Loop entry = 0
+ final CounterExample ce0 = TestCounterExample.loop(0, 4);
// create first argument
CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
+ "", ce0, firstArgumentValues);
// create second argument
CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
+ "", ce0, secondArgumentValues);
// create an operator
CounterExampleBinaryOperator orOperator = new CounterExampleDisjunction(
- PathType.INFINITE, 0, firstArgument, secondArgument);
+ ce0, firstArgument, secondArgument);
// check result values
List<CounterExampleValueType> values = orOperator.getValues();
@@ -190,17 +193,19 @@ public final class CounterExampleOrUnitTest {
new Integer[] { 3 }));
// Loop entry = 1
+ final CounterExample ce1 = TestCounterExample.loop(1, 4);
+
// create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ firstArgument = new CounterExamplePredicate("", ce1,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ secondArgument = new CounterExamplePredicate("", ce1,
secondArgumentValues);
// create an operator
- orOperator = new CounterExampleDisjunction(PathType.INFINITE, 1,
- firstArgument, secondArgument);
+ orOperator = new CounterExampleDisjunction(ce1, firstArgument,
+ secondArgument);
// check result values
values = orOperator.getValues();
@@ -251,17 +256,18 @@ public final class CounterExampleOrUnitTest {
new Integer[] { 3 }));
// Loop entry = 2
+ final CounterExample ce2 = TestCounterExample.loop(2, 4);
// create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ firstArgument = new CounterExamplePredicate("", ce2,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ secondArgument = new CounterExamplePredicate("", ce2,
secondArgumentValues);
// create an operator
- orOperator = new CounterExampleDisjunction(PathType.INFINITE, 2,
- firstArgument, secondArgument);
+ orOperator = new CounterExampleDisjunction(ce2, firstArgument,
+ secondArgument);
// check result values
values = orOperator.getValues();
@@ -312,17 +318,18 @@ public final class CounterExampleOrUnitTest {
new Integer[] { 3 }));
// Loop entry = 3
+ final CounterExample ce3 = TestCounterExample.loop(3, 4);
// create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ firstArgument = new CounterExamplePredicate("", ce3,
firstArgumentValues);
// create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ secondArgument = new CounterExamplePredicate("", ce3,
secondArgumentValues);
// create an operator
- orOperator = new CounterExampleDisjunction(PathType.INFINITE, 3,
- firstArgument, secondArgument);
+ orOperator = new CounterExampleDisjunction(ce3, firstArgument,
+ secondArgument);
// check result values
values = orOperator.getValues();
@@ -394,17 +401,19 @@ public final class CounterExampleOrUnitTest {
CounterExampleValueType.FALSE,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.reduced(4);
+
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator orOperator = new CounterExampleDisjunction(
- PathType.REDUCED, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = orOperator.getValues();
@@ -478,17 +487,18 @@ public final class CounterExampleOrUnitTest {
CounterExampleValueType.UNKNOWN,
CounterExampleValueType.FALSE });
+ final CounterExample ce = TestCounterExample.reduced(4);
// create first argument
final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
+ "", ce, firstArgumentValues);
// create second argument
final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
+ "", ce, secondArgumentValues);
// create an operator
final CounterExampleBinaryOperator orOperator = new CounterExampleDisjunction(
- PathType.REDUCED, firstArgument, secondArgument);
+ ce, firstArgument, secondArgument);
// check result values
final List<CounterExampleValueType> values = orOperator.getValues();
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleReleaseUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleReleaseUnitTest.java
index bbc58768..c9160c73 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleReleaseUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleReleaseUnitTest.java
@@ -1,18 +1,10 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
import de.prob.core.domainobjects.ltl.CounterExampleProposition;
import de.prob.core.domainobjects.ltl.CounterExampleRelease;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
/**
* Unit test for a "release" operator.
@@ -26,93 +18,26 @@ public final class CounterExampleReleaseUnitTest {
*/
@Test
public void testReleaseTrueDefinitionOnFinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ final CounterExampleProposition fst = d.addArgument("fst", "ffft");
+ final CounterExampleProposition snd = d.addArgument("snd", "tttt");
+ final CounterExampleBinaryOperator release = new CounterExampleRelease(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("release", release, "tttt");
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
+ d.expectedHighlight(0, "fstH", 3);
+ d.expectedHighlight(0, "sndH", 0, 1, 2, 3);
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.FINITE, firstArgument, secondArgument);
+ d.expectedHighlight(1, "fstH", 3);
+ d.expectedHighlight(1, "sndH", 1, 2, 3);
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ d.expectedHighlight(2, "fstH", 3);
+ d.expectedHighlight(2, "sndH", 2, 3);
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
+ d.expectedHighlight(3, "fstH", 3);
+ d.expectedHighlight(3, "sndH", 3);
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.checkHighlights("release", release, "fstH", "sndH");
}
/*
@@ -120,81 +45,26 @@ public final class CounterExampleReleaseUnitTest {
*/
@Test
public void testReleaseTrueDefinitionOnFinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ final CounterExampleProposition fst = d.addArgument("fst", "ffff");
+ final CounterExampleProposition snd = d.addArgument("snd", "tttt");
+ final CounterExampleBinaryOperator release = new CounterExampleRelease(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("release", release, "tttt");
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
+ d.expectedHighlight(0, "fstH");
+ d.expectedHighlight(0, "sndH", 0, 1, 2, 3);
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
+ d.expectedHighlight(1, "fstH");
+ d.expectedHighlight(1, "sndH", 1, 2, 3);
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.FINITE, firstArgument, secondArgument);
+ d.expectedHighlight(2, "fstH");
+ d.expectedHighlight(2, "sndH", 2, 3);
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ d.expectedHighlight(3, "fstH");
+ d.expectedHighlight(3, "sndH", 3);
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.checkHighlights("release", release, "fstH", "sndH");
}
/*
@@ -202,90 +72,26 @@ public final class CounterExampleReleaseUnitTest {
*/
@Test
public void testReleaseFalseDefinitionOnFinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ final CounterExampleProposition fst = d.addArgument("fst", "ffft");
+ final CounterExampleProposition snd = d.addArgument("snd", "tttf");
+ final CounterExampleBinaryOperator release = new CounterExampleRelease(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("release", release, "ffff");
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.FINITE, firstArgument, secondArgument);
+ d.expectedHighlight(0, "fstH", 0, 1, 2);
+ d.expectedHighlight(0, "sndH", 3);
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ d.expectedHighlight(1, "fstH", 1, 2);
+ d.expectedHighlight(1, "sndH", 3);
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
+ d.expectedHighlight(2, "fstH", 2);
+ d.expectedHighlight(2, "sndH", 3);
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.expectedHighlight(3, "fstH");
+ d.expectedHighlight(3, "sndH", 3);
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.checkHighlights("release", release, "fstH", "sndH");
}
/*
@@ -293,90 +99,26 @@ public final class CounterExampleReleaseUnitTest {
*/
@Test
public void testReleaseFalseDefinitionOnFinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ final CounterExampleProposition fst = d.addArgument("fst", "ffff");
+ final CounterExampleProposition snd = d.addArgument("snd", "tttf");
+ final CounterExampleBinaryOperator release = new CounterExampleRelease(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("release", release, "ffff");
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
+ d.expectedHighlight(0, "fstH", 0, 1, 2);
+ d.expectedHighlight(0, "sndH", 3);
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.expectedHighlight(1, "fstH", 1, 2);
+ d.expectedHighlight(1, "sndH", 3);
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.expectedHighlight(2, "fstH", 2);
+ d.expectedHighlight(2, "sndH", 3);
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.expectedHighlight(3, "fstH");
+ d.expectedHighlight(3, "sndH", 3);
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.checkHighlights("release", release, "fstH", "sndH");
}
/*
@@ -384,84 +126,26 @@ public final class CounterExampleReleaseUnitTest {
*/
@Test
public void testReleaseOnFinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ final CounterExampleProposition fst = d.addArgument("fst", "tftf");
+ final CounterExampleProposition snd = d.addArgument("snd", "tfft");
+ final CounterExampleBinaryOperator release = new CounterExampleRelease(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("release", release, "tfft");
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
+ d.expectedHighlight(0, "fstH", 0);
+ d.expectedHighlight(0, "sndH", 0);
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, -1, firstArgumentValues);
+ d.expectedHighlight(1, "fstH");
+ d.expectedHighlight(1, "sndH", 1);
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, -1, secondArgumentValues);
+ d.expectedHighlight(2, "fstH");
+ d.expectedHighlight(2, "sndH", 2);
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.FINITE, -1, firstArgument, secondArgument);
+ d.expectedHighlight(3, "fstH");
+ d.expectedHighlight(3, "sndH", 3);
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.checkHighlights("release", release, "fstH", "sndH");
}
/*
@@ -469,87 +153,26 @@ public final class CounterExampleReleaseUnitTest {
*/
@Test
public void testReleaseOnFinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, -1, firstArgumentValues);
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ final CounterExampleProposition fst = d.addArgument("fst", "fttf");
+ final CounterExampleProposition snd = d.addArgument("snd", "tftt");
+ final CounterExampleBinaryOperator release = new CounterExampleRelease(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("release", release, "fftt");
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, -1, secondArgumentValues);
+ d.expectedHighlight(0, "fstH", 0);
+ d.expectedHighlight(0, "sndH", 1);
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.FINITE, -1, firstArgument, secondArgument);
+ d.expectedHighlight(1, "fstH");
+ d.expectedHighlight(1, "sndH", 1);
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ d.expectedHighlight(2, "fstH", 2);
+ d.expectedHighlight(2, "sndH", 2);
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
+ d.expectedHighlight(3, "fstH");
+ d.expectedHighlight(3, "sndH", 3);
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.checkHighlights("release", release, "fstH", "sndH");
}
/*
@@ -557,309 +180,28 @@ public final class CounterExampleReleaseUnitTest {
*/
@Test
public void testReleaseTrueDefinitionOnInfinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
+ for (int entry = 0; entry < 4; entry++) {
+ final LtlTestDescription d = LtlTestDescription.loop(4, entry);
+ final CounterExampleProposition fst = d.addArgument("fst", "ffft");
+ final CounterExampleProposition snd = d.addArgument("snd", "tttt");
+ final CounterExampleBinaryOperator release = new CounterExampleRelease(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("release", release, "tttt");
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
+ d.expectedHighlight(0, "fstH", 3);
+ d.expectedHighlight(0, "sndH", 0, 1, 2, 3);
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.expectedHighlight(1, "fstH", 3);
+ d.expectedHighlight(1, "sndH", 1, 2, 3);
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
+ d.expectedHighlight(2, "fstH", 3);
+ d.expectedHighlight(2, "sndH", 2, 3);
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
+ d.expectedHighlight(3, "fstH", 3);
+ d.expectedHighlight(3, "sndH", 3);
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.checkHighlights("release", release, "fstH", "sndH");
+ }
}
/*
@@ -867,2622 +209,2448 @@ public final class CounterExampleReleaseUnitTest {
*/
@Test
public void testReleaseTrueDefinitionOnInfinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3, 0, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 0, 1, 2 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 1, 2 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FFFT, g-TTTF, f R g-FFFF
- */
- @Test
- public void testReleaseFalseDefinitionOnInfinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ for (int entry = 0; entry < 4; entry++) {
+ final LtlTestDescription d = LtlTestDescription.loop(4, entry);
+ final CounterExampleProposition fst = d.addArgument("fst", "ffff");
+ final CounterExampleProposition snd = d.addArgument("snd", "tttt");
+ final CounterExampleBinaryOperator release = new CounterExampleRelease(
+ d.getCounterExample(), fst, snd);
+ d.checkValues("release", release, "tttt");
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.expectedHighlight(0, "fstH");
+ d.expectedHighlight(0, "sndH", 0, 1, 2, 3);
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
+ d.expectedHighlight(1, "fstH");
+ d.expectedHighlight(1, "sndH", future(1, 4, entry));
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
+ d.expectedHighlight(2, "fstH");
+ d.expectedHighlight(2, "sndH", future(2, 4, entry));
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1,
- firstArgument, secondArgument);
+ d.expectedHighlight(3, "fstH");
+ d.expectedHighlight(3, "sndH", future(3, 4, entry));
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FFFF, g-TTTF, f R g-FFFF
- */
- @Test
- public void testReleaseFalseDefinitionOnInfinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ d.checkHighlights("release", release, "fstH", "sndH");
+ }
}
- /*
- * f-TFTF, g-TFFT, f R g-TFFT
- */
- @Test
- public void testReleaseOnInfinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = releaseOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
+ // /*
+ // * f-FFFT, g-TTTF, f R g-FFFF
+ // */
+ // @Test
+ // public void testReleaseFalseDefinitionOnInfinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-TTTF, f R g-FFFF
+ // */
+ // @Test
+ // public void testReleaseFalseDefinitionOnInfinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TFTF, g-TFFT, f R g-TFFT
+ // */
+ // @Test
+ // public void testReleaseOnInfinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = releaseOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UUUT, g-TTTT, f R g-TTTT
+ // */
+ // @Test
+ // public void testReleaseTrueDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-TTTT, f R g-UUUU
+ // */
+ // @Test
+ // public void testReleaseTrueDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FFFT, g-TTTF, f R g-FFFF
+ // */
+ // @Test
+ // public void testReleaseFalseDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-FTTT, f R g-FUUU
+ // */
+ // @Test
+ // public void testReleaseFalseDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FUTU, g-UTUU, f R g-UTTU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FUUU, g-UTFU, f R g-UUFU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FUUU, g-UTUU, f R g-UUUU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-TTTT, f R g-UUUU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath4() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-UUUU, f R g-UUUU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath5() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UUUU, g-UUUU, f R g-UUUU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath6() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UUTF, g-FTTT, f R g-FTTU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath7() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FUTU, g-TUTU, f R g-UUTU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath8() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FFTU, g-TUTU, f R g-UUTU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath9() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FUUU, g-UTFU, f R g-UUFU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath10() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FUUU, g-UUFU, f R g-UUFU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath11() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FTUF, g-FTUU, f R g-FTUU
+ // */
+ // @Test
+ // public void testReleaseUnknownDefinitionOnReducedPath12() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator releaseOperator = new
+ // CounterExampleRelease(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = releaseOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = releaseOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = releaseOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+
+ private static int[] future(int current, int size, int entry) {
+ final int first = current <= entry ? current : entry;
+ final int resSize = size - first;
+ int[] res = new int[resSize];
+ for (int i = 0; i < resSize; i++) {
+ res[i] = first + i;
+ }
+ return res;
}
- /*
- * f-UUUT, g-TTTT, f R g-TTTT
- */
- @Test
- public void testReleaseTrueDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FFFF, g-TTTT, f R g-UUUU
- */
- @Test
- public void testReleaseTrueDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FFFT, g-TTTF, f R g-FFFF
- */
- @Test
- public void testReleaseFalseDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FFFF, g-FTTT, f R g-FUUU
- */
- @Test
- public void testReleaseFalseDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FUTU, g-UTUU, f R g-UTTU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FUUU, g-UTFU, f R g-UUFU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FUUU, g-UTUU, f R g-UUUU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FFFF, g-TTTT, f R g-UUUU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath4() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FFFF, g-UUUU, f R g-UUUU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath5() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UUUU, g-UUUU, f R g-UUUU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath6() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UUTF, g-FTTT, f R g-FTTU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath7() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FUTU, g-TUTU, f R g-UUTU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath8() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FFTU, g-TUTU, f R g-UUTU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath9() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FUUU, g-UTFU, f R g-UUFU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath10() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FUUU, g-UUFU, f R g-UUFU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath11() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FTUF, g-FTUU, f R g-FTUU
- */
- @Test
- public void testReleaseUnknownDefinitionOnReducedPath12() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = releaseOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = releaseOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = releaseOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
}
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleSinceUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleSinceUnitTest.java
index d41d7a29..967f9264 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleSinceUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleSinceUnitTest.java
@@ -1,18 +1,5 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
-import de.prob.core.domainobjects.ltl.CounterExampleProposition;
-import de.prob.core.domainobjects.ltl.CounterExampleSince;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
/**
* Unit test for a "since" operator.
@@ -21,3224 +8,3293 @@ import de.prob.core.domainobjects.ltl.CounterExampleValueType;
*
*/
public final class CounterExampleSinceUnitTest {
- /*
- * f-FTTT, g-TFFF, f S g-TTTT
- */
- @Test
- public void testSinceTrueDefinitionOnFinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-FFTT, g-TFFF, f S g-TFFF
- */
- @Test
- public void testSinceFalseDefinitionOnFinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-FTTT, g-FFFF, f S g-FFFF
- */
- @Test
- public void testSinceFalseDefinitionOnFinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-TTTT, g-FFFF, f S g-FFFF
- */
- @Test
- public void testSinceFalseDefinitionOnFinitePath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f - TFFT g - FTFF f S g - FTFF
- */
- @Test
- public void testSinceOnFinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- }
-
- /*
- * f-FTTT, g-TFFF, f S g-TTTT
- */
- @Test
- public void testSinceTrueDefinitionOnInfinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-FFTT, g-TFFF, f S g-TFFF
- */
- @Test
- public void testSinceFalseDefinitionOnInfinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-FTTT, g-FFFF, f S g-FFFF
- */
- @Test
- public void testSinceFalseDefinitionOnInfinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-TTTT, g-FFFF, f S g-FFFF
- */
- @Test
- public void testSinceFalseDefinitionOnInfinitePath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- sinceOperator = new CounterExampleSince(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-FTTT, g-TFFF, f S g-TTTT
- */
- @Test
- public void testSinceTrueDefinitionOnReducedPath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-FFTT, g-TFFF, f S g-TFFF
- */
- @Test
- public void testSinceFalseDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-FTTT, g-FFFF, f S g-FFFF
- */
- @Test
- public void testSinceFalseDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-TTTT, g-FFFF, f S g-FFFF
- */
- @Test
- public void testSinceFalseDefinitionOnReducedPath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-UUTU, g-UTUF, f S g-UTTU
- */
- @Test
- public void testSinceUnknownDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-UFUU, g-UUFF, f S g-UUUU
- */
- @Test
- public void testSinceUnknownDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-UUTU, g-UUUF, f S g-UUUU
- */
- @Test
- public void testSinceUnknownDefinitionOnReducedPath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-TTTT, g-FFFF, f S g-FFFF
- */
- @Test
- public void testSinceUnknownDefinitionOnReducedPath4() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-TTTT, g-UUUU, f S g-UUUU
- */
- @Test
- public void testSinceUnknownDefinitionOnReducedPath5() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- // f-TUTU, g-UFUF, f S g-UUUU
- @Test
- public void testSinceUnknownDefinitionOnReducedPath6() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- // f-UFTU, g-FFTF, f S g-UFTU
- @Test
- public void testSinceUnknownDefinitionOnReducedPath7() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- }
-
- // f-UUUU, g-TUUU, f S g-TUUU
- @Test
- public void testSinceUnknownDefinitionOnReducedPath8() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUFU, g-TUFU, f S g- TUFU
- @Test
- public void testSinceUnknownDefinitionOnReducedPath9() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-FFUU, g-FUUU, f S g-FUUU
- @Test
- public void testSinceUnknownDefinitionOnReducedPath10() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUUU, g-UTUU, f S g-UTUU
- @Test
- public void testSinceUnknownDefinitionOnReducedPath11() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UFUU, g-UUUU, f S g-UUUU
- @Test
- public void testSinceUnknownDefinitionOnReducedPath12() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UFTU, g-FFTF, f S g-UFTU
- */
- @Test
- public void testSinceUnknownDefinitionOnReducedPath13() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- }
-
- /*
- * f-UUUU, g-UUUU, f S g-UUUU
- */
- @Test
- public void testSinceUnknownDefinitionOnReducedPath14() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = sinceOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = sinceOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = sinceOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
+ // /*
+ // * f-FTTT, g-TFFF, f S g-TTTT
+ // */
+ // @Test
+ // public void testSinceTrueDefinitionOnFinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-FFTT, g-TFFF, f S g-TFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnFinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-FTTT, g-FFFF, f S g-FFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnFinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-FFFF, f S g-FFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnFinitePath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f - TFFT g - FTFF f S g - FTFF
+ // */
+ // @Test
+ // public void testSinceOnFinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // }
+ //
+ // /*
+ // * f-FTTT, g-TFFF, f S g-TTTT
+ // */
+ // @Test
+ // public void testSinceTrueDefinitionOnInfinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-FFTT, g-TFFF, f S g-TFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnInfinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-FTTT, g-FFFF, f S g-FFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnInfinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-FFFF, f S g-FFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnInfinitePath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator sinceOperator = new CounterExampleSince(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // sinceOperator = new CounterExampleSince(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-FTTT, g-TFFF, f S g-TTTT
+ // */
+ // @Test
+ // public void testSinceTrueDefinitionOnReducedPath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-FFTT, g-TFFF, f S g-TFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-FTTT, g-FFFF, f S g-FFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-FFFF, f S g-FFFF
+ // */
+ // @Test
+ // public void testSinceFalseDefinitionOnReducedPath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-UUTU, g-UTUF, f S g-UTTU
+ // */
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-UFUU, g-UUFF, f S g-UUUU
+ // */
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-UUTU, g-UUUF, f S g-UUUU
+ // */
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-FFFF, f S g-FFFF
+ // */
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath4() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-UUUU, f S g-UUUU
+ // */
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath5() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // // f-TUTU, g-UFUF, f S g-UUUU
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath6() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // // f-UFTU, g-FFTF, f S g-UFTU
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath7() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // }
+ //
+ // // f-UUUU, g-TUUU, f S g-TUUU
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath8() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUFU, g-TUFU, f S g- TUFU
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath9() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-FFUU, g-FUUU, f S g-FUUU
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath10() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUUU, g-UTUU, f S g-UTUU
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath11() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UFUU, g-UUUU, f S g-UUUU
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath12() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UFTU, g-FFTF, f S g-UFTU
+ // */
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath13() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // }
+ //
+ // /*
+ // * f-UUUU, g-UUUU, f S g-UUUU
+ // */
+ // @Test
+ // public void testSinceUnknownDefinitionOnReducedPath14() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator sinceOperator = new
+ // CounterExampleSince(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = sinceOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = sinceOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = sinceOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
}
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleTriggerUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleTriggerUnitTest.java
index 8726fa19..45bc1d3d 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleTriggerUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleTriggerUnitTest.java
@@ -1,18 +1,5 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
-import de.prob.core.domainobjects.ltl.CounterExampleProposition;
-import de.prob.core.domainobjects.ltl.CounterExampleTrigger;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
/**
* Unit test for a "trigger" operator.
@@ -21,3432 +8,3496 @@ import de.prob.core.domainobjects.ltl.CounterExampleValueType;
*
*/
public final class CounterExampleTriggerUnitTest {
- /*
- * f-TFFF, g-TTTT, f T g-TTTT
- */
- @Test
- public void testTriggerTrueDefinitionOnFinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-FFFF, g-TTTT, f T g-TTTT
- */
- @Test
- public void testTriggerTrueDefinitionOnFinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-TFFF, g-FTTT, f T g-FFFF
- */
- @Test
- public void testTriggerFalseDefinitionOnFinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-FFFF, g-FTTT, f T g-FFFF
- */
- @Test
- public void testTriggerFalseDefinitionOnFinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-FTFT, g-TFFT, f T g-TFFT
- */
- @Test
- public void testTriggerOnFinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FTTF, g-TTFT, f T g-TTFF
- */
- @Test
- public void testTriggerOnFinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.FINITE, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
- }
-
- /*
- * f-TFFF, g-TTTT, f T g-TTTT
- */
- @Test
- public void testTriggerTrueDefinitionOnInfinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-FFFF, g-TTTT, f T g-TTTT
- */
- @Test
- public void testTriggerTrueDefinitionOnInfinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-TFFF, g-FTTT, f T g-FFFF
- */
- @Test
- public void testTriggerFalseDefinitionOnInfinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-FFFF, g-FTTT, f T g-FFFF
- */
- @Test
- public void testTriggerFalseDefinitionOnInfinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-FTFT, g-TFFT, f T g-TFFT
- */
- @Test
- public void testTriggerOnInfinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = triggerOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TFFF, g-TTTT, f T g-TTTT
- */
- @Test
- public void testTriggerTrueDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-FFFF, g-TTTT, f T g-TTTT
- */
- @Test
- public void testTriggerTrueDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-TFFF, g-FTTT, f T g-FFFF
- */
- @Test
- public void testTriggerFalseDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-FFFF, g-FTTT, f T g-FFFF
- */
- @Test
- public void testTriggerFalseDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
- }
-
- /*
- * f-UTUF, g-UUTU, f T g-UTTU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-UUUF, g-UFTU, f T g-UFFU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-UUUF, g-UUTU, f T g-UUUU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-FFFF, g-TTTT, f T g-TTTT
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath4() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-FFFF, g-UUUU, f T g-UUUU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath5() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 0 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1, 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1, 0 }));
- }
-
- /*
- * f-UUUU, g-UUUU, f T g-UUUU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath6() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-FTUU, g-TTTF, f T g-TTTF
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath7() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTUF, g-UTUT, f T g-UTUU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath8() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- }
-
- /*
- * f-UTFF, g-UTUT, f T g-UTUU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath9() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-UUUF, g-UFTU, f T g-UFUU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath10() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2, 1 }));
- }
-
- /*
- * f-UUUF, g-UFUU, f T g-UFUU
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath11() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- }
-
- /*
- * f-FUTF, g-UUTF, f T g-UUTF
- */
- @Test
- public void testTriggerUnknownDefinitionOnReducedPath12() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = triggerOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = triggerOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = triggerOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
+ // /*
+ // * f-TFFF, g-TTTT, f T g-TTTT
+ // */
+ // @Test
+ // public void testTriggerTrueDefinitionOnFinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-TTTT, f T g-TTTT
+ // */
+ // @Test
+ // public void testTriggerTrueDefinitionOnFinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-TFFF, g-FTTT, f T g-FFFF
+ // */
+ // @Test
+ // public void testTriggerFalseDefinitionOnFinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-FTTT, f T g-FFFF
+ // */
+ // @Test
+ // public void testTriggerFalseDefinitionOnFinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-FTFT, g-TFFT, f T g-TFFT
+ // */
+ // @Test
+ // public void testTriggerOnFinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FTTF, g-TTFT, f T g-TTFF
+ // */
+ // @Test
+ // public void testTriggerOnFinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.FINITE, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // }
+ //
+ // /*
+ // * f-TFFF, g-TTTT, f T g-TTTT
+ // */
+ // @Test
+ // public void testTriggerTrueDefinitionOnInfinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-TTTT, f T g-TTTT
+ // */
+ // @Test
+ // public void testTriggerTrueDefinitionOnInfinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-TFFF, g-FTTT, f T g-FFFF
+ // */
+ // @Test
+ // public void testTriggerFalseDefinitionOnInfinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-FTTT, f T g-FFFF
+ // */
+ // @Test
+ // public void testTriggerFalseDefinitionOnInfinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-FTFT, g-TFFT, f T g-TFFT
+ // */
+ // @Test
+ // public void testTriggerOnInfinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = triggerOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TFFF, g-TTTT, f T g-TTTT
+ // */
+ // @Test
+ // public void testTriggerTrueDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-TTTT, f T g-TTTT
+ // */
+ // @Test
+ // public void testTriggerTrueDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-TFFF, g-FTTT, f T g-FFFF
+ // */
+ // @Test
+ // public void testTriggerFalseDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-FTTT, f T g-FFFF
+ // */
+ // @Test
+ // public void testTriggerFalseDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // }
+ //
+ // /*
+ // * f-UTUF, g-UUTU, f T g-UTTU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-UUUF, g-UFTU, f T g-UFFU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-UUUF, g-UUTU, f T g-UUUU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-TTTT, f T g-TTTT
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath4() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-FFFF, g-UUUU, f T g-UUUU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath5() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 0 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1, 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1, 0 }));
+ // }
+ //
+ // /*
+ // * f-UUUU, g-UUUU, f T g-UUUU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath6() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-FTUU, g-TTTF, f T g-TTTF
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath7() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTUF, g-UTUT, f T g-UTUU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath8() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // }
+ //
+ // /*
+ // * f-UTFF, g-UTUT, f T g-UTUU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath9() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-UUUF, g-UFTU, f T g-UFUU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath10() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2, 1 }));
+ // }
+ //
+ // /*
+ // * f-UUUF, g-UFUU, f T g-UFUU
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath11() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator triggerOperator = new
+ // CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // }
+ //
+ // /*
+ // * f-FUTF, g-UUTF, f T g-UUTF
+ // */
+ // @Test
+ // public void testTriggerUnknownDefinitionOnReducedPath12() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = triggerOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = triggerOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = triggerOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
}
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleUntilUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleUntilUnitTest.java
index 1e7e0a7b..f94c169e 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleUntilUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleUntilUnitTest.java
@@ -1,18 +1,5 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
-import de.prob.core.domainobjects.ltl.CounterExampleProposition;
-import de.prob.core.domainobjects.ltl.CounterExampleUntil;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
/**
* Unit test for an "until" operator.
@@ -21,2286 +8,2352 @@ import de.prob.core.domainobjects.ltl.CounterExampleValueType;
*
*/
public final class CounterExampleUntilUnitTest {
- /*
- * f-TTTF, g-FFFT, f U g-TTTT
- */
- @Test
- public void testUntilTrueDefinitionOnFinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTTF, g-FFFF, f U g-FFFF
- */
- @Test
- public void testUntilFalseDefinitionOnFinitePath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTFF, g-FFFT, f U g-FFFT
- */
- @Test
- public void testUntilFalseDefinitionOnFinitePath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTTT, g-FFFF, f U g-FFFF
- */
- @Test
- public void testUntilFalseDefinitionOnFinitePath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f - TFFT g - FTFF f U g - TTFF
- */
- @Test
- public void testUntilOnFinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f - TFFT g - FTFF
- */
- @Test
- public void testUntilOnInfinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 0 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- untilOperator = new CounterExampleUntil(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- untilOperator = new CounterExampleUntil(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- untilOperator = new CounterExampleUntil(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTTU, g-UUUT, f U g-TTTT
- */
- @Test
- public void testUntilTrueDefinitionOnReducedPath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UUFU, g-FFFT, f U g-FFFT
- */
- @Test
- public void testUntilFalseDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UUUF, g-FFFF, f U g-FFFF
- */
- @Test
- public void testUntilFalseDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTUU, g-FUTU, f U g-UTTU
- */
- @Test
- public void testUntilUnknownDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UUFU, g-FFUU, f U g-UUUU
- */
- @Test
- public void testUntilUnknownDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTUU, g-FUUU, f U g-UUUU
- */
- @Test
- public void testUntilUnknownDefinitionOnReducedPath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTTT, g-FFFF, f U g-UUUU
- */
- @Test
- public void testUntilUnknownDefinitionOnReducedPath4() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTTT, g-UUUU, f U g-UUUU
- */
- @Test
- public void testUntilUnknownDefinitionOnReducedPath5() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTUT, g-FUFU, f U g-UUUU
- */
- @Test
- public void testUntilOnReducedPathUnknownDefinition6() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTFU, g-FTFF, f U g-UTFU
- */
- @Test
- public void testUntilOnReducedPathUnknownDefinition7() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUUU, g-UUUT, f U g-UUUT
- @Test
- public void testUntilUnknownDefinitionOnReducedPath8() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UFUU, g-UFUT, f U g-UFUT
- @Test
- public void testUntilUnknownDefinitionOnReducedPath9() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUFF, g-UUUF, f U g-UUUF
- @Test
- public void testUntilUnknownDefinitionOnReducedPath10() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUUU, g-UUTU, f U g-UUTU
- @Test
- public void testUntilUnknownDefinitionOnReducedPath11() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUFU, g-UUUU, f U g-UUUU
- @Test
- public void testUntilUnknownDefinitionOnReducedPath12() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f - UTFU g - FTFF f U g - UTFU
- */
- @Test
- public void testUntilOnReducedPathUnknownDefinition13() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f - UUUU g - UUUU f U g - UUUU
- */
- @Test
- public void testUntilOnReducedPathUnknownDefinition14() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = untilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = untilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = untilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
+ // /*
+ // * f-TTTF, g-FFFT, f U g-TTTT
+ // */
+ // @Test
+ // public void testUntilTrueDefinitionOnFinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTTF, g-FFFF, f U g-FFFF
+ // */
+ // @Test
+ // public void testUntilFalseDefinitionOnFinitePath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTFF, g-FFFT, f U g-FFFT
+ // */
+ // @Test
+ // public void testUntilFalseDefinitionOnFinitePath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-FFFF, f U g-FFFF
+ // */
+ // @Test
+ // public void testUntilFalseDefinitionOnFinitePath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f - TFFT g - FTFF f U g - TTFF
+ // */
+ // @Test
+ // public void testUntilOnFinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f - TFFT g - FTFF
+ // */
+ // @Test
+ // public void testUntilOnInfinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator untilOperator = new CounterExampleUntil(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 0 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // untilOperator = new CounterExampleUntil(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // untilOperator = new CounterExampleUntil(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // untilOperator = new CounterExampleUntil(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTTU, g-UUUT, f U g-TTTT
+ // */
+ // @Test
+ // public void testUntilTrueDefinitionOnReducedPath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UUFU, g-FFFT, f U g-FFFT
+ // */
+ // @Test
+ // public void testUntilFalseDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UUUF, g-FFFF, f U g-FFFF
+ // */
+ // @Test
+ // public void testUntilFalseDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTUU, g-FUTU, f U g-UTTU
+ // */
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UUFU, g-FFUU, f U g-UUUU
+ // */
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTUU, g-FUUU, f U g-UUUU
+ // */
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-FFFF, f U g-UUUU
+ // */
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath4() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-UUUU, f U g-UUUU
+ // */
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath5() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTUT, g-FUFU, f U g-UUUU
+ // */
+ // @Test
+ // public void testUntilOnReducedPathUnknownDefinition6() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTFU, g-FTFF, f U g-UTFU
+ // */
+ // @Test
+ // public void testUntilOnReducedPathUnknownDefinition7() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUUU, g-UUUT, f U g-UUUT
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath8() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UFUU, g-UFUT, f U g-UFUT
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath9() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUFF, g-UUUF, f U g-UUUF
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath10() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUUU, g-UUTU, f U g-UUTU
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath11() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUFU, g-UUUU, f U g-UUUU
+ // @Test
+ // public void testUntilUnknownDefinitionOnReducedPath12() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f - UTFU g - FTFF f U g - UTFU
+ // */
+ // @Test
+ // public void testUntilOnReducedPathUnknownDefinition13() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f - UUUU g - UUUU f U g - UUUU
+ // */
+ // @Test
+ // public void testUntilOnReducedPathUnknownDefinition14() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator untilOperator = new
+ // CounterExampleUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = untilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = untilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = untilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
}
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleWeakUntilUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleWeakUntilUnitTest.java
index d34fdc6c..db33abab 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleWeakUntilUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleWeakUntilUnitTest.java
@@ -1,18 +1,5 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
-import de.prob.core.domainobjects.ltl.CounterExampleProposition;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
-import de.prob.core.domainobjects.ltl.CounterExampleWeakUntil;
/**
* Unit test for a "weak until" operator.
@@ -21,2111 +8,2172 @@ import de.prob.core.domainobjects.ltl.CounterExampleWeakUntil;
*
*/
public final class CounterExampleWeakUntilUnitTest {
- /*
- * f-TTTF, g-FFFT, f WU g-TTTT
- */
- @Test
- public void testWeakUntilOnFinitePathTrueDefinition1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTTT, g-FFFF, f WU g-TTTT
- */
- @Test
- public void testWeakUntilOnFinitePathTrueDefinition2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 0);
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 0);
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 0);
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 0);
- }
-
- /*
- * f-TTTF, g-FFFF, f WU g-FFFF
- */
- @Test
- public void testWeakUntilOnFinitePathFalseDefinition1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTFF, g-FFFT, f WU g-FFFT
- */
- @Test
- public void testWeakUntilOnFinitePathFalseDefinition2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f - FFTT g - TFFF f WU g - TFTT
- */
- @Test
- public void testWeakUntilOnFinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 0);
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 0);
- }
-
- /*
- * f - FFTT g - TFFF
- */
- @Test
- public void testWeakUntilOnInfinitePath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // Loop entry = 0
- // create first argument
- CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, firstArgumentValues);
-
- // create second argument
- CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.INFINITE, 0, secondArgumentValues);
-
- // create an operator
- CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.INFINITE, 0, firstArgument, secondArgument);
-
- // check result values
- List<CounterExampleValueType> values = weakUntilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // Loop entry = 1
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
- secondArgumentValues);
-
- // create an operator
- weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 1,
- firstArgument, secondArgument);
-
- // check result values
- values = weakUntilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3, 1 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 1 }));
-
- // Loop entry = 2
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
- secondArgumentValues);
-
- // create an operator
- weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 2,
- firstArgument, secondArgument);
-
- // check result values
- values = weakUntilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 0);
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3, 2 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 0);
-
- // Loop entry = 3
- // create first argument
- firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- firstArgumentValues);
-
- // create second argument
- secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
- secondArgumentValues);
-
- // create an operator
- weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 3,
- firstArgument, secondArgument);
-
- // check result values
- values = weakUntilOperator.getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 0);
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 0);
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 0);
- }
-
- /*
- * f-TTTU, g-UUUT, f WU g-TTTT
- */
- @Test
- public void testWeakUntilTrueDefinitionOnReducedPath() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.FINITE, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.FINITE, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.TRUE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTUU, g-FUTU, f WU g-UTTU
- */
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath1() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UUFU, g-FFUU, f WU g-UUUU
- */
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath2() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTUU, g-FUUU, f WU g-UUUU
- */
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath3() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTTT, g-FFFF, f WU g-UUUU
- */
- @Test
- public void testWeakUntilOnReducedPathUnknownDefinition4() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-TTTT, g-UUUU, f WU g-UUUU
- */
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath5() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTUT, g-FUFU, f WU g-UUUU
- */
- @Test
- public void testWeakUntilOnReducedPathUnknownDefinition6() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 4);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1, 2, 3 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 3);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1, 2, 3 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2, 3 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f-UTFU, g-FTFF, f WU g-UTFU
- */
- @Test
- public void testWeakUntilOnReducedPathUnknownDefinition7() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUUU, g-UUUT, f WU g-UUUT
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath8() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UFUU, g-UFUT, f WU g-UFUT
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath9() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.TRUE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 0);
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUFF, g-UUUF, f WU g-UUUF
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath10() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUUU, g-UUTU, f WU g-UUTU
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath11() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 0);
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- // f-UUFU, g-UUUU, f WU g-UUUU
- @Test
- public void testWeakUntilUnknownDefinitionOnReducedPath12() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- PathType.REDUCED, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- PathType.REDUCED, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f - UTFU g - FTFF f WU g - UTFU
- */
- @Test
- public void testWeakUntilOnReducedPathUnknownDefinition13() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.FALSE });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.FALSE);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 2);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0, 1 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 0);
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
-
- /*
- * f - UUUU g - UUUU f WU g - UUUU
- */
- @Test
- public void testWeakUntilOnReducedPathUnknownDefinition14() {
- // create first argument values
- final List<CounterExampleValueType> firstArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create second argument values
- final List<CounterExampleValueType> secondArgumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.UNKNOWN });
-
- // create first argument
- final CounterExampleProposition firstArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, firstArgumentValues);
-
- // create second argument
- final CounterExampleProposition secondArgument = new CounterExamplePredicate(
- "", PathType.REDUCED, -1, secondArgumentValues);
-
- // create an operator
- final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil(
- PathType.REDUCED, -1, firstArgument, secondArgument);
-
- // check result values
- final List<CounterExampleValueType> values = weakUntilOperator
- .getValues();
- assertTrue(values.size() == firstArgumentValues.size());
- assertTrue(values.size() == secondArgumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
-
- // check highlighted positions
- final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
- .getFirstHighlightedPositions();
- final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
- .getSecondHighlightedPositions();
- assertTrue(firstHighlightedPositions.size() == firstArgumentValues
- .size());
- assertTrue(secondHighlightedPositions.size() == secondArgumentValues
- .size());
-
- // State 0
- assertTrue(firstHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
- assertTrue(secondHighlightedPositions.get(0).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(0).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- // State 1
- assertTrue(firstHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
- assertTrue(secondHighlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- // State 2
- assertTrue(firstHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
- assertTrue(secondHighlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // State 3
- assertTrue(firstHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- firstHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- assertTrue(secondHighlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- secondHighlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 3 }));
- }
+ // /*
+ // * f-TTTF, g-FFFT, f WU g-TTTT
+ // */
+ // @Test
+ // public void testWeakUntilOnFinitePathTrueDefinition1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-FFFF, f WU g-TTTT
+ // */
+ // @Test
+ // public void testWeakUntilOnFinitePathTrueDefinition2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 0);
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 0);
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 0);
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 0);
+ // }
+ //
+ // /*
+ // * f-TTTF, g-FFFF, f WU g-FFFF
+ // */
+ // @Test
+ // public void testWeakUntilOnFinitePathFalseDefinition1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTFF, g-FFFT, f WU g-FFFT
+ // */
+ // @Test
+ // public void testWeakUntilOnFinitePathFalseDefinition2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f - FFTT g - TFFF f WU g - TFTT
+ // */
+ // @Test
+ // public void testWeakUntilOnFinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 0);
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 0);
+ // }
+ //
+ // /*
+ // * f - FFTT g - TFFF
+ // */
+ // @Test
+ // public void testWeakUntilOnInfinitePath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // Loop entry = 0
+ // // create first argument
+ // CounterExampleProposition firstArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, firstArgumentValues);
+ //
+ // // create second argument
+ // CounterExampleProposition secondArgument = new CounterExamplePredicate(
+ // "", PathType.INFINITE, 0, secondArgumentValues);
+ //
+ // // create an operator
+ // CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.INFINITE, 0, firstArgument, secondArgument);
+ //
+ // // check result values
+ // List<CounterExampleValueType> values = weakUntilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // Loop entry = 1
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 1,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = weakUntilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3, 1 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 1 }));
+ //
+ // // Loop entry = 2
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 2,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = weakUntilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 0);
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3, 2 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 0);
+ //
+ // // Loop entry = 3
+ // // create first argument
+ // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // firstArgumentValues);
+ //
+ // // create second argument
+ // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3,
+ // secondArgumentValues);
+ //
+ // // create an operator
+ // weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 3,
+ // firstArgument, secondArgument);
+ //
+ // // check result values
+ // values = weakUntilOperator.getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 0);
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 0);
+ // }
+ //
+ // /*
+ // * f-TTTU, g-UUUT, f WU g-TTTT
+ // */
+ // @Test
+ // public void testWeakUntilTrueDefinitionOnReducedPath() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.FINITE, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.FINITE, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTUU, g-FUTU, f WU g-UTTU
+ // */
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath1() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UUFU, g-FFUU, f WU g-UUUU
+ // */
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath2() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTUU, g-FUUU, f WU g-UUUU
+ // */
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath3() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-FFFF, f WU g-UUUU
+ // */
+ // @Test
+ // public void testWeakUntilOnReducedPathUnknownDefinition4() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-TTTT, g-UUUU, f WU g-UUUU
+ // */
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath5() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTUT, g-FUFU, f WU g-UUUU
+ // */
+ // @Test
+ // public void testWeakUntilOnReducedPathUnknownDefinition6() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 4);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1, 2, 3 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 3);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1, 2, 3 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2, 3 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f-UTFU, g-FTFF, f WU g-UTFU
+ // */
+ // @Test
+ // public void testWeakUntilOnReducedPathUnknownDefinition7() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUUU, g-UUUT, f WU g-UUUT
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath8() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UFUU, g-UFUT, f WU g-UFUT
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath9() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.TRUE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUFF, g-UUUF, f WU g-UUUF
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath10() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.FALSE);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUUU, g-UUTU, f WU g-UUTU
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath11() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // // f-UUFU, g-UUUU, f WU g-UUUU
+ // @Test
+ // public void testWeakUntilUnknownDefinitionOnReducedPath12() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // PathType.REDUCED, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f - UTFU g - FTFF f WU g - UTFU
+ // */
+ // @Test
+ // public void testWeakUntilOnReducedPathUnknownDefinition13() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.TRUE,
+ // CounterExampleValueType.FALSE,
+ // CounterExampleValueType.FALSE });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.TRUE);
+ // assertTrue(values.get(2) == CounterExampleValueType.FALSE);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 2);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0, 1 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 0);
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
+ //
+ // /*
+ // * f - UUUU g - UUUU f WU g - UUUU
+ // */
+ // @Test
+ // public void testWeakUntilOnReducedPathUnknownDefinition14() {
+ // // create first argument values
+ // final List<CounterExampleValueType> firstArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create second argument values
+ // final List<CounterExampleValueType> secondArgumentValues = Arrays
+ // .asList(new CounterExampleValueType[] {
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN,
+ // CounterExampleValueType.UNKNOWN });
+ //
+ // // create first argument
+ // final CounterExampleProposition firstArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, firstArgumentValues);
+ //
+ // // create second argument
+ // final CounterExampleProposition secondArgument = new
+ // CounterExamplePredicate(
+ // "", PathType.REDUCED, -1, secondArgumentValues);
+ //
+ // // create an operator
+ // final CounterExampleBinaryOperator weakUntilOperator = new
+ // CounterExampleWeakUntil(
+ // PathType.REDUCED, -1, firstArgument, secondArgument);
+ //
+ // // check result values
+ // final List<CounterExampleValueType> values = weakUntilOperator
+ // .getValues();
+ // assertTrue(values.size() == firstArgumentValues.size());
+ // assertTrue(values.size() == secondArgumentValues.size());
+ // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
+ // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN);
+ //
+ // // check highlighted positions
+ // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator
+ // .getFirstHighlightedPositions();
+ // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator
+ // .getSecondHighlightedPositions();
+ // assertTrue(firstHighlightedPositions.size() == firstArgumentValues
+ // .size());
+ // assertTrue(secondHighlightedPositions.size() == secondArgumentValues
+ // .size());
+ //
+ // // State 0
+ // assertTrue(firstHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ // assertTrue(secondHighlightedPositions.get(0).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(0).toArray(new Integer[0]),
+ // new Integer[] { 0 }));
+ //
+ // // State 1
+ // assertTrue(firstHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ // assertTrue(secondHighlightedPositions.get(1).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(1).toArray(new Integer[0]),
+ // new Integer[] { 1 }));
+ //
+ // // State 2
+ // assertTrue(firstHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ // assertTrue(secondHighlightedPositions.get(2).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(2).toArray(new Integer[0]),
+ // new Integer[] { 2 }));
+ //
+ // // State 3
+ // assertTrue(firstHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // firstHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // assertTrue(secondHighlightedPositions.get(3).size() == 1);
+ // assertTrue(Arrays.equals(
+ // secondHighlightedPositions.get(3).toArray(new Integer[0]),
+ // new Integer[] { 3 }));
+ // }
}
diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleYesterdayUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleYesterdayUnitTest.java
index 5518e5b6..b7b7e254 100644
--- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleYesterdayUnitTest.java
+++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleYesterdayUnitTest.java
@@ -1,17 +1,9 @@
package de.prob.core.domainobjects.ltl.unittests;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.List;
-
import org.junit.Test;
-import de.prob.core.command.LtlCheckingCommand.PathType;
-import de.prob.core.domainobjects.ltl.CounterExamplePredicate;
import de.prob.core.domainobjects.ltl.CounterExampleProposition;
import de.prob.core.domainobjects.ltl.CounterExampleUnaryOperator;
-import de.prob.core.domainobjects.ltl.CounterExampleValueType;
import de.prob.core.domainobjects.ltl.CounterExampleYesterday;
/**
@@ -27,52 +19,8 @@ public final class CounterExampleYesterdayUnitTest {
*/
@Test
public void testYesterdayOnFinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- PathType.FINITE, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator yesterdayOperator = new CounterExampleYesterday(
- PathType.FINITE, argument);
-
- // check result values
- final List<CounterExampleValueType> values = yesterdayOperator
- .getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = yesterdayOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- assertTrue(highlightedPositions.get(0).size() == 0);
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
+ final LtlTestDescription d = LtlTestDescription.finite(4);
+ checkYesterdayFTFT(d);
}
/*
@@ -80,166 +28,10 @@ public final class CounterExampleYesterdayUnitTest {
*/
@Test
public void testYesterdayOnInfinitePath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // Loop entry = 0
- // create an argument
- CounterExampleProposition argument = new CounterExamplePredicate(
- PathType.INFINITE, 0, argumentValues);
-
- // create an operator
- CounterExampleUnaryOperator yesterdayOperator = new CounterExampleYesterday(
- PathType.INFINITE, 0, argument);
-
- // check result values
- List<CounterExampleValueType> values = yesterdayOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- List<List<Integer>> highlightedPositions = yesterdayOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- assertTrue(highlightedPositions.get(0).size() == 0);
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // Loop entry = 1
- // create an argument
- argument = new CounterExamplePredicate(PathType.INFINITE, 1,
- argumentValues);
-
- // create an operator
- yesterdayOperator = new CounterExampleYesterday(PathType.INFINITE, 1,
- argument);
-
- // check result values
- values = yesterdayOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = yesterdayOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- assertTrue(highlightedPositions.get(0).size() == 0);
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // Loop entry = 2
- // create an argument
- argument = new CounterExamplePredicate(PathType.INFINITE, 2,
- argumentValues);
-
- // create an operator
- yesterdayOperator = new CounterExampleYesterday(PathType.INFINITE, 2,
- argument);
-
- // check result values
- values = yesterdayOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = yesterdayOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- assertTrue(highlightedPositions.get(0).size() == 0);
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
-
- // Loop entry = 3
- // create an argument
- argument = new CounterExamplePredicate(PathType.INFINITE, 3,
- argumentValues);
-
- // create an operator
- yesterdayOperator = new CounterExampleYesterday(PathType.INFINITE, 3,
- argument);
-
- // check result values
- values = yesterdayOperator.getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.FALSE);
- assertTrue(values.get(2) == CounterExampleValueType.TRUE);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- highlightedPositions = yesterdayOperator.getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- assertTrue(highlightedPositions.get(0).size() == 0);
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
+ for (int entry = 0; entry < 4; entry++) {
+ final LtlTestDescription d = LtlTestDescription.loop(4, entry);
+ checkYesterdayFTFT(d);
+ }
}
/*
@@ -247,52 +39,28 @@ public final class CounterExampleYesterdayUnitTest {
*/
@Test
public void testYesterdayOnReducedPath() {
- // create argument values
- final List<CounterExampleValueType> argumentValues = Arrays
- .asList(new CounterExampleValueType[] {
- CounterExampleValueType.TRUE,
- CounterExampleValueType.UNKNOWN,
- CounterExampleValueType.FALSE,
- CounterExampleValueType.TRUE });
-
- // create an argument
- final CounterExampleProposition argument = new CounterExamplePredicate(
- PathType.REDUCED, argumentValues);
-
- // create an operator
- final CounterExampleUnaryOperator yesterdayOperator = new CounterExampleYesterday(
- PathType.REDUCED, argument);
-
- // check result values
- final List<CounterExampleValueType> values = yesterdayOperator
- .getValues();
- assertTrue(values.size() == argumentValues.size());
- assertTrue(values.get(0) == CounterExampleValueType.FALSE);
- assertTrue(values.get(1) == CounterExampleValueType.TRUE);
- assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN);
- assertTrue(values.get(3) == CounterExampleValueType.FALSE);
-
- // check highlighted positions
- final List<List<Integer>> highlightedPositions = yesterdayOperator
- .getHighlightedPositions();
- assertTrue(highlightedPositions.size() == argumentValues.size());
-
- assertTrue(highlightedPositions.get(0).size() == 0);
-
- assertTrue(highlightedPositions.get(1).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(1).toArray(new Integer[0]),
- new Integer[] { 0 }));
-
- assertTrue(highlightedPositions.get(2).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(2).toArray(new Integer[0]),
- new Integer[] { 1 }));
-
- assertTrue(highlightedPositions.get(3).size() == 1);
- assertTrue(Arrays.equals(
- highlightedPositions.get(3).toArray(new Integer[0]),
- new Integer[] { 2 }));
+ final LtlTestDescription d = LtlTestDescription.reduced(4);
+ final CounterExampleProposition arg = d.addArgument("arg", "tuft");
+ final CounterExampleUnaryOperator yesterday = new CounterExampleYesterday(
+ d.getCounterExample(), arg);
+ d.checkValues("yesterday", yesterday, "ftuf");
+ d.expectedHighlight(0, "yestH");
+ d.expectedHighlight(1, "yestH", 0);
+ d.expectedHighlight(2, "yestH", 1);
+ d.expectedHighlight(3, "yestH", 2);
+ d.checkHighlights("yesterday", yesterday, "yestH");
+ }
+ private void checkYesterdayFTFT(final LtlTestDescription d) {
+ final CounterExampleProposition arg = d.addArgument("arg", "ftft");
+ final CounterExampleUnaryOperator yesterday = new CounterExampleYesterday(
+ d.getCounterExample(), arg);
+ d.checkValues("yesterday", yesterday, "fftf");
+ d.expectedHighlight(0, "yestH");
+ d.expectedHighlight(1, "yestH", 0);
+ d.expectedHighlight(2, "yestH", 1);
+ d.expectedHighlight(3, "yestH", 2);
+ d.checkHighlights("yesterday", yesterday, "yestH");
}
+
}
--
GitLab