public static FSM GenerateTestSequenceAutomaton(string testcaseName, Sequence<Sequence<CompoundTerm>> testseqs, Set<Symbol> actionSymbols)
{
Set<Term> acceptingStates = Set<Term>.EmptySet;
Set<Term> states = Set<Term>.EmptySet;
Symbol testCaseActionSymbol = new Symbol(testcaseName);
Literal initialState = new Literal(0);
states = states.Add(initialState);
#region generate transitions and accepting states
Set<Triple<Term, CompoundTerm, Term>> transitions =
Set<Triple<Term, CompoundTerm, Term>>.EmptySet;
for (int i = 0; i < testseqs.Count; i++)
{
//the i'th test sequence start action
CompoundTerm startTestAction =
new CompoundTerm(testCaseActionSymbol,
new Sequence<Term>(new Literal(i)));
transitions = transitions.Add(new Triple<Term, CompoundTerm, Term>(
initialState,startTestAction, IntermediateState.State(i,0)));
Sequence<CompoundTerm> testseq = testseqs[i];
//the final step state of the i'th test sequence is an accepting state
acceptingStates = acceptingStates.Add(IntermediateState.State(i, testseq.Count));
states = states.Add(IntermediateState.State(i, testseq.Count));
for (int j = 0; j < testseq.Count; j++)
{
if (!actionSymbols.Contains(testseq[j].Symbol))
throw new ArgumentException("Not all action symbols in test sequences appear in actionSymbols", "actionSymbols");
states = states.Add(IntermediateState.State(i, j));
transitions = transitions.Add(new Triple<Term, CompoundTerm, Term>(
IntermediateState.State(i, j), testseq[j], IntermediateState.State(i, j + 1)));
}
}
#endregion
return new FSM(initialState, states, transitions,
acceptingStates, actionSymbols.Add(testCaseActionSymbol));
}
FSM CreateSampleFA()
{
Literal[] states = new Literal[5];
for (int i = 0; i < 5; i++)
states[i] = new Literal(i);
CompoundTerm a = new CompoundTerm(new Symbol("a"));
CompoundTerm b = new CompoundTerm(new Symbol("b"));
CompoundTerm c = new CompoundTerm(new Symbol("c"));
Set<Term> faStates = new Set<Term>(states);
Set<Term> accStates = new Set<Term>(states[2], states[3]);
Set<Symbol> vocab = new Set<Symbol>(a.Symbol, b.Symbol, c.Symbol);
Set<Transition> transitions =
new Set<Transition>(
new Transition(states[0], a, states[1]),
new Transition(states[1], b, states[2]),
new Transition(states[1], c, states[3]),
new Transition(states[3], a, states[4]));
return new FSM(states[0], faStates, transitions, accStates, vocab);
}
// This method has side effects on this.stateMap, this.nodeMap, this.nodes, this.acceptingNodes, this.actionsExploredFromNode
private bool TryGetTargetNode(Node sourceNode, CompoundTerm action, out Node targetNode)
{
IState targetState;
if (this.actionsExploredFromNode.ContainsKey(sourceNode))
{
if (!this.actionsExploredFromNode[sourceNode].TryGetValue(action, out targetNode))
{
//this action has not been explored yet from the given node
TransitionProperties transitionProperties;
targetState = this.modelProgram.GetTargetState(stateMap[sourceNode], action, Set<string>.EmptySet, out transitionProperties);
if (!this.nodeMap.TryGetValue(targetState, out targetNode))
{
targetNode = new Literal(this.nodes.Count);
this.stateMap[targetNode] = targetState;
this.nodeMap[targetState] = targetNode;
this.nodes = this.nodes.Add(targetNode);
if (this.modelProgram.IsAccepting(targetState))
this.acceptingNodes = this.acceptingNodes.Add(targetNode);
//if (!this.modelProgram.SatisfiesStateInvariant(targetState))
// this.errorNodes = this.errorNodes.Add(targetNode);
}
}
else
{
targetState = this.stateMap[targetNode];
}
}
else //the state has not yet been explored at all
{
TransitionProperties transitionProperties;
targetState = this.modelProgram.GetTargetState(stateMap[sourceNode], action, Set<string>.EmptySet, out transitionProperties);
if (!this.nodeMap.TryGetValue(targetState, out targetNode))
{
targetNode = new Literal(this.nodes.Count);
this.stateMap[targetNode] = targetState;
this.nodeMap[targetState] = targetNode;
this.nodes = this.nodes.Add(targetNode);
if (this.modelProgram.IsAccepting(targetState))
this.acceptingNodes = this.acceptingNodes.Add(targetNode);
//if (!this.modelProgram.SatisfiesStateInvariant(targetState))
// this.errorNodes = this.errorNodes.Add(targetNode);
}
Dictionary<CompoundTerm, Node> actionsFromState = new Dictionary<CompoundTerm, Node>();
actionsFromState[action] = targetNode;
this.actionsExploredFromNode[sourceNode] = actionsFromState;
}
return this.modelProgram.SatisfiesStateFilter(targetState);
}
internal ExploredTransitions(ModelProgram modelProgram, int initTransitions, int maxTransitions)
{
this.modelProgram = modelProgram;
this.transitions = Set<Transition>.EmptySet;
this.groupingTransitions = Set<Transition>.EmptySet;
Node initNode = new Literal(0);
this.initialNode = initNode;
this.nodes = new Set<Node>(initNode);
this.acceptingNodes = (modelProgram.IsAccepting(modelProgram.InitialState) ?
new Set<Node>(initNode) :
Set<Node>.EmptySet);
//this.errorNodes = (!modelProgram.SatisfiesStateInvariant(modelProgram.InitialState) ?
// new Set<Node>(initNode) :
// Set<Node>.EmptySet);
Dictionary<Node, IState> initialStateMap =
new Dictionary<Node, IState>();
initialStateMap[initNode] = modelProgram.InitialState;
this.stateMap = initialStateMap;
actionsExploredFromNode = new Dictionary<Node, Dictionary<CompoundTerm,Node>>();
Dictionary<IState, Node> initialNodeMap =
new Dictionary<IState, Node>();
initialNodeMap[modelProgram.InitialState] = initNode;
this.nodeMap = initialNodeMap;
this.hiddenTransitions = Set<Transition>.EmptySet;
this.maxTransitions = maxTransitions;
this.initTransitions = initTransitions;
}
/// <summary>
/// Explores the model associated with this instance.
/// The dictionary stateMap (if not null) is used to record the mapping
/// from generated finite automata states to IStates.
/// Explore(null) is the same as Explore()
/// </summary>
/// <returns>A list of transitions. Each transition is a start state,
/// an action label and an end state.</returns>
public FSM Explore(Dictionary<Term,IState> generatedStateMap)
{
Set<Symbol> actionSymbols = modelProgram.ActionSymbols();
IState initialState = modelProgram.InitialState;
Dictionary<IState, int> states = new Dictionary<IState, int>();
LinkedList<IState> frontier = new LinkedList<IState>();
frontier.AddFirst(initialState);
int nextStateId = 0;
Dictionary<Transition, Transition> transitions = new Dictionary<Transition, Transition>();
while (frontier.Count > 0)
{
IState startState = frontier.First.Value;
frontier.RemoveFirst();
if (!states.ContainsKey(startState)) states.Add(startState, nextStateId++);
foreach (Symbol actionSymbol in actionSymbols)
{
if (modelProgram.IsPotentiallyEnabled(startState, actionSymbol))
{
IEnumerable<CompoundTerm> actions = modelProgram.GetActions(startState, actionSymbol);
foreach (CompoundTerm action in actions)
{
TransitionProperties transitionProperties;
IState targetState = modelProgram.GetTargetState(startState, action, Set<string>.EmptySet, out transitionProperties);
if (IncludeTransition(startState, action, targetState, transitionProperties.Properties))
{
Transition t = new Transition(startState, action, targetState);
transitions.Add(t, t);
if (!states.ContainsKey(targetState) && !frontier.Contains(targetState))
frontier.AddFirst(targetState);
}
}
}
}
}
Term automatonInitialState = new Literal(states[initialState]);
Set<Term> automatonStates = Set<Term>.EmptySet;
Set<Term> acceptingStates = Set<Term>.EmptySet;
foreach (KeyValuePair<IState, int> kv in states)
{
Term automatonState = new Literal(kv.Value);
automatonStates = automatonStates.Add(automatonState);
if (modelProgram.IsAccepting(kv.Key))
acceptingStates = acceptingStates.Add(automatonState);
if (generatedStateMap != null)
generatedStateMap[automatonState] = kv.Key;
}
Set<Triple<Term, CompoundTerm, Term>> automatonTransitions = Set<Triple<Term, CompoundTerm, Term>>.EmptySet;
foreach (KeyValuePair<Transition, Transition> kv in transitions)
{
Transition t = kv.Key;
automatonTransitions = automatonTransitions.Add(new Triple<Term, CompoundTerm, Term>(new Literal(states[t.startState]),
t.action,
new Literal(states[t.targetState])));
}
return new FSM(automatonInitialState, automatonStates, automatonTransitions, acceptingStates);
}
public static FSM ProjectFromProduct(FSM finiteAutomaton, Set<Symbol> projectedSymbols, Sequence<Branch> treePosition, Dictionary<Term, IState>/*?*/ stateMap, out Dictionary<Term, IState>/*?*/ reductStateMap)
{
Set<IState> projectedIStates = finiteAutomaton.States.Convert<IState>(delegate(Term t) { return GetReduct(treePosition, stateMap[t]); });
Set<IState> projectedAcceptingIStates = finiteAutomaton.AcceptingStates.Convert<IState>(delegate(Term t) { return GetReduct(treePosition, stateMap[t]); });
reductStateMap = new Dictionary<Term, IState>();
Dictionary<IState, Term> reverseMap = new Dictionary<IState, Term>();
Term initialState = new Literal(0);
IState initialStateReduct = GetReduct(treePosition, stateMap[finiteAutomaton.InitialState]);
reductStateMap[initialState] = initialStateReduct;
reverseMap[initialStateReduct] = initialState;
int i = 1;
foreach (IState s in projectedIStates.Remove(initialStateReduct))
{
Term t = new Literal(i++);
reductStateMap[t] = s;
reverseMap[s] = t;
}
Set<Term> states = new Set<Term>(reductStateMap.Keys);
Set<Term> acceptingStates = projectedAcceptingIStates.Convert<Term>(delegate(IState x){return reverseMap[x];});
Set<Triple<Term, CompoundTerm, Term>> transitions =
finiteAutomaton.Transitions.Convert<Triple<Term, CompoundTerm, Term>>(
delegate(Triple<Term, CompoundTerm, Term> t)
{
return new Triple<Term, CompoundTerm, Term>(reverseMap[GetReduct(treePosition, stateMap[t.First])],
t.Second,
reverseMap[GetReduct(treePosition, stateMap[t.Third])]);
});
Set<Triple<Term, CompoundTerm, Term>> transitions1 =
transitions.Select(delegate(Triple<Term, CompoundTerm, Term> t)
{ return projectedSymbols.Contains(t.Second.Symbol); });
return new FSM(initialState, states, transitions1, acceptingStates, projectedSymbols);
}
Term Term()
{
Term result;
switch (nextToken.kind)
{
case Token.Kind.Integer:
result = new Literal(int.Parse(nextToken.value));
Next();
return result;
case Token.Kind.String:
result = new Literal(nextToken.value);
Next();
return result;
case Token.Kind.Boolean:
result = new Literal(bool.Parse(nextToken.value));
Next();
return result;
case Token.Kind.Null:
result = new Literal((string)null);
Next();
return result;
case Token.Kind.Wildcard:
Next();
return Any.Value;
case Token.Kind.Symbol:
{
Symbol symbol = ParseSymbol();
// take care of literals
if (AbstractValue.GetLiteralTypes().ContainsValue(symbol.Name)
&& symbol.Name != "string"
&& symbol.Name != "int"
&& symbol.Name != "bool")
{
Expect(Token.Kind.Open);
if (nextToken.kind != Token.Kind.String)
throw new SyntaxErrorException("saw " + nextToken.kind.ToString() + " where " +
Token.Kind.String.ToString() + " was expected");
string literalString = nextToken.value;
Next();
IComparable value;
bool flag = false;
switch (symbol.Name)
{
case "byte":
{
byte v;
flag = byte.TryParse(literalString, out v);
value = v;
break;
}
case "char":
{
char v;
flag = char.TryParse(literalString, out v);
value = v;
break;
}
case "double":
{
double v;
flag = double.TryParse(literalString, out v);
value = v;
break;
}
case "float":
{
float v;
flag = float.TryParse(literalString, out v);
value = v;
break;
}
case "long":
{
long v;
flag = long.TryParse(literalString, out v);
value = v;
break;
}
case "sbyte":
{
sbyte v;
flag = sbyte.TryParse(literalString, out v);
value = v;
break;
}
case "short":
{
short v;
flag = short.TryParse(literalString, out v);
value = v;
break;
}
case "uint":
{
uint v;
flag = uint.TryParse(literalString, out v);
value = v;
break;
}
case "ulong":
{
ulong v;
flag = ulong.TryParse(literalString, out v);
value = v;
break;
}
case "ushort":
{
ushort v;
flag = ushort.TryParse(literalString, out v);
value = v;
break;
}
default:
throw new SyntaxErrorException("saw unexpected token " + symbol.Name + " where " +
"name of literal type was expected (internal error)");
}
if (!flag)
throw new SyntaxErrorException("could not parse " + literalString + " as .NET type " + symbol.Name);
Expect(Token.Kind.Close);
return new Literal(value);
}
else if (nextToken.kind != Token.Kind.Open)
{
if (null != symbol.DomainParameters &&
symbol.DomainParameters != Sequence<Symbol>.EmptySequence)
throw new SyntaxErrorException("domain parameters not allowed in variable " + symbol.FullName);
string variableName = symbol.Name;
return new Variable(variableName);
}
else
{
Expect(Token.Kind.Open);
bool expectComma = false;
LinkedList<Term> arguments = new LinkedList<Term>();
while (nextToken.kind != Token.Kind.Close)
{
if (expectComma) Expect(Token.Kind.Comma);
Term arg = Term();
arguments.AddLast(arg);
expectComma = true;
}
Expect(Token.Kind.Close);
Term[] argsArray = new Term[arguments.Count];
arguments.CopyTo(argsArray, 0);
return new CompoundTerm(symbol, argsArray);
}
}
default:
throw new SyntaxErrorException("saw unexpected " + nextToken.kind.ToString());
}
}