public void TestSampleSymbolicRegexesMiscOptions()
{
CharSetSolver css = new CharSetSolver(BitWidth.BV16);
//--- ignore case
var r0 = css.RegexConverter.ConvertToSymbolicRegex("^foo$", RegexOptions.IgnoreCase);
Assert.IsTrue(r0.ToString().Equals("[Ff][Oo][Oo]"));
//--- ignore case locally
var r0b = css.RegexConverter.ConvertToSymbolicRegex("^f(?i:o)o$");
Assert.IsTrue(r0b.ToString().Equals("f[Oo]o"));
//--- multiline option
var r1 = css.RegexConverter.ConvertToSymbolicRegex(@"^foo\Z", RegexOptions.Multiline);
//var a1 = css.RegexConverter.Convert(@"^foo\Z", RegexOptions.Multiline);
//a1.ShowGraph("a1");
Assert.IsTrue(r1.ToString().Equals(@"(.*\n)?foo"));
//--------
var r2 = css.RegexConverter.ConvertToSymbolicRegex(@"^", RegexOptions.Multiline);
//var a2 = css.RegexConverter.Convert(@"^", RegexOptions.Multiline);
Assert.IsTrue(r2.ToString().Equals(@".*"));
//a2.ShowGraph("a2");
//--------
var r3 = css.RegexConverter.ConvertToSymbolicRegex(@"$", RegexOptions.Multiline);
//var a3 = css.RegexConverter.Convert(@"$", RegexOptions.Multiline);
//a3.ShowGraph("a3");
Assert.IsTrue(r3.ToString().Equals(@".*"));
//--------
var r4 = css.RegexConverter.ConvertToSymbolicRegex(@"^$", RegexOptions.Multiline);
var a4 = css.RegexConverter.Convert(@"^$", RegexOptions.Multiline);
var regex4 = new Regex(@"^$", RegexOptions.Multiline);
var regex4b = new Regex(@"^(.*\n)?(\n.*)?$", RegexOptions.Singleline);
var r4b = css.RegexConverter.ConvertToSymbolicRegex(@"^(.*\n)?(\n.*)?$", RegexOptions.Singleline);
//a4.ShowGraph("a4");
var a4min = a4.Determinize().Minimize();
//a4min.ShowGraph("a4min");
Assert.IsTrue(css.Accepts(a4min, ""));
Assert.IsTrue(regex4.IsMatch(""));
Assert.IsTrue(regex4b.IsMatch(""));
Assert.IsTrue(css.Accepts(a4min, "\n"));
Assert.IsTrue(regex4.IsMatch("\n"));
Assert.IsTrue(regex4b.IsMatch("\n"));
Assert.IsTrue(css.Accepts(a4min, "a\n"));
Assert.IsTrue(regex4.IsMatch("a\n"));
Assert.IsTrue(regex4b.IsMatch("a\n"));
Assert.IsTrue(css.Accepts(a4min, "a\n\nbcd"));
Assert.IsTrue(regex4.IsMatch("a\n\nbcd"));
Assert.IsTrue(regex4b.IsMatch("a\n\nbcd"));
//some negative cases
Assert.IsFalse(css.Accepts(a4min, "a\nbcd"));
Assert.IsFalse(regex4.IsMatch("a\nbcd"));
Assert.IsFalse(regex4.IsMatch("a\nbcd"));
Assert.IsTrue(r4b.ToString().Equals(@"(.*\n)?(\n.*)?"));
Assert.IsTrue(r4.ToString().Equals(@"(.*\n)?(\n.*)?"));
}
public void TestLoopThatStartsWith0()
{
string regex = @"(w(a|bc){0,2})";
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var aut = css.Convert(regex,RegexOptions.Singleline,true);
//css.ShowGraph(aut, "CornerCase");
var str = "w.-J_";
var actual = css.Accepts(aut, str);
var expected = Regex.IsMatch(str, regex);
Assert.AreEqual(expected, actual);
}
public void TestLoopThatStartsWith0()
{
string regex = @"(w(a|bc){0,2})";
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var aut = css.Convert(regex, RegexOptions.Singleline, true);
//css.ShowGraph(aut, "CornerCase");
var str = "w.-J_";
var actual = css.Accepts(aut, str);
var expected = Regex.IsMatch(str, regex);
Assert.AreEqual(expected, actual);
}
public void TestWordBoundary()
{
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var regex = @"\b(@|A)B\b";
Assert.IsTrue(Regex.IsMatch("AB", regex));
Assert.IsTrue(Regex.IsMatch("A@B", regex));
Assert.IsTrue(Regex.IsMatch("A@B&", regex));
Assert.IsTrue(Regex.IsMatch("+AB+", regex));
Assert.IsFalse(Regex.IsMatch("@B", regex));
Assert.IsFalse(Regex.IsMatch("A@B_", regex));
var aut = css.Convert(regex);//.RemoveEpsilons(css.MkOr).Determinize(css).Minimize(css);
//css.ShowGraph(aut, "aut");
Assert.IsTrue(css.Accepts(aut, "AB"));
Assert.IsTrue(css.Accepts(aut, "A@B"));
Assert.IsTrue(css.Accepts(aut, "A@B&"));
Assert.IsTrue(css.Accepts(aut, "+AB+"));
Assert.IsFalse(css.Accepts(aut, "@B"));
Assert.IsFalse(css.Accepts(aut, "A@B_"));
CheckValidity(css, aut, new Regex(regex, RegexOptions.Singleline));
}
public void TestWordBoundaryCase()
{
string s = "abc";
string r = @"\b";
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var aut = css.Convert(r, RegexOptions.Singleline, true);
//css.ShowGraph(aut, "test1");
css.RegexConverter.EliminateBoundaryStates(aut);
//css.ShowGraph(aut,"test2");
Assert.IsTrue(css.Accepts(aut, s));
Assert.IsTrue(Regex.IsMatch(s, r, RegexOptions.Singleline));
}
//returns true iff dfa accepts str
private static bool Accepts(Automaton <BDD> dfa1, string str, HashSet <char> al, CharSetSolver solver)
{
return(solver.Accepts(dfa1, str));
//int currState = dfa1.InitialState;
//for (int i = 0; i < str.Length; i++)
//{
// currState = GetNextState(currState, str[i], dfa1, solver);
// if (currState < 0)
// return false;
//}
//return dfa1.GetFinalStates().ToList().Contains(currState);
}
public void TestTrivialWordBoundary4()
{
Regex r = new Regex(@"^\b[A@]\b$", RegexOptions.None);
CharSetSolver css = new CharSetSolver(BitWidth.BV16);
var aut = css.Convert(r.ToString(), RegexOptions.Singleline, true);
//css.ShowGraph(aut, "TrivialWordBoundary4_with_b");
css.RegexConverter.EliminateBoundaryStates(aut);
var aut1 = aut.RemoveEpsilons().Determinize().Minimize();
//css.ShowGraph(aut, "TrivialWordBoundary4");
string s = "@";
bool ismatchExpected = r.IsMatch(s);
bool ismatchActual = css.Accepts(aut1, s);
CheckValidity(css, aut, r);
}
/*
* IsYieldTypeSafe :
* 2.1 Input parameters :
* 2.1.1 Automaton<BvSet> implTypeCheckAutomaton : This input Automaton is generated for a phase of YTS checking of an impl.
* 2.2 Return value : returns true if input automaton is subset of YTS property autoamaton.
* 2.3 Action : Subset checking for a phase of an implementation. f L(YTSI) is subset of L(YTSP) {TRUE} else {FALSE}
*/
public static bool IsYieldTypeSafe(Automaton <BvSet> implTypeCheckAutomaton, Implementation impl, MoverTypeChecker moverTypeChecker, int phaseNum)
{
List <BvSet> witnessSet;
var isNonEmpty = Automaton <BvSet> .CheckDifference(
implTypeCheckAutomaton,
yieldTypeCheckerAutomaton,
0,
yieldTypeCheckerAutomatonSolver,
out witnessSet);
#if DEBUG && !DEBUG_DETAIL
var diffAutomaton = implTypeCheckAutomaton.Minus(yieldTypeCheckerAutomaton, yieldTypeCheckerAutomatonSolver);
string diffAutomatonGraphName = "diffAutomaton" + impl.Proc.Name + phaseNum.ToString();
yieldTypeCheckerAutomatonSolver.ShowGraph(diffAutomaton, diffAutomatonGraphName + ".dgml");
#endif
#if DEBUG && !DEBUG_DETAIL
string s = yieldTypeCheckerAutomatonSolver.GenerateMember(implTypeCheckAutomaton);
Console.WriteLine("\n member " + s + " \n");
if (!yieldTypeCheckerAutomatonSolver.Accepts(yieldTypeCheckerAutomaton, s))
{
Console.WriteLine("Property Automaton accepts a random member of impl_automaton " + s);
}
else
{
Console.WriteLine("Property Automaton does not accept a random member of impl_automaton " + s);
}
#endif
if (isNonEmpty)
{
var witness = new String(Array.ConvertAll(witnessSet.ToArray(), bvset => (char)yieldTypeCheckerAutomatonSolver.Choose(bvset)));
moverTypeChecker.Error(impl, "\n Body of " + impl.Proc.Name + " has invalid trace of actions " + witness + "\n");
return(false);
}
return(true);
}
public void TestWordBoundaryCase()
{
string s = "abc";
string r = @"\b";
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var aut = css.Convert(r,RegexOptions.Singleline,true);
//css.ShowGraph(aut, "test1");
css.RegexConverter.EliminateBoundaryStates(aut);
//css.ShowGraph(aut,"test2");
Assert.IsTrue(css.Accepts(aut, s));
Assert.IsTrue(Regex.IsMatch(s, r, RegexOptions.Singleline));
}
public void TestWordBoundary()
{
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var regex = @"\b(@|A)B\b";
Assert.IsTrue(Regex.IsMatch("AB", regex));
Assert.IsTrue(Regex.IsMatch("A@B", regex));
Assert.IsTrue(Regex.IsMatch("A@B&", regex));
Assert.IsTrue(Regex.IsMatch("+AB+", regex));
Assert.IsFalse(Regex.IsMatch("@B", regex));
Assert.IsFalse(Regex.IsMatch("A@B_", regex));
var aut = css.Convert(regex);//.RemoveEpsilons(css.MkOr).Determinize(css).Minimize(css);
//css.ShowGraph(aut, "aut");
Assert.IsTrue(css.Accepts(aut, "AB"));
Assert.IsTrue(css.Accepts(aut, "A@B"));
Assert.IsTrue(css.Accepts(aut, "A@B&"));
Assert.IsTrue(css.Accepts(aut, "+AB+"));
Assert.IsFalse(css.Accepts(aut, "@B"));
Assert.IsFalse(css.Accepts(aut, "A@B_"));
CheckValidity(css, aut, new Regex(regex, RegexOptions.Singleline));
}
public void TestTrivialWordBoundary4()
{
Regex r = new Regex(@"^\b[A@]\b$",RegexOptions.None);
CharSetSolver css = new CharSetSolver(BitWidth.BV16);
var aut = css.Convert(r.ToString(), RegexOptions.Singleline, true);
//css.ShowGraph(aut, "TrivialWordBoundary4_with_b");
css.RegexConverter.EliminateBoundaryStates(aut);
var aut1 = aut.RemoveEpsilons().Determinize().Minimize();
//css.ShowGraph(aut, "TrivialWordBoundary4");
string s = "@";
bool ismatchExpected = r.IsMatch(s);
bool ismatchActual = css.Accepts(aut1, s);
CheckValidity(css, aut, r);
}
//returns true iff dfa accepts str
private static bool Accepts(Automaton<BDD> dfa1, string str, HashSet<char> al, CharSetSolver solver)
{
return solver.Accepts(dfa1, str);
//int currState = dfa1.InitialState;
//for (int i = 0; i < str.Length; i++)
//{
// currState = GetNextState(currState, str[i], dfa1, solver);
// if (currState < 0)
// return false;
//}
//return dfa1.GetFinalStates().ToList().Contains(currState);
}
