private List<ConfigurationBase> MakeOneMove(ConfigurationBase currentStep) { List<ConfigurationBase> listResult = new List<ConfigurationBase>(); IEnumerable<ConfigurationBase> list = currentStep.MakeOneMove(); foreach (ConfigurationBase step in list) { bool contains = false; foreach (ConfigurationBase dest in listResult) { if (dest.Event == step.Event) { contains = true; break; } } //duplicated steps should not be added in. if (!contains) { listResult.Add(step); } } return listResult; }
/// <summary> /// This method checks whether the found counterexample is spurious or not. /// This checking only works for abstraction for parameterized systems. /// </summary> /// <returns></returns> protected virtual bool IsCounterExampleSpurious() { Stack <ConfigurationBase> working = new Stack <ConfigurationBase>(1024); List <ConfigurationBase> ConcreteCounterExampleTrace = new List <ConfigurationBase>(64); working.Push(InitialStep); Stack <int> depthStack = new Stack <int>(1024); depthStack.Push(0); List <int> depthList = new List <int>(1024); StringHashTable visited = new StringHashTable(1024); visited.Add("0-" + InitialStep.GetID()); do { ConfigurationBase current = working.Pop(); int depth = depthStack.Pop(); if (depth > 0) { while (depthList[depthList.Count - 1] >= depth) { int lastIndex = depthList.Count - 1; depthList.RemoveAt(lastIndex); ConcreteCounterExampleTrace.RemoveAt(lastIndex); } } ConcreteCounterExampleTrace.Add(current); depthList.Add(depth); if (ConcreteCounterExampleTrace.Count == VerificationOutput.CounterExampleTrace.Count) { VerificationOutput.CounterExampleTrace = ConcreteCounterExampleTrace; Ultility.Ultility.CutNumber = 2; return(false); } else { ConfigurationBase abstractStep = VerificationOutput.CounterExampleTrace[depth + 1]; IEnumerable <ConfigurationBase> steps = current.MakeOneMove(abstractStep.Event); //for (int j = 0; j < steps.Length; j++) foreach (ConfigurationBase step in steps) { if (abstractStep.EqualsV(step)) { string tmp = (depth + 1) + "-" + step.GetID(); if (!visited.ContainsKey(tmp)) { working.Push(step); depthStack.Push(depth + 1); visited.Add(tmp); } } } } } while (working.Count > 0); return(true); }
public bool IsDivergent() { Stack <ConfigurationBase> working = new Stack <ConfigurationBase>(); List <string> path = new List <string>(100); StringHashTable visited = new StringHashTable(100); //The following are for identifying the current path. Stack <int> depthStack = new Stack <int>(1024); depthStack.Push(0); List <int> depthList = new List <int>(1024); //The above are for identifying the current path. working.Push(this); visited.Add(GetID()); while (working.Count > 0) { ConfigurationBase current = working.Pop(); IEnumerable <ConfigurationBase> nextStates = current.MakeOneMove(Constants.TAU); //The following are for identifying the current path. int depth = depthStack.Pop(); if (depth > 0) { while (depthList[depthList.Count - 1] >= depth) { int lastIndex = depthList.Count - 1; depthList.RemoveAt(lastIndex); path.RemoveAt(lastIndex); } } path.Add(current.GetID()); depthList.Add(depth); if (nextStates != null) { //for (int i = 0; i < nextStates.Length; i++) foreach (ConfigurationBase next in nextStates) { //ConfigurationBase next = nextStates[i]; string ID = next.GetID(); if (path.Contains(ID)) { return(true); } else { if (!visited.ContainsKey(ID)) { visited.Add(ID); working.Push(next); depthStack.Push(depth + 1); } } } } } return(false); }