/// <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);
}
}
/// <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);
}
/// <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());
}
}
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>
/// Produces the target state that results from invoking <paramref name="action"/>
/// in the context of <paramref name="startState"/>.
/// </summary>
/// <param name="startState">The state in which the action is invoked</param>
/// <param name="action">The action to be invoked</param>
/// <param name="transitionPropertyNames">The names of meta-properties to be collected
/// during the calculation of the step.</param>
/// <param name="transitionProperties">Output parameter that will contain a
/// map of property names to property values. Each property value multiset of
/// terms. For example, the property value might be the value of a Boolean function
/// that controls state filtering. Or, it might correspond to the "coverage" of the model that results from this
/// step. In this case, the value might denote the line numbers or blocks of the
/// model program that were exercised in this step, or a projection of the state
/// space or a reference to section numbers of a requirements document to indicate
/// that the functionality defined by that section was exercised.</param>
/// <returns>The state that results from the invocation of <paramref name="action"/>
/// in <paramref name="startState"/>.</returns>
/// <seealso cref="GetTransitionPropertyNames"/>
public override IState GetTargetState(IState startState, CompoundTerm action, Set<string> transitionPropertyNames,
out TransitionProperties transitionProperties)
{
transitionProperties = new TransitionProperties();
FsmState fs = startState as FsmState;
if (fs == null)
throw new ArgumentException("Invalid state");
Set<Term> targetAutomatonStates = Set<Term>.EmptySet;
foreach (Term automatonState in fs.AutomatonStates)
{
Set<Transition> outgoing = this.automaton.OutgoingTransitions(automatonState);
foreach (Transition t in outgoing)
{
CompoundTerm ct = t.Second as CompoundTerm;
if (ct == null) throw new InvalidOperationException("Internal error, invalid transition. FSM transition action symbol is null in "+t.ToString());
if (IsCompatibleTerm(action, ct)) //(Object.Equals(ct, action))
{
targetAutomatonStates = targetAutomatonStates.Add(t.Third);
}
}
}
if (targetAutomatonStates.Equals(Set<Term>.EmptySet))
throw new ArgumentException("Action not enabled: " + action.ToString());
return new FsmState(targetAutomatonStates);
}
static Set<string> GetUnusedArguments(Set<string> defaultArguments, CompoundTerm action)
{
Set<string> result = defaultArguments;
foreach (Term arg in action.Arguments)
{
if (!arg.Equals(Any.Value))
{
Variable v = arg as Variable;
if (null == v)
throw new ModelProgramUserException("invalid argument for action " + action.ToString() +
": " + arg.ToString());
string name = v.ToString();
if (!defaultArguments.Contains(name))
throw new ModelProgramUserException("invalid (possibly misspelled) argument for action " + action.ToString() +
": " + arg.ToString() + ". Must be one of " + defaultArguments.ToString() + ".");
result = result.Remove(name);
}
}
return result;
}
static void CheckForDuplicateArgument(CompoundTerm action)
{
Set<Term> argsSoFar = Set<Term>.EmptySet;
foreach (Term arg in action.Arguments)
{
if (argsSoFar.Contains(arg))
throw new ModelProgramUserException("action label " + action.ToString() + " contains duplicate argument " + arg.ToString());
else if (!Any.Value.Equals(arg))
{
argsSoFar = argsSoFar.Add(arg);
}
}
}
/// <summary>
/// Computes the mapping from the parameter positions of the action label to the
/// output parameter positions of the .NET method that implements the action.
/// </summary>
/// <param name="actionLabel">The finish action label</param>
/// <param name="actionMethod">The action method</param>
/// <returns>An array of integers where each entry is the index in the parameter list
/// of the .NET method. The special value -1 is used to indicate the position of the the
/// return value. The special value -2 is used to indicate an ignored argument.</returns>
internal static int[] GetOutputParameterIndices(CompoundTerm actionLabel, MethodInfo actionMethod)
{
List<int> parameterIndices = new List<int>();
foreach (Term arg in actionLabel.Arguments)
{
if (Any.Value == arg)
parameterIndices.Add(-2);
else
{
Variable v = arg as Variable;
if (null != v)
{
string name = v.ToString();
if ("result".Equals(name))
parameterIndices.Add(-1);
else
{
int index = 0;
bool foundMatch = false;
foreach (ParameterInfo pInfo in actionMethod.GetParameters())
{
if (pInfo.Name.Equals(name))
{
parameterIndices.Add(index);
foundMatch = true;
break;
}
index += 1;
}
// this test is dead code (was previously checked).
if (!foundMatch)
throw new ModelProgramUserException("action label " + actionLabel.ToString() +
" includes unrecognized output argument " + name);
}
}
else
{
throw new ModelProgramUserException("action label " + actionLabel.ToString() +
" may not include ground term " + arg.ToString());
}
}
}
return parameterIndices.ToArray();
}
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>
/// 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);
}
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>
/// Returns true if the action is enabled in the current state.
/// If the action is not enabled, provides a reason in <paramref name="failureReason"/>.
/// </summary>
/// <param name="action">action whose enabledness is being checked</param>
/// <param name="failureReason">failure reason if the action is not enabled</param>
/// <returns>true if the action is enabled, false otherwise</returns>
public bool IsActionEnabled(CompoundTerm action, out string failureReason)
{
if (!AllActionSymbols.Contains(action.Symbol))
{
failureReason = "Action symbol '" + action.Symbol.ToString() + "' not enabled in the model";
return false;
}
else
{
bool isEnabled = modelProgram.IsEnabled(currState, action);
if (!isEnabled)
{
failureReason = "Action '" + ConformanceTester.MakeQuotedString(action.ToString()) + "' not enabled in the model";
foreach (string s in modelProgram.GetEnablingConditionDescriptions(currState, action, true))
{
failureReason += "\n";
failureReason += s;
}
return false;
}
else
{
failureReason = "";
return true;
}
}
}
