/// <summary/>
public CompoundTerm DoAction(CompoundTerm action)
{
Config.init();
string s = action.ToString();
if (!c.isConnected())
{
c.Socket();
if (Config.logEnabled) { Logger.log("connect to " + Config.host + ":" + Config.port); }
c.Connect(Config.host, Config.port, Config.bufferSize);
}
if (resetDelayed)
{
if (Config.logEnabled) { Logger.log("delayed Reset on " + s); }
reset();
}
if (Config.logEnabled) { Logger.log("send " + s); }
c.Send(s + "\n");
s = receive();
if (Config.logEnabled) { Logger.log("rcvd " + s); }
if (s.Length == 0)
{
return null;
}
else
{
return CompoundTerm.Parse(s);
}
}
public Action DoAction(Action action)
{
switch (action.Name)
{
case ("CheckView"):
Set <string> modelView = (Set <string>)action[0];
Set <string> implView = new Set <string>(bag.table.Keys);
if (!modelView.Equals(implView))
{
throw new Exception("Inconsistent views of state: model:" +
modelView + " iut:" + implView);
}
return(null);
case ("Add"):
bag.Add((string)action[0]);
return(null);
case ("Delete"):
bag.Delete((string)action[0]);
return(null);
case ("Lookup_Start"):
return(Action.Create("Lookup_Finish", bag.Lookup((string)action[0])));
case ("Count_Start"):
return(Action.Create("Count_Finish", bag.Count));
default:
throw new Exception("Unexpected action " + action);
}
}
//ParameterizedThreadStart CallTheImplementationThreadStart = new ParameterizedThreadStart(CallTheImplementation);
Action DoAction(Action action, TimeSpan t)
{
ImplementationResultWrapper implRes = new ImplementationResultWrapper();
//Thread CallTheImplementationThread = new Thread(CallTheImplementationThreadStart);
//CallTheImplementationThread.Start(new object[] { impl, action, implRes});
//bool ok = CallTheImplementationThread.Join(t);
bool ok = worker.StartWork(CallTheImplementation,
new object[] { impl, action, implRes }, t);
if (!ok)
{
//CallTheImplementationThread.Abort();
throw new ConformanceTesterException("Action timed out"); //conformance failure
}
else
{
if (implRes.exception != null)
{
//rethrow the exception thrown by the implementation
//include only the message in the exception
throw new ConformanceTesterException(MakeQuotedString(implRes.exception.Message)); //conformance failure
}
else
{
return(implRes.implAction); //return either null or the following implementation action
}
}
}
public Action DoAction(Action action)
{
switch (action.Name)
{
case ("CheckView"):
Set<string> modelView = (Set<string>)action[0];
Set<string> implView = new Set<string>(bag.table.Keys);
if (!modelView.Equals(implView))
throw new Exception("Inconsistent views of state: model:" +
modelView + " iut:" + implView);
return null;
case ("Add"):
bag.Add((string)action[0]);
return null;
case ("Delete"):
bag.Delete((string)action[0]);
return null;
case ("Lookup_Start"):
return Action.Create("Lookup_Finish", bag.Lookup((string)action[0]));
case ("Count_Start"):
return Action.Create("Count_Finish", bag.Count);
default:
throw new Exception("Unexpected action " + action);
}
}
/// <summary>
/// Update the current state to the target state of the action from the current state.
/// If the action is the current action in the current test case, consume that action.
/// </summary>
/// <param name="action">given action</param>
public override void DoAction(CompoundTerm action)
{
base.DoAction(action);
if (!this.currentTest.IsEmpty && this.currentTest.Head.Equals(action))
{
this.currentTest = this.currentTest.Tail;
this.currentTestInProgress = true;
}
}
/// <summary>
/// Get coverage points from a given state and given action
/// </summary>
/// <param name="state">from given state</param>
/// <param name="action">given action</param>
/// <returns>coverage points</returns>
public Bag<Term> GetCoveragePoints(IState state, Action action)
{
TransitionProperties tprops;
mp.GetTargetState(state, action, transitionPropertyNames, out tprops);
Bag<Term> res = Bag<Term>.EmptyBag;
foreach (Bag<Term> props in tprops.Properties.Values)
res = res.Union(props);
return res;
}
internal MapViewer(string keyName, CompoundTerm t, bool isBag)
{
this.isBag = isBag;
this.t = t;
this.keyName = keyName;
this.argumentViewers = new TermViewer[t.Arguments.Count/2];
for (int i = 0; i < argumentViewers.Length; i++)
{
argumentViewers[i] = new MapletViewer(t.Arguments[2 * i], t.Arguments[(2 * i) + 1], isBag);
}
}
/// <summary>
/// Add a relational (i.e. unordered) transition into the graph.
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="label"></param>
public void AddRelationalTransition(Vertex from, Vertex to, String label)
{
VertexData vd = vertexRecords[from];
CompoundTerm edgeLabel = new CompoundTerm(new Symbol(label), new Sequence<Term>());
if (vd.unorderedOutgoingEdges.ContainsKey(edgeLabel))
{
vd.unorderedOutgoingEdges = vd.unorderedOutgoingEdges.Override(edgeLabel, vd.unorderedOutgoingEdges[edgeLabel].Add(to));
}
else
{
vd.unorderedOutgoingEdges = vd.unorderedOutgoingEdges.Add(edgeLabel, new Set<Vertex>(to));
}
}
/// <summary>
/// Get coverage points from a given state and given action
/// </summary>
/// <param name="state">from given state</param>
/// <param name="action">given action</param>
/// <returns>coverage points</returns>
public Bag <Term> GetCoveragePoints(IState state, Action action)
{
TransitionProperties tprops;
mp.GetTargetState(state, action, transitionPropertyNames, out tprops);
Bag <Term> res = Bag <Term> .EmptyBag;
foreach (Bag <Term> props in tprops.Properties.Values)
{
res = res.Union(props);
}
return(res);
}
static void CallTheImplementation(object implAndActionAndRes)
{
object[] args = (object[])implAndActionAndRes;
try
{
Action implAction = ((IStepper)args[0]).DoAction((Action)args[1]);
((ImplementationResultWrapper)args[2]).implAction = implAction;
}
catch (Exception e)
{
((ImplementationResultWrapper)args[2]).exception = e;
}
}
double GetReward(IState s, Action a)
{
Bag <CoveragePoint> cps = this.coveragePointProvider(s, a);
double totreward = 0;
foreach (CoveragePoint cp in cps)
{
int newCoverage = cps.CountItem(cp); //note this is >= 1
int oldCoverage = coveragePoints.CountItem(cp); //note this is >= 0
double reward = (newCoverage / (newCoverage + (oldCoverage * oldCoverage)));
totreward = totreward + reward;
}
return(totreward);
}
/// <summary>
/// Parses a symbol from the given string
/// </summary>
public static Symbol Parse(string representation)
{
if (representation == null)
{
throw new ArgumentNullException("representation");
}
try
{
Term term = Term.Parse(representation + "()");
CompoundTerm ct = (CompoundTerm)term;
return(ct.Symbol);
}
catch (ArgumentException)
{
throw;
}
}
public override CompoundTerm DoStep(InterpretationContext c, CompoundTerm action)
{
// Result of invocation must be a value term (must support IComparable)
IComparable/*?*/ thisArg;
IComparable/*?*/[] methodArgs = this.ConvertTermArgumentsToMethodArguments(c, action.Arguments, out thisArg);
foreach (IComparable/*?*/ o in methodArgs)
AbstractValue.FinalizeImport(o);
object/*?*/ resultObj = this.method.methodInfo.Invoke(thisArg, methodArgs);
CompoundTerm/*?*/ finishAction = null;
// Handle output args and return value
if (null != this.finishActionMethod)
{
int nOutputs = this.finishActionMethod.actionLabel.Arguments.Count;
Sequence<Term> outputs = Sequence<Term>.EmptySequence;
for (int i = 0; i < nOutputs; i += 1)
{
int outputArgIndex = this.finishActionMethod.outputArgumentIndices[i];
if (-2 == outputArgIndex) // "any" placeholder
outputs = outputs.AddLast(Any.Value);
else
{
object output = (-1 == outputArgIndex ? resultObj : methodArgs[outputArgIndex]);
IComparable outputAsComparable;
if (null == output)
outputAsComparable = null;
else
{
outputAsComparable = output as IComparable;
if (null == outputAsComparable)
throw new InvalidOperationException(MessageStrings.LocalizedFormat(MessageStrings.ComparableResultRequired, action.ToString(), output.ToString()));
}
outputs = outputs.AddLast(AbstractValue.GetTerm(outputAsComparable));
}
}
finishAction = new CompoundTerm(this.FinishAction, outputs);
}
return finishAction;
}
/// <summary>
/// Perform the action
/// </summary>
/// <param name="action">the given action</param>
/// <returns>the returned action (or null)</returns>
public CompoundTerm DoAction(CompoundTerm action)
{
switch (action.FunctionSymbol.ToString())
{
case "Insert":
{
Coin coin = GetCoin(action.Arguments[0]);
EmptyCoffeeMachineImpl.InsertACoin(coin);
return null;
}
case "Cancel":
{
Term coin = CompoundValue.GetTerm(EmptyCoffeeMachineImpl.Cancel());
return new CompoundTerm(Symbol.Parse("Return"), coin);
}
default:
throw new InvalidOperationException("Unrecognized action: " + action.ToString());
}
}
/// <summary>
/// Update the current state to the target state of the action from the current state.
/// Records coverage points of this transition.
/// </summary>
/// <param name="action">given action</param>
public override void DoAction(Action action)
{
System.Console.WriteLine("Action " + action.ToString());
int srcHash = this.currState.GetHashCode();
base.DoAction(action);
int targetHash = this.currState.GetHashCode();
if (this.ObservableActionSymbols.Contains(action.FunctionSymbol1))
{
AddPassiveEdge(srcHash, targetHash);
}
else
{
AddActiveEdge(srcHash, targetHash);
}
doValueIteration(bdt);
}
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));
}
public CompoundTerm DoAction(CompoundTerm action)
{
System.Console.WriteLine("robot" + action.Name + action.Arguments[0].ToString());
int id;
switch (action.FunctionSymbol.ToString())
{
case ("CreateRobot"):
id = (int)((CompoundTerm)action[0])[0];
impl.AddRobot(id);
return null;
case ("DeleteRobot"):
id = (int)((CompoundTerm)action[0])[0];
impl.KillRobot(id);
return null;
case ("Search"):
id = (int)((CompoundTerm)action[0])[0];
impl.Search(id);
return impl.Recharge(id);
case("Wait"):
id = (int)((CompoundTerm)action[0])[0];
impl.Wait(id);
return null;
/* case("Recharge"):
id = (int)((CompoundTerm)action[0])[0];
impl.Recharge(id);
return null;
*/
case("CheckState"):
id = (int)action[0];
if (id != impl.maxId)
throw new Exception("Wrong Number of Robots in Model and Implementation");
else
return null;
default:
throw new Exception("Unexpected action " + action);
}
}
public CompoundTerm DoAction(CompoundTerm action)
{
switch (action.Name)
{
case("Tests"): return null; // first action in test seq.
case("ServerSocket"):
s.Socket(); return null;
case("ServerBind"):
s.Bind(host,port); return null;
case("ServerListen"):
s.Listen(); return null;
case("ServerAccept"):
s.Accept(); return null;
case("ServerReceive"):
s.Receive(); return null;
case("ServerSend"):
// s.Send sends a double, not a string!
s.Send((double)((Literal) action.Arguments[0]).Value);
return null;
case("ServerCloseConnection"):
s.CloseConnection(); return null;
case("ServerClose"):
s.Close(); return null;
case("ClientSocket"):
c.Socket(); return null;
case("ClientConnect"):
c.Connect(host,port); return null;
case("ClientSend"):
c.Send("T"); return null;
case("ClientReceive_Start"):
// c.Receive returns a double, not a string
return CompoundTerm.Create("ClientReceive_Finish",
c.Receive());
case("ClientClose"):
c.Close(); return null;
default: throw new Exception("Unexpected action " + action);
}
}
public CompoundTerm DoAction(CompoundTerm compoundTerm)
{
Console.Out.Write("Press ");
switch (compoundTerm.Name)
{
case "PressMin_Sec":
Console.Out.WriteLine("Both Min and Sec");
return null;
case "PressMin":
Console.Out.WriteLine("Min");
return null;
case "PressSec":
Console.Out.WriteLine("Sec");
return null;
case "PressStartStop":
Console.Out.WriteLine("Start/Stop");
return null;
}
Console.Out.WriteLine("DoAction(" + compoundTerm.Name + ")");
return null;
}
/// <summary>
/// Perform the action
/// </summary>
/// <param name="action">the given action</param>
/// <returns>the returned action (or null)</returns>
public CompoundTerm DoAction(CompoundTerm action)
{
switch (action.FunctionSymbol.ToString())
{
case "SetPlayer1":
wh.Set(); // Signal the waiting thread to proceed (test-cases continue, don't exit)
Console.WriteLine("\nSetting Player1 to " + (string)action[0]);
runner.setPlayer("Player1", (string)action[0]);
return null;
case "SetPlayer2":
Console.WriteLine("\nSetting Player2 to " + (string)action[0]);
runner.setPlayer("Player2", (string)action[0]);
return null;
case "ReadLastResult_Start":
Console.WriteLine("\nChecking the results list-box");
Thread.Sleep(200);
return CompoundTerm.Create("ReadLastResult_Finish", runner.getLastResult());
default:
throw new InvalidOperationException("Unrecognized action: " + action.ToString());
}
}
/// <summary>
/// Update the current state to the target state of the action from the current state.
/// Records coverage points of this transition.
/// </summary>
/// <param name="action">given action</param>
public override void DoAction(Action action)
{
UpdateCoveragePoints(action);
int srcHash = this.currState.GetHashCode();
base.DoAction(action);
int targetHash = this.currState.GetHashCode();
if (!v.ContainsKey(targetHash))
{
v[targetHash] = 1.0;
}
if (this.ObservableActionSymbols.Contains(action.FunctionSymbol1))
{
AddPassiveEdge(srcHash, targetHash);
DoValueIteration(); // do value iteration when the probabilities change
}
else
{
bool doiter = false;
// do value iteration when a new active edge is added to the transition graph
if (!activeEdges.ContainsKey(srcHash))
{
doiter = true;
}
else if (!activeEdges[srcHash].Contains(targetHash))
{
doiter = true;
}
AddActiveEdge(srcHash, targetHash);
if (doiter)
{
DoValueIteration();
}
}
//foreach (int i in cov.Keys)
// if(cov[i]<1)
// System.Console.WriteLine("state : " + i + " cov " + cov[i]);
}
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);
}
public CompoundTerm DoAction(CompoundTerm action)
{
switch (action.FunctionSymbol.ToString()) {
case("Tests"): return null; // first action in test seq.
case ("SelectMessages"):
NewsReaderUI.SelectMessages(); return null;
case ("SelectTopics"):
NewsReaderUI.SelectTopics(); return null;
case ("ShowTitles"):
NewsReaderUI.ShowTitles(); return null;
case ("ShowText"):
NewsReaderUI.ShowText();
return null;
case ("SortByFirst"):
NewsReaderUI.SortByFirst();
return null;
case ("SortByMostRecent"):
NewsReaderUI.SortByMostRecent();
return null;
default:
throw new Exception("Unexpected action " + action);
}
}
/// <summary>
/// Select an action that is enabled in the current state
/// and whose action symbol is in the set <paramref name="actionSymbols"/>.
/// Use coverage points and reward policy.
/// </summary>
/// <param name="actionSymbols">set of candidate action symbols</param>
/// <returns>the chosen action or null if no choice is possible</returns>
public override Action SelectAction(Set <Symbol> actionSymbols)
{
if (actionSymbols == null)
{
throw new ArgumentNullException("actionSymbols");
}
if (actionSymbols.IsEmpty)
{
return(null);
}
Sequence <Action> actions = new Sequence <Action>(this.GetEnabledActions(actionSymbols));
if (actions.IsEmpty)
{
return(null);
}
Action a = ChooseAction(actions, this.CurrentState); //choose a tester action
return(a);
}
/// <summary>
/// Select an action that is enabled in the current state
/// and whose action symbol is in the set <paramref name="actionSymbols"/>.
/// Use coverage points and reward policy.
/// </summary>
/// <param name="actionSymbols">set of candidate action symbols</param>
/// <returns>the chosen action or null if no choice is possible</returns>
public override Action SelectAction(Set <Symbol> actionSymbols)
{
if (actionSymbols == null)
{
throw new ArgumentNullException("actionSymbols");
}
if (actionSymbols.IsEmpty)
{
return(null);
}
Sequence <Action> actions = new Sequence <Action>(this.GetEnabledActions(actionSymbols));
if (actions.IsEmpty)
{
return(null);
}
Action a = ChooseAction(actions, this.CurrentState); //choose a tester action
//System.Console.WriteLine("Chosen Action " + a.ToString());
return(a);
}
/// <summary>
/// Update the current state to the target state of the action from the current state.
/// Records coverage points of this transition.
/// </summary>
/// <param name="action">given action</param>
public override void DoAction(Action action)
{
UpdateCoveragePoints(action);
int srcHash = this.currState.GetHashCode();
base.DoAction(action);
int targetHash = this.currState.GetHashCode();
if (!v.ContainsKey(targetHash))
{
v[targetHash] = 1.0;
}
if (this.ObservableActionSymbols.Contains(action.FunctionSymbol1))
{
AddPassiveEdge(srcHash, targetHash);
DoValueIteration(); // do value iteration when the probabilities change
}
else
{
bool doiter = false;
// do value iteration when a new active edge is added to the transition graph
if (!activeEdges.ContainsKey(srcHash))
doiter = true;
else if (!activeEdges[srcHash].Contains(targetHash))
{
doiter = true;
}
AddActiveEdge(srcHash, targetHash);
if (doiter)
DoValueIteration();
}
//foreach (int i in cov.Keys)
// if(cov[i]<1)
// System.Console.WriteLine("state : " + i + " cov " + cov[i]);
}
private CompoundTerm ChooseAction(Sequence <Action> actions, IState iState)
{
Action maxAct = actions.Head;
int sState = iState.GetHashCode();
int tState;
IExtendedState iestate = (IExtendedState)iState;
int c = iestate.LocationValuesCount;
foreach (Action a in actions)
{
foreach (string s in this.modelProgram.GetEnablingConditionDescriptions(iState, a, false))
{
Term t = Term.Parse(s);
Sequence <Term> vars = (t.Arguments[0].Arguments);
Map <Variable, Term> subst = ConstructSubst(a, vars);
System.Console.WriteLine(a.ToString() + sState + " enabled string " + t.Arguments[1].Substitute(subst));
}
}
/*
* for (int i = 0; i < c; i++)
* {
* System.Console.WriteLine("name: "+iestate.GetLocationName(i) + " value : "+
* iestate.GetLocationValue(i) + " hash" +
* iestate.GetLocationValue(i).GetHashCode());
* CompoundValue t = (CompoundValue)iestate.GetLocationValue(i);
* foreach (CompoundValue t1 in t.FieldValues())
* {
* System.Console.WriteLine(" field " + t1.ToString());
* }
* }
*/
TransitionProperties tp;
int sum = 0;
Sequence <Pair <int, Action> > cumulActSum = Sequence <Pair <int, Action> > .EmptySequence;
Set <int> coveredActs = findCoveredActs(sState, actions);
if (!cov.ContainsKey(sState))
{
cov[sState] = 0.0;
}
Set <Action> newStateActs = new Set <Action>();
Set <Action> newActs = new Set <Action>();
Set <Action> oldActs = new Set <Action>(actions.Head);
foreach (Action a in actions)
{
tState = this.modelProgram.GetTargetState(iState, a, null, out tp).GetHashCode();
if (!v.ContainsKey(tState))
{
newStateActs = newStateActs.Add(a);
}
else if (!coveredActs.Contains(a.GetHashCode()))
{
newActs = newActs.Add(a);
}
else
{
// one greedy approach
/*
* if (v.ContainsKey(tState) && v[tState] > maxv)
* {
* maxv = v[tState];
* oldActs = new Set<Action>(a);
* }
* else if (v.ContainsKey(tState) && v[tState] == maxv)
* {
* oldActs = oldActs.Add(a);
* }*/
// probabilistic greedy approach
if (v.ContainsKey(tState))
{
sum = sum + (int)(v[tState] * Math.Pow(10.0, 9.0));
Pair <int, Action> np = new Pair <int, Action>(sum, a);
cumulActSum = cumulActSum.AddLast(np);
}
}
}
if (!newStateActs.IsEmpty)
{
maxAct = newStateActs.Choose();
System.Console.WriteLine("new action in new state " + maxAct.ToString());
}
else if (!newActs.IsEmpty)
{
maxAct = newActs.Choose();
System.Console.WriteLine("new action in old state " + maxAct.ToString());
}
else
{
//maxAct = oldActs.Choose();
Random rndNumbers = new Random();
int rndNumber = rndNumbers.Next(sum);
System.Console.WriteLine(sum + " " + rndNumber);
foreach (Pair <int, Action> np in cumulActSum)
{
System.Console.WriteLine(np.First + " " + np.Second.ToString());
if (rndNumber <= np.First)
{
maxAct = np.Second;
break;
}
maxAct = np.Second;
}
System.Console.WriteLine("old action in old state " + maxAct.ToString());
}
coveredActs = coveredActs.Add(maxAct.GetHashCode());
cov[sState] = (double)coveredActs.Count / (double)actions.Count;
return(maxAct);
}
/// <summary>
/// Parse the string into an action.
/// </summary>
/// <param name="s">given string representing of an action</param>
/// <returns>action represented by the string</returns>
new public static Action Parse(string s)
{
return((Action)CompoundTerm.Parse(s));
}
/// <summary>
/// Compute the weight of an action a in state s as 1000 * GetReward(s,a) as integer
/// </summary>
int GetWeight(IState s, Action a)
{
return Math.Max((int)GetReward(s, a) * 1000, 1);
}
double GetReward(IState s, Action a)
{
Bag<CoveragePoint> cps = this.coveragePointProvider(s, a);
double totreward = 0;
foreach (CoveragePoint cp in cps)
{
int newCoverage = cps.CountItem(cp); //note this is >= 1
int oldCoverage = coveragePoints.CountItem(cp); //note this is >= 0
double reward = (newCoverage / (newCoverage + (oldCoverage * oldCoverage)));
totreward = totreward + reward;
}
return totreward;
}
/// <summary>
/// Returns a bag containing a single coverage point that is a pair of integers
/// that are the hashcodes of the state and the action.
/// </summary>
static Bag<Term> DefaultCoveragePointProvider(IState state, CompoundTerm action)
{
return new Bag<Term>(new Pair<int, int>(state.GetHashCode(), action.GetHashCode()).AsTerm);
}
/// <summary>
/// Update the bag of coverage points seen so far, by adding
/// the coverage points provided by the transition labeled by action a from state s.
/// </summary>
internal void Update(IState s, Action a)
{
Bag<Term> cps = this.coveragePointProvider(s, a);
this.coveragePoints = this.coveragePoints.Union(cps);
}
/// <summary>
/// Update the current state to the target state of the action from the current state.
/// Records coverage points of this transition.
/// </summary>
/// <param name="action">given action</param>
public override void DoAction(Action action)
{
Update(this.CurrentState, action);
base.DoAction(action);
}
void CreateVariableWiewers()
{
//view also the control mode of the root state if the product has more than one machine in it
//the id of the composed state is -1
//if (leafStates.Count > 1)
// termViewers.Add(TermViewer.Create("[Control Mode]", rootState.ControlMode), -1);
for (int stateId = 0; stateId < this.leafStates.Count; stateId++)
{
IState leafState = this.leafStates[stateId];
//string modelName = this.modelNames[stateId];
//each state has a control mode, create a viewer for it if the controlMode is
//not an empty sequence
if (!leafState.ControlMode.ToCompactString().Equals("Sequence()"))
termViewers.Add(TermViewer.Create("[Control Mode]", leafState.ControlMode), stateId);
IExtendedState estate = leafState as IExtendedState;
if (estate != null)
{
#region add the domain map viewer, skip this if there are no domains
if (estate.DomainMap.Count > 0)
{
//StringBuilder sb = new StringBuilder();
Sequence<Term> args = Sequence<Term>.EmptySequence;
foreach (Pair<Symbol, int> si in estate.DomainMap)
{
args = args.AddLast(new Literal(si.First.FullName));
args = args.AddLast(new Literal(si.Second));
}
Symbol symb = Symbol.Parse("Map<String, Integer>");
Term domMap = new CompoundTerm(symb, args);
termViewers.Add(TermViewer.Create("[Domain Map]", domMap), stateId);
}
#endregion
//add a viewer for each state variable
for (int j = 0; j < estate.LocationValuesCount; j++)
{
termViewers.Add(TermViewer.Create(estate.GetLocationName(j),
estate.GetLocationValue(j)), stateId);
}
}
}
}
private CompoundTerm ChooseAction(Sequence <Action> actions, IState iState)
{
Set <int> coveredActs;
double minCov = 1.0;
double maxv = 0.0;
IState tState;
Action maxAct = actions.Head;
TransitionProperties tp;
if (!cov.ContainsKey(iState))
{
maxAct = actions.Choose();
cov[iState] = (1.0 / actions.Count);
v[iState] = 1.0;
// System.Console.WriteLine("inside if " + iState.GetHashCode() + " cov"+ cov[iState]);
return(maxAct);
}
else if (cov.ContainsKey(iState) && cov[iState] < 1.0)
{
coveredActs = new Set <int>(this.findCoveredActs(iState));
Set <int> acts = new Set <int>();
foreach (Action a in actions)
{
if (!coveredActs.Contains(a.GetHashCode()))
{
System.Console.WriteLine(a.GetHashCode());
tState = modelProgram.GetTargetState(iState, a, null, out tp);
if (!cov.ContainsKey(tState))
{
minCov = 0;
maxAct = a;
}
else if (cov[tState] <= minCov)
{
minCov = cov[tState];
maxAct = a;
}
}
else
{
acts.Add(a.GetHashCode());
tState = modelProgram.GetTargetState(iState, a, null, out tp);
if (v.ContainsKey(tState))
{
maxv = Math.Max(maxv, v[tState]);
}
}
}
acts = acts.Add(maxAct.GetHashCode());
cov[iState] = (acts.Count / actions.Count);
if (v.ContainsKey(iState))
{
v[iState] = Math.Min(v[iState], (alpha * maxv));
}
else
{
v[iState] = alpha * maxv;
}
//System.Console.WriteLine("inside <1.0 " + iState.GetHashCode() + " cov " + cov[iState]);
return(maxAct);
}
else if (cov.ContainsKey(iState) && cov[iState] == 1.0)
{
foreach (Action a in actions)
{
tState = modelProgram.GetTargetState(iState, a, null, out tp);
if (!cov.ContainsKey(tState))
{
maxv = 1.0;
maxAct = a;
}
else if (cov.ContainsKey(tState) && maxv <= v[tState])
{
maxv = v[tState];
maxAct = a;
}
}
if (v.ContainsKey(iState))
{
v[iState] = Math.Min(v[iState], (alpha * maxv));
}
else
{
v[iState] = alpha * maxv;
}
//System.Console.WriteLine("inside else " + iState.GetHashCode() + " " + v[iState]);
return(maxAct);
}
else
{
//System.Console.WriteLine("Should not be reachable!! cov" + cov[iState]);
return(maxAct);
}
}
// invariant: this.arity <= aInfo.arity when this in aInfo.actionMethods
protected ActionMethod(CompoundTerm actionLabel, Method method, int arity)
{
this.actionLabel = actionLabel;
this.method = method;
this.arity = arity;
}
/// <summary>
/// Hide the transition with the given action from the given node
/// </summary>
internal void HideTransition(Node node, CompoundTerm action)
{
this.hiddenTransitions = this.hiddenTransitions.Union(this.transitions.Select(delegate(Transition t) { return t.First.Equals(node) && t.Second.Equals(action); }));
this.transitions = this.transitions.Difference(this.hiddenTransitions);
}
/// <summary>
/// Show the transition with the given action from the given state
/// </summary>
internal void ShowTransition(Node sourceNode, CompoundTerm action)
{
Node targetNode;
if (TryGetTargetNode(sourceNode, action, out targetNode))
{
Transition t = new Triple<Term, CompoundTerm, Term>(sourceNode, action, targetNode);
this.transitions = this.transitions.Add(t);
this.hiddenTransitions = this.hiddenTransitions.Remove(t);
}
}
public abstract CompoundTerm DoStep(InterpretationContext c, CompoundTerm action);
private CompoundTerm ChooseAction(Sequence <Action> actions, IState iState)
{
TransitionProperties tp;
int targetId = -1;
List <double> MaxV = bdt.ReturnValue(true);
List <double> MinV = bdt.ReturnValue(false);
List <Set <int> > abstractMap = bdt.ReturnLeaves();
Sequence <Pair <int, Action> > cumulActSum = Sequence <Pair <int, Action> > .EmptySequence;
double epsilon = 0.1;
Dictionary <int, int> sumTarget = new Dictionary <int, int>();
Action maxAct = null;
int targetAbsId = -1;
int sum = 0;
UpdateRequirementMaps(actions, iState);
Set <Action> newStateActs = new Set <Action>();
Set <Action> oldActs = new Set <Action>(actions.Head);
foreach (Action a in actions)
{
int tState = this.modelProgram.GetTargetState(iState, a, null, out tp).GetHashCode();
targetAbsId = findAbstractId(tState, abstractMap);
if (targetAbsId == -1)
{
newStateActs = newStateActs.Add(a);
}
else
{
sum = sum + (int)(MaxV[targetAbsId] * Math.Pow(10.0, 9.0));
Pair <int, Action> np = new Pair <int, Action>(sum, a);
sumTarget.Add(sum, targetAbsId);
cumulActSum = cumulActSum.AddLast(np);
}
}
if (!newStateActs.IsEmpty)
{
maxAct = newStateActs.Choose();
System.Console.WriteLine("new action in new state " + maxAct.ToString());
return(maxAct);
}
else
{
Random rndNumbers = new Random();
int rndNumber = rndNumbers.Next(sum);
System.Console.WriteLine(sum + " " + rndNumber);
foreach (Pair <int, Action> np in cumulActSum)
{
System.Console.WriteLine(np.First + " " + np.Second.ToString());
if (rndNumber <= np.First)
{
maxAct = np.Second;
targetId = sumTarget[np.First];
break;
}
targetId = sumTarget[np.First];
maxAct = np.Second;
}
System.Console.WriteLine("old action in old state " + maxAct.ToString());
}
// Adaptive Refinement
if (MaxV[targetId] - MinV[targetId] > epsilon)
{
if (i < requirementProperties.Count)
{
string s1 = requirementProperties[i++];
bdt = bdt.Refine(s1, requireEnabledStateMap[s1]);
bdt.PrintTree(0);
}
}
return(maxAct);
}
/// <summary>
/// Compute the weight of an action a in state s as 1000 * GetReward(s,a) as integer
/// </summary>
int GetWeight(IState s, Action a)
{
return(Math.Max((int)GetReward(s, a) * 1000, 1));
}
/// <summary>
/// Update the current state to the target state of the action from the current state.
/// Records coverage points of this transition.
/// </summary>
/// <param name="action">given action</param>
public override void DoAction(Action action)
{
Update(this.CurrentState, action);
base.DoAction(action);
}
public new CompoundTerm DoAction(CompoundTerm action)
{
if (svthread == null) { startServer(); }
return base.DoAction(action);
}
/// <summary>
/// Update the bag of coverage points seen so far, by adding
/// the coverage points provided by the transition labeled by action a from state s.
/// </summary>
internal void Update(IState s, Action a)
{
Bag <Term> cps = this.coveragePointProvider(s, a);
this.coveragePoints = this.coveragePoints.Union(cps);
}
/// <summary>
/// Returns true if the action is a label of a visible transition from the given node
/// </summary>
internal bool IsActionVisible(Node node, CompoundTerm action)
{
return this.transitions.Exists(delegate(Transition t) { return t.First.Equals(node) && t.Second.Equals(action); });
}
readonly int[] inputArgumentIndices; // method arg position is index[ith action arg];
#endregion Fields
#region Constructors
// -1 means implicit this param
// -2 means Any.Value ("_")
public ActionMethodStart(CompoundTerm actionLabel, Method method, int arity, ActionMethodFinish/*?*/ finishActionMethod, int[] inputArgumentIndices)
: base(actionLabel, method, arity)
{
this.finishActionMethod = finishActionMethod;
this.inputArgumentIndices = inputArgumentIndices;
}
// 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);
}
/// <summary>
/// Run a single test case.
/// Returns the result of the test case, containing the action trace
/// </summary>
/// <param name="testNr">test case number</param>
/// <returns>test result</returns>
internal TestResult RunTestCase(int testNr)
{
Sequence <Action> testCase = Sequence <Action> .EmptySequence;
Action /*?*/ o = null;
// Requirements metrics
Bag <Pair <string, string> > executedRequirements = Bag <Pair <string, string> > .EmptyBag;
while ((this.stepsCnt <= 0) || testCase.Count < stepsCnt || (!model.IsInAcceptingState && (maxStepsCnt <= 0 || testCase.Count < maxStepsCnt)))
{
if (o != null || (IsAsync && !observations.IsEmpty))
{
#region there is an implementation action o to be checked
if (o == null)
{
o = observations.Dequeue();
}
testCase = testCase.AddLast(o); //record the action in the testCase
string failureReason = "";
if (model.IsActionEnabled(o, out failureReason)) //check conformance to the model
{
model.DoAction(o);
o = null; //consume the action
}
else
{
return(new TestResult(testNr, Verdict.Failure, failureReason, testCase, executedRequirements)); // Requirements metrics: ", executedRequirements"
}
#endregion
}
else
{
//use only cleanup actions when in cleanup phase
Set <Symbol> actionSymbols = (((stepsCnt <= 0) || testCase.Count < stepsCnt) ? this.testerActionSymbols : this.cleanupActionSymbols);
//select a tester action that is enabled in the current model state
Action testerAction = model.SelectAction(actionSymbols);
//if a tester action could be chosen
if (testerAction != null)
{
#region execute the tester action
//get the timespan within which calling impl with testerAction must return
TimeSpan t = (!internalActionSymbols.Contains(testerAction.Symbol) ?
this.testerActionTimeout(model.CurrentState, testerAction) : new TimeSpan());
//do the action in the model
model.DoAction(testerAction);
// Requirements metrics
string actionName = testerAction.Name;
foreach (string methodName in LibraryModelProgram.AllModeledRequirements.Keys)
{
// The methods names don't contain "_Start"
// when testerAction.Name == actionName_Start, remove the "_Start"
// in order to check it in AllModeledRequirements.Keys
if (actionName.Contains("_Start"))
{
actionName = actionName.Replace("_Start", "");
}
// I use 'Contains' to get all the enabled actions as well
if (methodName.Contains(actionName))
{
foreach (Pair <string, string> req in LibraryModelProgram.AllModeledRequirements[methodName])
{
executedRequirements = executedRequirements.Add(req);
}
}
}
//record the action in the testCase
testCase = testCase.AddLast(testerAction);
//call the implementation if the symbol is shared
if (!internalActionSymbols.Contains(testerAction.Symbol))
{
try
{
DateTime startAction = DateTime.Now; // Performance metrics
o = DoAction(testerAction, t); //if return value is non-null it will be checked next time around
// Requirements metrics
CalcPerformance(testerAction, startAction);
}
catch (ConformanceTesterException e)
{
return(new TestResult(testNr, Verdict.Failure, e.Message, testCase, executedRequirements)); //conformance failure // Requirements : ", executedRequirements"
}
}
#endregion
}
else
{
//otherwise, try to get an implementation action
if (IsAsync)
{
//get the Wait action from the model
Action w = model.SelectAction(waitActionSet);
int obsTimeout = (w == null ? 0 : (int)w[0]);
if (w != null)
{
testCase = testCase.AddLast(w);
model.DoAction(w);
}
if (!observations.TryDequeue(new TimeSpan(0, 0, 0, 0, obsTimeout), out o))
{
//if there are no tester actions and no observables but the
//model is in accepting state, the test succeeds
if (model.IsInAcceptingState)
{
return(new TestResult(testNr, Verdict.Success, "", testCase, executedRequirements));// Requirements metrics: ", executedRequirements"
}
else
{
o = timeoutAction;
}
}
}
else
{
//if there are no tester actions and no observables but the
//model is in accepting state, the test succeeds
if (model.IsInAcceptingState)
{
return(new TestResult(testNr, Verdict.Success, "", testCase, executedRequirements));// Requirements metrics: ", executedRequirements"
}
else
{
return(new TestResult(testNr, Verdict.Failure, "Run stopped in a non-accepting state", testCase, executedRequirements));// Requirements metrics: ", executedRequirements"
}
}
}
}
}
if (model.IsInAcceptingState)
{
return(new TestResult(testNr, Verdict.Success, "", testCase, executedRequirements));// Requirements metrics: ", executedRequirements"
}
else
{
return(new TestResult(testNr, Verdict.Failure, "Test run did not finish in accepting state", testCase, executedRequirements));// Requirements metrics: ", executedRequirements"
}
}
