public void ChooseUnifromlyTest()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD set1 = solver.MkRangeConstraint('\0', '\x01', true);
BDD set2 = solver.MkRangeConstraint('\u0FFF', '\u0FFF');
string set2str = solver.PrettyPrint(set2);
BDD set3 = solver.MkRangeConstraint('\u00FF', '\u00FF');
BDD set4 = solver.MkRangeConstraint('\u000F', '\u000F');
BDD set = solver.MkOr(new BDD[] { set2, set3, set4, set1 });
string setstr = solver.PrettyPrint(set);
set.ToDot(@"foo.dot");
var map = new Dictionary <char, int>();
map['\0'] = 0;
map['\x01'] = 0;
map['\u0FFF'] = 0;
map['\u00FF'] = 0;
map['\u000F'] = 0;
for (int i = 0; i < 50000; i++)
{
var c = solver.ChooseUniformly(set);
map[c] += 1;
}
foreach (var kv in map)
{
Assert.IsTrue(kv.Value > 9700);
}
}
public void TestIgnoreCaseTransformer()
{
CharSetSolver solver = new CharSetSolver();
int t = System.Environment.TickCount;
IgnoreCaseTransformer ic = new IgnoreCaseTransformer(solver);
//simple test first:
BDD a2c = solver.MkRangeConstraint('a', 'c');
BDD a2cA2C = ic.Apply(a2c);
BDD a2cA2C_expected = a2c.Or(solver.MkRangeConstraint('A', 'C'));
Assert.AreEqual <BDD>(a2cA2C, a2cA2C_expected);
//
//comprehensive test:
//
//test that the whole array is correct:
// Microsoft.Automata.Generated.IgnoreCaseRelation.ignorecase
// (generated by:)
//
// IgnoreCaseRelationGenerator.Generate(
// "Microsoft.Automata.Generated",
// "IgnoreCaseRelation",
// @"C:\GitHub\AutomataDotNet\Automata\src\Automata\Internal\Generated");
//
//test that all characters in it are truly equivalent wrt the igore-case option of regex
//
for (int i = 0; i <= 0xFFFF; i++)
{
char c = (char)i;
if (ic.IsInDomain(c))
{
BDD cC = ic.Apply(solver.MkCharConstraint(c));
foreach (char d in solver.GenerateAllCharacters(cC))
{
Assert.IsTrue(Regex.IsMatch(d.ToString(), "^(?i:" + StringUtility.Escape(c) + ")$"));
}
}
}
//
//second, test that all characters outside the domain are only equivalent (up-to-case) to themsevles
//
// for some reson this does not succeed, ??? some characters, e.g. '\xF7', are
// equivalent to some other characters in the below test, but not when tested individually
// there is a bug in Regex.IsMatch with ignore-case combined with intervals
//
//for (int i = 2; i <= 0xFFFD; i++)
//{
// char c = (char)i;
// if (!ic.IsInDomain(c))
// {
// if (Regex.IsMatch(c.ToString(), @"^([\0-" + StringUtility.Escape((char)(i - 1)) + StringUtility.Escape((char)(i + 1)) + @"-\uFFFF])$", RegexOptions.IgnoreCase))
// Console.WriteLine(StringUtility.Escape(c));
// }
//}
}
public void GenerateMintermsTest1()
{
CharSetSolver bddb = new CharSetSolver(BitWidth.BV16);
BDD a = bddb.MkRangeConstraint('a', 'a');
BDD b = bddb.MkRangeConstraint('b', 'b');
BDD c = bddb.MkRangeConstraint('c', 'c');
var combinations = new List <Pair <bool[], BDD> >(bddb.GenerateMinterms(new BDD[] { a, b, c }));
Assert.AreEqual <int>(4, combinations.Count);
}
public void TestIgnoreCaseTransformer()
{
CharSetSolver solver = new CharSetSolver();
int t = System.Environment.TickCount;
IgnoreCaseTransformer ic = new IgnoreCaseTransformer(solver);
//simple test first:
BDD a2c = solver.MkRangeConstraint('a', 'c');
BDD a2cA2C = ic.Apply(a2c);
BDD a2cA2C_expected = a2c.Or(solver.MkRangeConstraint('A', 'C'));
Assert.AreEqual<BDD>(a2cA2C, a2cA2C_expected);
//
//comprehensive test:
//
//test that the whole array is correct:
// Microsoft.Automata.Internal.Generated.IgnoreCaseRelation.ignorecase
// (generated by:)
//
// IgnoreCaseRelationGenerator.Generate(
// "Microsoft.Automata.Internal.Generated",
// "IgnoreCaseRelation",
// @"C:\GitHub\AutomataDotNet\Automata\src\Automata\Internal\Generated");
//
//test that all characters in it are truly equivalent wrt the igore-case option of regex
//
for (int i = 0; i <= 0xFFFF; i++)
{
char c = (char)i;
if (ic.IsInDomain(c))
{
BDD cC = ic.Apply(solver.MkCharConstraint(c));
foreach (char d in solver.GenerateAllCharacters(cC))
{
Assert.IsTrue(Regex.IsMatch(d.ToString(), "^(?i:" + StringUtility.Escape(c) + ")$"));
}
}
}
//
//second, test that all characters outside the domain are only equivalent (up-to-case) to themsevles
//
// for some reson this does not succeed, ??? some characters, e.g. '\xF7', are
// equivalent to some other characters in the below test, but not when tested individually
// there is a bug in Regex.IsMatch with ignore-case combined with intervals
//
//for (int i = 2; i <= 0xFFFD; i++)
//{
// char c = (char)i;
// if (!ic.IsInDomain(c))
// {
// if (Regex.IsMatch(c.ToString(), @"^([\0-" + StringUtility.Escape((char)(i - 1)) + StringUtility.Escape((char)(i + 1)) + @"-\uFFFF])$", RegexOptions.IgnoreCase))
// Console.WriteLine(StringUtility.Escape(c));
// }
//}
}
public void GenerateMintermsTest2()
{
CharSetSolver bddb = new CharSetSolver(BitWidth.BV16);
BDD a = bddb.MkRangeConstraint('b', 'c');
BDD b = bddb.MkRangeConstraint('b', 'b');
BDD b2 = bddb.MkRangeConstraint('b', 'b');
BDD c = bddb.MkRangeConstraint('c', 'c');
BDD b3 = bddb.MkRangeConstraint('b', 'b');
var combinations = new List <Pair <bool[], BDD> >(bddb.GenerateMinterms(new BDD[] { a, b, b2, c, b3 }));
Assert.AreEqual <int>(3, combinations.Count, "only three combinations are possible");
}
public void ChooseUnifromlyTest()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD set1 = solver.MkRangeConstraint('\0', '\x01', true);
BDD set2 = solver.MkRangeConstraint( '\u0FFF', '\u0FFF');
string set2str = solver.PrettyPrint(set2);
BDD set3 = solver.MkRangeConstraint( '\u00FF', '\u00FF');
BDD set4 = solver.MkRangeConstraint( '\u000F', '\u000F');
BDD set = solver.MkOr(new BDD[]{set2, set3, set4, set1});
string setstr = solver.PrettyPrint(set);
set.ToDot(@"foo.dot");
var map = new Dictionary<char, int>();
map['\0'] = 0;
map['\x01'] = 0;
map['\u0FFF'] = 0;
map['\u00FF'] = 0;
map['\u000F'] = 0;
for (int i = 0; i < 50000; i++)
{
var c = solver.ChooseUniformly(set);
map[c] += 1;
}
foreach (var kv in map)
Assert.IsTrue(kv.Value > 9700);
}
public void ChooseTest()
{
for (int i = 0; i < 10; i++)
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD set1 = solver.MkRangeConstraint('a', 'c', true);
string set1str = solver.PrettyPrint(set1);
BDD set2 = solver.MkRangeConstraint('a', 'c');
string set2str = solver.PrettyPrint(set2);
BDD set3 = solver.MkRangeConstraint('A', 'C');
string set3str = solver.PrettyPrint(set3);
BDD set1a = solver.MkOr(set2, set3);
Assert.AreEqual <string>("[A-Ca-c]", set1str);
Assert.AreEqual <string>("[a-c]", set2str);
Assert.AreEqual <string>("[A-C]", set3str);
int h1 = set1.GetHashCode();
int h2 = set1a.GetHashCode();
bool same = (h1 == h2);
Assert.AreSame(set1, set1a);
Assert.IsTrue(same);
Assert.IsTrue(solver.AreEquivalent(set1, set1a));
//int seed = solver.Chooser.RandomSeed;
char choice1 = (char)solver.Choose(set1);
char choice2 = (char)solver.Choose(set1);
char choice3 = (char)solver.Choose(set1);
char choice4 = (char)solver.Choose(set1);
//solver.Chooser.RandomSeed = seed;
//char choice1a = solver.Choose(set1a);
//char choice2a = solver.Choose(set1a);
//char choice3a = solver.Choose(set1a);
//char choice4a = solver.Choose(set1a);
//string s = new String(new char[] { choice1, choice2, choice3, choice4 });
//string sa = new String(new char[] { choice1a, choice2a, choice3a, choice4a });
//Assert.AreEqual<string>(s, sa);
}
}
public HelperPredicates(CharSetSolver solver, bool OptimzeForAsciiInput)
{
this.solver = solver;
helper_predicates = new List <string>();
predicate_cache = new Dictionary <BDD, string>();
ascii = solver.MkRangeConstraint('\0', '\x7F');
this.OptimzeForASCIIinput = OptimzeForAsciiInput;
}
public void ChooseTest2()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD set1 = solver.MkRangeConstraint('a', 'a', true);
string set1str = solver.PrettyPrint(set1);
BDD set2 = solver.MkRangeConstraint('a', 'a');
string set2str = solver.PrettyPrint(set2);
BDD set3 = solver.MkRangeConstraint('A', 'A');
string set3str = solver.PrettyPrint(set3);
BDD set1a = solver.MkOr(set2, set3);
Assert.AreEqual<string>("[Aa]", set1str);
Assert.AreEqual<string>("a", set2str);
Assert.AreEqual<string>("A", set3str);
}
public HelperPredicates(CharSetSolver solver, bool OptimzeForAsciiInput)
{
this.solver = solver;
helper_predicates = new List<string>();
predicate_cache = new Dictionary<BDD, string>();
ascii = solver.MkRangeConstraint('\0', '\x7F');
this.OptimzeForASCIIinput = OptimzeForAsciiInput;
}
public void ChooseTest2()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD set1 = solver.MkRangeConstraint('a', 'a', true);
string set1str = solver.PrettyPrint(set1);
BDD set2 = solver.MkRangeConstraint('a', 'a');
string set2str = solver.PrettyPrint(set2);
BDD set3 = solver.MkRangeConstraint('A', 'A');
string set3str = solver.PrettyPrint(set3);
BDD set1a = solver.MkOr(set2, set3);
Assert.AreEqual <string>("[Aa]", set1str);
Assert.AreEqual <string>("a", set2str);
Assert.AreEqual <string>("A", set3str);
}
public void ChooseTest()
{
for (int i = 0; i < 10; i++)
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD set1 = solver.MkRangeConstraint('a', 'c', true);
string set1str = solver.PrettyPrint(set1);
BDD set2 = solver.MkRangeConstraint('a', 'c');
string set2str = solver.PrettyPrint(set2);
BDD set3 = solver.MkRangeConstraint( 'A', 'C');
string set3str = solver.PrettyPrint(set3);
BDD set1a = solver.MkOr(set2, set3);
Assert.AreEqual<string>("[A-Ca-c]",set1str);
Assert.AreEqual<string>("[a-c]", set2str);
Assert.AreEqual<string>("[A-C]", set3str);
int h1 = set1.GetHashCode();
int h2 = set1a.GetHashCode();
bool same = (h1 == h2);
Assert.AreSame(set1, set1a);
Assert.IsTrue(same);
Assert.IsTrue(solver.AreEquivalent(set1, set1a));
//int seed = solver.Chooser.RandomSeed;
char choice1 = (char)solver.Choose(set1);
char choice2 = (char)solver.Choose(set1);
char choice3 = (char)solver.Choose(set1);
char choice4 = (char)solver.Choose(set1);
//solver.Chooser.RandomSeed = seed;
//char choice1a = solver.Choose(set1a);
//char choice2a = solver.Choose(set1a);
//char choice3a = solver.Choose(set1a);
//char choice4a = solver.Choose(set1a);
//string s = new String(new char[] { choice1, choice2, choice3, choice4 });
//string sa = new String(new char[] { choice1a, choice2a, choice3a, choice4a });
//Assert.AreEqual<string>(s, sa);
}
}
public void GenerateMintermsTest4()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV7);
BDD a = solver.MkRangeConstraint('\0', '\x7E');
BDD b = solver.MkRangeConstraint('1', '1');
BDD c = solver.MkRangeConstraint('1', '3');
var Z = new List <Pair <bool[], BDD> >(solver.GenerateMinterms(new BDD[] { a, b, c })).ToArray();
var Y = Array.ConvertAll(Z, x => x.Second);
var X = new HashSet <BDD>(Y);
Assert.AreEqual <int>(4, X.Count);
Assert.IsTrue(X.Contains(solver.MkRangeConstraint('1', '1')));
Assert.IsTrue(X.Contains(solver.MkRangeConstraint('2', '3')));
Assert.IsTrue(X.Contains(solver.MkRangesConstraint(false, new char[][] { new char[] { '\x7F', '\x7F' } })));
Assert.IsTrue(X.Contains(solver.MkRangesConstraint(false, new char[][] { new char[] { '4', '\x7E' }, new char[] { '\0', '0' } })));
}
public void TestIgnoreCaseTransformer_SimpleCases()
{
CharSetSolver solver = new CharSetSolver();
int t = System.Environment.TickCount;
IgnoreCaseTransformer ic = new IgnoreCaseTransformer(solver);
//simple test first:
BDD a2c = solver.MkRangeConstraint('a', 'c');
BDD a2cA2C = ic.Apply(a2c);
BDD a2cA2C_expected = a2c.Or(solver.MkRangeConstraint('A', 'C'));
Assert.AreEqual <BDD>(a2cA2C, a2cA2C_expected);
//digits are not changed
BDD ascii_digits = solver.MkRangeConstraint('0', '9');
BDD ascii_digits1 = ic.Apply(ascii_digits);
Assert.AreEqual <BDD>(ascii_digits1, ascii_digits);
var tt = ic.Apply(solver.True);
var tt_compl = solver.MkNot(tt);
Assert.AreEqual <BDD>(ic.Apply(solver.True), solver.True);
}
public void GenerateMintermsTest3()
{
CharSetSolver bddb = new CharSetSolver(BitWidth.BV16);
BDD A = bddb.MkRangeConstraint('1', '4');
BDD A1 = bddb.MkRangesConstraint(false, new char[][] { new char[] { '1', '3' }, new char[] { '3', '4' } });
BDD B = bddb.MkRangesConstraint(false, new char[][] { new char[] { '2', '3' }, new char[] { '5', '6' }, new char[] { '8', '8' } });
BDD C = bddb.MkRangesConstraint(false, new char[][] { new char[] { '3', '4' }, new char[] { '6', '7' }, new char[] { '9', '9' } });
BDD D = bddb.MkRangesConstraint(false, new char[][] { new char[] { '0', '0' }, new char[] { '8', '9' } });
var combinations = new List <Pair <bool[], BDD> >(bddb.GenerateMinterms(new BDD[] { A, B, C, A1, D }));
Assert.AreEqual <int>(11, combinations.Count, "exactly 11 combinations must be possible");
}
public void GenerateMintermsTest4()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV7);
BDD a = solver.MkRangeConstraint( '\0', '\x7E');
BDD b = solver.MkRangeConstraint( '1', '1');
BDD c = solver.MkRangeConstraint( '1', '3');
var Z = new List<Pair<bool[], BDD>>(solver.GenerateMinterms(new BDD[] { a, b, c })).ToArray();
var Y = Array.ConvertAll(Z, x => x.Second);
var X = new HashSet<BDD>(Y);
Assert.AreEqual<int>(4, X.Count);
Assert.IsTrue(X.Contains(solver.MkRangeConstraint( '1', '1')));
Assert.IsTrue(X.Contains(solver.MkRangeConstraint( '2', '3')));
Assert.IsTrue(X.Contains(solver.MkRangesConstraint(false, new char[][] {new char[] { '\x7F', '\x7F' } })));
Assert.IsTrue(X.Contains(solver.MkRangesConstraint(false, new char[][] { new char[] { '4', '\x7E' }, new char[] { '\0', '0' } })));
}
public void GenerateMintermsTest3()
{
CharSetSolver bddb = new CharSetSolver(BitWidth.BV16);
BDD A = bddb.MkRangeConstraint( '1', '4');
BDD A1 = bddb.MkRangesConstraint(false, new char[][] { new char[] { '1', '3' }, new char[] { '3', '4' }});
BDD B = bddb.MkRangesConstraint(false, new char[][] { new char[] { '2', '3' }, new char[] { '5', '6' }, new char[] { '8', '8' } });
BDD C = bddb.MkRangesConstraint(false, new char[][] { new char[] { '3', '4' }, new char[] { '6', '7' }, new char[] { '9', '9' } });
BDD D = bddb.MkRangesConstraint(false, new char[][] { new char[] { '0', '0' }, new char[] { '8', '9' } });
var combinations = new List<Pair<bool[], BDD>>(bddb.GenerateMinterms(new BDD[] { A, B, C, A1, D }));
Assert.AreEqual<int>(11, combinations.Count, "exactly 11 combinations must be possible");
}
public void GenerateMintermsTest2()
{
CharSetSolver bddb = new CharSetSolver(BitWidth.BV16);
BDD a = bddb.MkRangeConstraint( 'b', 'c');
BDD b = bddb.MkRangeConstraint( 'b', 'b');
BDD b2 = bddb.MkRangeConstraint( 'b', 'b');
BDD c = bddb.MkRangeConstraint( 'c', 'c');
BDD b3 = bddb.MkRangeConstraint( 'b', 'b');
var combinations = new List<Pair<bool[], BDD>>(bddb.GenerateMinterms(new BDD[] { a, b, b2, c, b3 }));
Assert.AreEqual<int>(3, combinations.Count, "only three combinations are possible");
}
public void GenerateMintermsTest1()
{
CharSetSolver bddb = new CharSetSolver(BitWidth.BV16);
BDD a = bddb.MkRangeConstraint( 'a', 'a');
BDD b = bddb.MkRangeConstraint( 'b', 'b');
BDD c = bddb.MkRangeConstraint( 'c', 'c');
var combinations = new List<Pair<bool[], BDD>>(bddb.GenerateMinterms(new BDD[] { a, b, c }));
Assert.AreEqual<int>(4, combinations.Count);
}
