public void TestDoubleCompile4() { var f = new ZenFunction <int, int, int, int, int>((i1, i2, i3, i4) => 1); f.Compile(); f.Compile(); Assert.AreEqual(1, f.Evaluate(0, 0, 0, 0)); }
public void TestDoubleCompile0() { var f = new ZenFunction <int>(() => 1); f.Compile(); f.Compile(); Assert.AreEqual(1, f.Evaluate()); }
public void TestIndexOfEvaluation(string s, string sub, int offset, int expected) { var f = new ZenFunction <string, BigInteger>(s => s.IndexOf(sub, new BigInteger(offset))); Assert.AreEqual((short)expected, f.Evaluate(s)); f.Compile(); Assert.AreEqual((short)expected, f.Evaluate(s)); }
public void TestContainsEvaluation(string s, string sub, bool expected) { var f = new ZenFunction <string, string, bool>((s1, s2) => s1.Contains(s2)); Assert.AreEqual(expected, f.Evaluate(s, sub)); f.Compile(); Assert.AreEqual(expected, f.Evaluate(s, sub)); }
public void TestSubstringEvaluation(string s, int offset, int length, string expected) { var f = new ZenFunction <string, string>(s => s.Substring(new BigInteger(offset), new BigInteger(length))); Assert.AreEqual(expected, f.Evaluate(s)); f.Compile(); Assert.AreEqual(expected, f.Evaluate(s)); }
public void TestLengthEvaluation(string s, int expected) { var f = new ZenFunction <string, BigInteger>(s => s.Length()); Assert.AreEqual(new BigInteger(expected), f.Evaluate(s)); f.Compile(); Assert.AreEqual(new BigInteger(expected), f.Evaluate(s)); }
public void TestReplaceEvaluation(string s, string sub, string replace, string expected) { var f = new ZenFunction <string, string>(s => s.ReplaceFirst(sub, replace)); Assert.AreEqual(expected, f.Evaluate(s)); f.Compile(); Assert.AreEqual(expected, f.Evaluate(s)); }
public void TestDictionaryEvaluateOutput() { var f = new ZenFunction <int, int, Dict <int, int> >((x, y) => EmptyDict <int, int>().Add(x, y)); var d = f.Evaluate(1, 2); // Assert.AreEqual(1, d.Count); Assert.AreEqual(2, d.Get(1)); f.Compile(); d = f.Evaluate(1, 2); Assert.AreEqual(2, d.Get(1)); }
/// <summary> /// Check that the backends agree on the result. /// </summary> /// <param name="function">The function.</param> public static void CheckAgreement(Func <Zen <bool> > function) { foreach (var p in parameters) { var f = new ZenFunction <bool>(function); var result = f.Assert(o => Simplify(o, p), backend: p.Backend); Assert.AreEqual(f.Evaluate(), result); f.Compile(); Assert.AreEqual(f.Evaluate(), result); } }
public void TestAtEvaluation(string s, int index, string expected) { var f = new ZenFunction <string, BigInteger, string>((s, idx) => s.At(idx)); Assert.AreEqual(expected, f.Evaluate(s, (ushort)index)); f.Compile(); Assert.AreEqual(expected, f.Evaluate(s, (ushort)index)); if (expected != "") { var x = f.Find((str, idx, o) => And(str == s, o == expected)); Assert.AreEqual(x.Value.Item2, new BigInteger(index)); } }
/// <summary> /// Check that a predicate is not valid. /// </summary> /// <typeparam name="T1">First input type.</typeparam> /// <typeparam name="T2">Second input type.</typeparam> /// <param name="function">The predicate.</param> public static void CheckNotValid <T1, T2>(Func <Zen <T1>, Zen <T2>, Zen <bool> > function) { var selectedParams = SetParameters(typeof(T1), typeof(T2)); foreach (var p in selectedParams) { var f = new ZenFunction <T1, T2, bool>(function); var result = f.Find((i1, i2, o) => Simplify(Not(o), p), listSize: p.ListSize, backend: p.Backend); Assert.IsTrue(result.HasValue); // compare input with evaluation Assert.IsTrue(f.Evaluate(result.Value.Item1, result.Value.Item2)); f.Compile(); Assert.IsTrue(f.Evaluate(result.Value.Item1, result.Value.Item2)); } }
public static void Main(string[] args) { Console.WriteLine("Hello World!"); Zen <int> Multi(Zen <int> x, Zen <int> y) { return(3 * x + y); } ZenFunction <int, int, int> function = Function <int, int, int>(Multi); function.Compile(); var output = function.Evaluate(3, 2); // output = 11 var input = function.Find((x, y, result) => And(x <= 0, result == 11)); Console.WriteLine(input.ToString()); }
/// <summary> /// Check that the backends agree on the result. /// </summary> /// <param name="function">The function.</param> public static void CheckAgreement <T1>(Func <Zen <T1>, Zen <bool> > function) { var selectedParams = SetParameters(typeof(T1)); foreach (var p in selectedParams) { var f = new ZenFunction <T1, bool>(function); var result = f.Find((i1, o) => Simplify(o, p), listSize: p.ListSize, backend: p.Backend); if (result.HasValue) { Assert.IsTrue(f.Evaluate(result.Value)); f.Compile(); Assert.IsTrue(f.Evaluate(result.Value)); } } }
public void TestMultiplication() { var f = new ZenFunction <int, int, bool>((a, b) => a * b == 10); var inputs = f.Find((a, b, res) => res, backend: ModelChecking.Backend.Z3); Assert.IsTrue(inputs.HasValue); Assert.AreEqual(10, inputs.Value.Item1 * inputs.Value.Item2); Assert.IsTrue(f.Evaluate(5, 2)); Assert.IsTrue(f.Evaluate(1, 10)); Assert.IsFalse(f.Evaluate(4, 3)); f.Compile(); Assert.IsTrue(f.Evaluate(5, 2)); Assert.IsTrue(f.Evaluate(1, 10)); Assert.IsFalse(f.Evaluate(4, 3)); }
static void evaluateReachability(DVP dvp, List <Tuple <int, int> > failedLinks = null) { if (failedLinks == null) { failedLinks = new List <Tuple <int, int> >(); } ZenFunction <SimplePacket, IList <Tuple <int, int> >, bool> f = Function <SimplePacket, IList <Tuple <int, int> >, bool>(dvp.Forward); f.Compile(); Console.WriteLine("Evaluating output"); var correct_input = new SimplePacket { SrcIp = new Ip { Value = 1 }, DstIp = new Ip { Value = 2 }, }; var wrong_input = new SimplePacket { SrcIp = new Ip { Value = 0 }, DstIp = new Ip { Value = 0 }, }; Console.WriteLine("Evaluating correct input: \t" + correct_input); var output = f.Evaluate(correct_input, failedLinks); Console.WriteLine("\t Reachable? " + output); Console.WriteLine("Evaluating wrong input: \t" + wrong_input); output = f.Evaluate(wrong_input, failedLinks); Console.WriteLine("\t Reachable? " + output); Console.WriteLine(); }
/// <summary> /// Check a predicate is valid. /// </summary> /// <typeparam name="T1">First input type..</typeparam> /// <typeparam name="T2">Second input type.</typeparam> /// <typeparam name="T3">Third input type.</typeparam> /// <typeparam name="T4">Fourth input input.</typeparam> /// <param name="function">The predicate.</param> public static void CheckValid <T1, T2, T3, T4>(Func <Zen <T1>, Zen <T2>, Zen <T3>, Zen <T4>, Zen <bool> > function) { var selectedParams = SetParameters(typeof(T1), typeof(T2), typeof(T3), typeof(T4)); foreach (var p in selectedParams) { // prove that it is valid var f = new ZenFunction <T1, T2, T3, T4, bool>(function); var result = f.Find((i1, i2, i3, i4, o) => Simplify(Not(o), p), listSize: p.ListSize, backend: p.Backend); Assert.IsFalse(result.HasValue); // compare input with evaluation result = f.Find((i1, i2, i3, i4, o) => Simplify(o, p), listSize: p.ListSize, backend: p.Backend); Assert.IsTrue(result.HasValue); Assert.IsTrue(f.Evaluate(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4)); f.Compile(); Assert.IsTrue(f.Evaluate(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4)); } }
static void findLinks(DVP dvp, bool desired_result, SimplePacket packet) { Console.WriteLine("findLinks"); ZenFunction <SimplePacket, IList <Tuple <int, int> >, bool> f = Function <SimplePacket, IList <Tuple <int, int> >, bool>(dvp.Forward); f.Compile(); // Console.WriteLine("Using FindAll"); // Console.WriteLine("Number of packets that cannot be delivered in the network:"); var input = f.FindAll((pkt, failed_links, result) => And( And( And( And( pkt.GetDstIp().GetField <Ip, uint>("Value") == packet.DstIp.Value, pkt.GetSrcIp().GetField <Ip, uint>("Value") == packet.SrcIp.Value ), pkt.GetDstIp() != pkt.GetSrcIp()), result == desired_result), // For DVP, no route requires more then two links to fail (no multiple path routing) // Therefore, we limit length to 1 here failed_links.Length() == 1)); Console.WriteLine("\tCount:\t" + input.Count()); //Console.WriteLine(); //Console.WriteLine(input); if (input.Count() != 0) { Console.WriteLine("\tPrinting inputs:"); foreach (var x in input) { Console.Write("\t\t" + x.Item1 + " with List ["); foreach (var i in x.Item2) { Console.Write(i + ", "); } Console.WriteLine("]"); } } }
/// <summary> /// Check a predicate is valid. /// </summary> /// <typeparam name="T1">First input type..</typeparam> /// <typeparam name="T2">Second input type.</typeparam> /// <param name="function">The predicate.</param> public static void CheckValid <T1, T2>(Func <Zen <T1>, Zen <T2>, Zen <bool> > function) { // If testing on strings, only use Z3 backend (DD does not support strings) var selectedParams = SetParameters(typeof(T1), typeof(T2)); foreach (var p in selectedParams) { // prove that it is valid var f = new ZenFunction <T1, T2, bool>(function); var result = f.Find((i1, i2, o) => Simplify(Not(o), p), listSize: p.ListSize, backend: p.Backend); Assert.IsFalse(result.HasValue); // compare input with evaluation result = f.Find((i1, i2, o) => Simplify(o, p), listSize: p.ListSize, backend: p.Backend); Assert.IsTrue(result.HasValue); Assert.IsTrue(f.Evaluate(result.Value.Item1, result.Value.Item2)); f.Compile(); Assert.IsTrue(f.Evaluate(result.Value.Item1, result.Value.Item2)); } }
static void findPackets(DVP dvp, bool desired_result, List <Tuple <int, int> > failedLinks = null) { if (failedLinks == null) { failedLinks = new List <Tuple <int, int> >(); } Console.WriteLine("findPackets"); ZenFunction <SimplePacket, IList <Tuple <int, int> >, bool> f = Function <SimplePacket, IList <Tuple <int, int> >, bool>(dvp.Forward); f.Compile(); // Console.WriteLine("Using FindAll"); // Console.WriteLine("Number of packets that cannot be delivered in the network:"); Console.WriteLine(failedLinks); var input = f.FindAll((pkt, failed_links, result) => And( And( And( And( pkt.GetDstIp().GetField <Ip, uint>("Value") < 7, pkt.GetSrcIp().GetField <Ip, uint>("Value") < 7 ), pkt.GetDstIp() != pkt.GetSrcIp()), result == desired_result), failed_links == failedLinks)); Console.WriteLine("\tCount:\t" + input.Count()); //Console.WriteLine(); //Console.WriteLine(input); if (input.Count() != 0) { Console.WriteLine("\tPrinting inputs:"); foreach (var x in input) { Console.WriteLine("\t\t" + x); } } }
public void TestCompilation() { var f = new ZenFunction <Int3, Int3, Int3>((x, y) => x + y); f.Compile(); Assert.AreEqual(new Int3(3), f.Evaluate(new Int3(1), new Int3(2))); f = new ZenFunction <Int3, Int3, Int3>((x, y) => x - y); f.Compile(); Assert.AreEqual(new Int3(1), f.Evaluate(new Int3(3), new Int3(2))); f = new ZenFunction <Int3, Int3, Int3>((x, y) => x | y); f.Compile(); Assert.AreEqual(new Int3(3), f.Evaluate(new Int3(3), new Int3(2))); f = new ZenFunction <Int3, Int3, Int3>((x, y) => x & y); f.Compile(); Assert.AreEqual(new Int3(2), f.Evaluate(new Int3(3), new Int3(2))); f = new ZenFunction <Int3, Int3, Int3>((x, y) => x ^ y); f.Compile(); Assert.AreEqual(new Int3(1), f.Evaluate(new Int3(3), new Int3(2))); }