diff --git a/Source/CSharp/Expressive/Expressive.Tests/ExpressionTests.cs b/Source/CSharp/Expressive/Expressive.Tests/ExpressionTests.cs
index 8d4bcba..1df084c 100644
--- a/Source/CSharp/Expressive/Expressive.Tests/ExpressionTests.cs
+++ b/Source/CSharp/Expressive/Expressive.Tests/ExpressionTests.cs
@@ -163,27 +163,6 @@ public void RelationalTests()
             // Dates can be parsed to string.
             Assert.AreEqual(true, new Expression("[date1] == '2016-01-01'").Evaluate(new Dictionary<string, object> { ["date1"] = new DateTime(2016, 01, 01) }));
             Assert.AreEqual(true, new Expression("[date1] == '01/01/2016 00:00:00'").Evaluate(new Dictionary<string, object> { ["date1"] = new DateTime(2016, 01, 01) }));
-
-            // Null safety
-            Assert.AreEqual(true, new Expression("[number1] == null").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(false, new Expression("[number1] == null").Evaluate(new Dictionary<string, object> { ["number1"] = 2 }));
-            Assert.AreEqual(false, new Expression("[number1] != null").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(true, new Expression("[number1] != null").Evaluate(new Dictionary<string, object> { ["number1"] = 2 }));
-            Assert.AreEqual(true, new Expression("[number1] <> 2").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(null, new Expression("[number1] >= 2").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(null, new Expression("[number1] > 2").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(null, new Expression("[number1] <= 2").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(null, new Expression("[number1] < 2").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-
-            Assert.AreEqual(true, new Expression("null == [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(false, new Expression("null == [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = 2 }));
-            Assert.AreEqual(false, new Expression("null != [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(true, new Expression("null != [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = 2 }));
-            Assert.AreEqual(true, new Expression("2 <> [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(null, new Expression("2 >= [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(null, new Expression("2 > [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(null, new Expression("2 <= [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
-            Assert.AreEqual(null, new Expression("2 < [number1]").Evaluate(new Dictionary<string, object> { ["number1"] = null }));
         }
 
         [TestMethod]
diff --git a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/EqualExpressionTests.cs b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/EqualExpressionTests.cs
index b1c3590..cd43dbb 100644
--- a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/EqualExpressionTests.cs
+++ b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/EqualExpressionTests.cs
@@ -1,89 +1,39 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Relational;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Relational
 {
-    [TestClass]
-    public class EqualExpressionTests
+    public static class EqualExpressionTests
     {
-        [TestMethod]
-        public void TestBothNull()
+        [TestCase(null, null, true)]
+        [TestCase(5, 5, true)]
+        [TestCase(5, 2, false)]
+        [TestCase(2, 5, false)]
+        [TestCase(null, "abc", false)]
+        [TestCase("abc", null, false)]
+        [TestCase("abc", "abc", true)]
+        [TestCase(null, false, false)]
+        [TestCase(false, null, false)]
+        [TestCase(true, false, false)]
+        [TestCase(true, true, true)]
+        [TestCase(false, false, true)]
+        [TestCase(false, true, false)]
+        [TestCase(1.001, 1, false)]
+        [TestCase(1, 1.001, false)]
+        [TestCase(1.001, 1.001, true)]
+        [TestCase(1, 1.00, true)]
+        [TestCase(1.00, 1, true)]
+        public static void TestEvaluate(object lhs, object rhs, object expectedValue)
         {
             var expression = new EqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == lhs),
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == rhs),
                 new Context(ExpressiveOptions.None));
 
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestEqual()
-        {
-            var expression = new EqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLeftNull()
-        {
-            var expression = new EqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)"abc"),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestNotEqual()
-        {
-            var expression = new EqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestRightNull()
-        {
-            var expression = new EqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)false),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatUnequal()
-        {
-            var expression = new EqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatEqual()
-        {
-            var expression = new EqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.00),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
+            Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
         }
     }
 }
diff --git a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/GreaterThanExpressionTests.cs b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/GreaterThanExpressionTests.cs
index edbb37b..5805284 100644
--- a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/GreaterThanExpressionTests.cs
+++ b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/GreaterThanExpressionTests.cs
@@ -1,102 +1,39 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Relational;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Relational
 {
-    [TestClass]
-    public class GreaterThanExpressionTests
+    public static class GreaterThanExpressionTests
     {
-        [TestMethod]
-        public void TestBothNull()
-        {
-            var expression = new GreaterThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestEqual()
-        {
-            var expression = new GreaterThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestGreaterThan()
-        {
-            var expression = new GreaterThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLeftNull()
-        {
-            var expression = new GreaterThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)"abc"),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLessThan()
-        {
-            var expression = new GreaterThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestRightNull()
-        {
-            var expression = new GreaterThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)false),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatTrue()
-        {
-            var expression = new GreaterThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatFalse()
-        {
-            var expression = new GreaterThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
+        [TestCase(null, null, false)]
+        [TestCase(5, 5, false)]
+        [TestCase(5, 2, true)]
+        [TestCase(2, 5, false)]
+        [TestCase(null, "abc", false)]
+        [TestCase("abc", null, true)]
+        [TestCase("abc", "abc", false)]
+        [TestCase(null, false, false)]
+        [TestCase(false, null, true)]
+        [TestCase(true, false, true)]
+        [TestCase(true, true, false)]
+        [TestCase(false, false, false)]
+        [TestCase(false, true, false)]
+        [TestCase(1.001, 1, true)]
+        [TestCase(1, 1.001, false)]
+        [TestCase(1.001, 1.001, false)]
+        [TestCase(1, 1.00, false)]
+        [TestCase(1.00, 1, false)]
+        public static void TestEvaluate(object lhs, object rhs, object expectedValue)
+        {
+            var expression = new GreaterThanExpression(
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == lhs),
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == rhs),
+                new Context(ExpressiveOptions.None));
+
+            Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
         }
-
-
     }
 }
diff --git a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/GreaterThanOrEqualExpressionTests.cs b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/GreaterThanOrEqualExpressionTests.cs
index 93924a2..0bfaaf3 100644
--- a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/GreaterThanOrEqualExpressionTests.cs
+++ b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/GreaterThanOrEqualExpressionTests.cs
@@ -1,111 +1,39 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Relational;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Relational
 {
-    [TestClass]
-    public class GreaterThanOrEqualExpressionTests
+    public static class GreaterThanOrEqualExpressionTests
     {
-        [TestMethod]
-        public void TestBothNull()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestEqual()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestGreaterThan()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLeftNull()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)"abc"),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLessThan()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestRightNull()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)false),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatEqual()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.0),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatTrue()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatFalse()
-        {
-            var expression = new GreaterThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
+        [TestCase(null, null, true)]
+        [TestCase(5, 5, true)]
+        [TestCase(5, 2, true)]
+        [TestCase(2, 5, false)]
+        [TestCase(null, "abc", false)]
+        [TestCase("abc", null, true)]
+        [TestCase("abc", "abc", true)]
+        [TestCase(null, false, false)]
+        [TestCase(false, null, true)]
+        [TestCase(true, false, true)]
+        [TestCase(true, true, true)]
+        [TestCase(false, false, true)]
+        [TestCase(false, true, false)]
+        [TestCase(1.001, 1, true)]
+        [TestCase(1, 1.001, false)]
+        [TestCase(1.001, 1.001, true)]
+        [TestCase(1, 1.00, true)]
+        [TestCase(1.00, 1, true)]
+        public static void TestEvaluate(object lhs, object rhs, object expectedValue)
+        {
+            var expression = new GreaterThanOrEqualExpression(
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == lhs),
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == rhs),
+                new Context(ExpressiveOptions.None));
+
+            Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
         }
     }
 }
diff --git a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/LessThanExpressionTests.cs b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/LessThanExpressionTests.cs
index 09a6b19..dbf874f 100644
--- a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/LessThanExpressionTests.cs
+++ b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/LessThanExpressionTests.cs
@@ -1,101 +1,39 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Relational;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Relational
 {
-    [TestClass]
-    public class LessThanExpressionTests
+    public static class LessThanExpressionTests
     {
-        [TestMethod]
-        public void TestBothNull()
-        {
-            var expression = new LessThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestEqual()
-        {
-            var expression = new LessThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestGreaterThan()
-        {
-            var expression = new LessThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLeftNull()
-        {
-            var expression = new LessThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)"abc"),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
+        [TestCase(null, null, false)]
+        [TestCase(5, 5, false)]
+        [TestCase(5, 2, false)]
+        [TestCase(2, 5, true)]
+        [TestCase(null, "abc", true)]
+        [TestCase("abc", null, false)]
+        [TestCase("abc", "abc", false)]
+        [TestCase(null, false, true)]
+        [TestCase(false, null, false)]
+        [TestCase(true, false, false)]
+        [TestCase(true, true, false)]
+        [TestCase(false, false, false)]
+        [TestCase(false, true, true)]
+        [TestCase(1.001, 1, false)]
+        [TestCase(1, 1.001, true)]
+        [TestCase(1.001, 1.001, false)]
+        [TestCase(1, 1.00, false)]
+        [TestCase(1.00, 1, false)]
+        public static void TestEvaluate(object lhs, object rhs, object expectedValue)
+        {
+            var expression = new LessThanExpression(
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == lhs),
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == rhs),
+                new Context(ExpressiveOptions.None));
+
+            Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
         }
-
-        [TestMethod]
-        public void TestLessThan()
-        {
-            var expression = new LessThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestRightNull()
-        {
-            var expression = new LessThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)false),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatTrue()
-        {
-            var expression = new LessThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatFalse()
-        {
-            var expression = new LessThanExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
     }
 }
diff --git a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/LessThanOrEqualExpressionTests.cs b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/LessThanOrEqualExpressionTests.cs
index bca9cb2..7a73ce7 100644
--- a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/LessThanOrEqualExpressionTests.cs
+++ b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/LessThanOrEqualExpressionTests.cs
@@ -1,112 +1,39 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Relational;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Relational
 {
-    [TestClass]
-    public class LessThanOrEqualExpressionTests
+    public static class LessThanOrEqualExpressionTests
     {
-        [TestMethod]
-        public void TestBothNull()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestEqual()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
+        [TestCase(null, null, true)]
+        [TestCase(5, 5, true)]
+        [TestCase(5, 2, false)]
+        [TestCase(2, 5, true)]
+        [TestCase(null, "abc", true)]
+        [TestCase("abc", null, false)]
+        [TestCase("abc", "abc", true)]
+        [TestCase(null, false, true)]
+        [TestCase(false, null, false)]
+        [TestCase(true, false, false)]
+        [TestCase(true, true, true)]
+        [TestCase(false, false, true)]
+        [TestCase(false, true, true)]
+        [TestCase(1.001, 1, false)]
+        [TestCase(1, 1.001, true)]
+        [TestCase(1.001, 1.001, true)]
+        [TestCase(1, 1.00, true)]
+        [TestCase(1.00, 1, true)]
+        public static void TestEvaluate(object lhs, object rhs, object expectedValue)
+        {
+            var expression = new LessThanOrEqualExpression(
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == lhs),
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == rhs),
+                new Context(ExpressiveOptions.None));
+
+            Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
         }
-
-        [TestMethod]
-        public void TestGreaterThan()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLeftNull()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)"abc"),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLessThan()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestRightNull()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)false),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(null, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatEqual()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.0),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatTrue()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatFalse()
-        {
-            var expression = new LessThanOrEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
     }
 }
diff --git a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/NotEqualExpressionTests.cs b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/NotEqualExpressionTests.cs
index 56d5a9c..811b5d8 100644
--- a/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/NotEqualExpressionTests.cs
+++ b/Source/CSharp/Expressive/Expressive.Tests/Expressions/Binary/Relational/NotEqualExpressionTests.cs
@@ -1,89 +1,39 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Relational;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Relational
 {
-    [TestClass]
-    public class NotEqualExpressionTests
+    public static class NotEqualExpressionTests
     {
-        [TestMethod]
-        public void TestBothNull()
+        [TestCase(null, null, false)]
+        [TestCase(5, 5, false)]
+        [TestCase(5, 2, true)]
+        [TestCase(2, 5, true)]
+        [TestCase(null, "abc", true)]
+        [TestCase("abc", null, true)]
+        [TestCase("abc", "abc", false)]
+        [TestCase(null, false, true)]
+        [TestCase(false, null, true)]
+        [TestCase(true, false, true)]
+        [TestCase(true, true, false)]
+        [TestCase(false, false, false)]
+        [TestCase(false, true, true)]
+        [TestCase(1.001, 1, true)]
+        [TestCase(1, 1.001, true)]
+        [TestCase(1.001, 1.001, false)]
+        [TestCase(1, 1.00, false)]
+        [TestCase(1.00, 1, false)]
+        public static void TestEvaluate(object lhs, object rhs, object expectedValue)
         {
             var expression = new NotEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == lhs),
+                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == rhs),
                 new Context(ExpressiveOptions.None));
 
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestEqual()
-        {
-            var expression = new NotEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestLeftNull()
-        {
-            var expression = new NotEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)"abc"),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestNotEqual()
-        {
-            var expression = new NotEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)5),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestRightNull()
-        {
-            var expression = new NotEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)false),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)null),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatEqual()
-        {
-            var expression = new NotEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.0),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(false, expression.Evaluate(null));
-        }
-
-        [TestMethod]
-        public void TestIntFloatNotEqual()
-        {
-            var expression = new NotEqualExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1.001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1),
-                new Context(ExpressiveOptions.None));
-
-            Assert.AreEqual(true, expression.Evaluate(null));
+            Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
         }
     }
 }
diff --git a/Source/CSharp/Expressive/Expressive.Tests/Expressive.Tests.csproj b/Source/CSharp/Expressive/Expressive.Tests/Expressive.Tests.csproj
index 2be3360..116daae 100644
--- a/Source/CSharp/Expressive/Expressive.Tests/Expressive.Tests.csproj
+++ b/Source/CSharp/Expressive/Expressive.Tests/Expressive.Tests.csproj
@@ -17,6 +17,10 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="coverlet.msbuild" Version="2.9.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -25,6 +29,11 @@
     <PackageReference Include="Moq" Version="4.10.1" />
     <PackageReference Include="MSTest.TestAdapter" Version="1.2.0" />
     <PackageReference Include="MSTest.TestFramework" Version="1.2.0" />
+    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.16.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/GreaterThanExpression.cs b/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/GreaterThanExpression.cs
index 56aa218..d01b7fb 100644
--- a/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/GreaterThanExpression.cs
+++ b/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/GreaterThanExpression.cs
@@ -15,22 +15,8 @@ public GreaterThanExpression(IExpression lhs, IExpression rhs, Context context)
 
         #region BinaryExpressionBase Members
 
-        protected override object EvaluateImpl(object lhsResult, IExpression rightHandSide, IDictionary<string, object> variables)
-        {
-            // Use the type of the left operand to make the comparison
-            if (lhsResult is null)
-            {
-                return null;
-            }
-
-            var rhsResult = rightHandSide.Evaluate(variables);
-            if (rhsResult is null)
-            {
-                return null;
-            }
-
-            return Comparison.CompareUsingMostPreciseType(lhsResult, rhsResult, this.context) > 0;
-        }
+        protected override object EvaluateImpl(object lhsResult, IExpression rightHandSide, IDictionary<string, object> variables) => 
+            Comparison.CompareUsingMostPreciseType(lhsResult, rightHandSide.Evaluate(variables), this.context) > 0;
 
         #endregion
     }
diff --git a/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/GreaterThanOrEqualExpression.cs b/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/GreaterThanOrEqualExpression.cs
index d5bed62..1129ce8 100644
--- a/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/GreaterThanOrEqualExpression.cs
+++ b/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/GreaterThanOrEqualExpression.cs
@@ -15,22 +15,8 @@ public GreaterThanOrEqualExpression(IExpression lhs, IExpression rhs, Context co
 
         #region BinaryExpressionBase Members
 
-        protected override object EvaluateImpl(object lhsResult, IExpression rightHandSide, IDictionary<string, object> variables)
-        {
-            // Use the type of the left operand to make the comparison
-            if (lhsResult is null)
-            {
-                return null;
-            }
-
-            var rhsResult = rightHandSide.Evaluate(variables);
-            if (rhsResult is null)
-            {
-                return null;
-            }
-
-            return Comparison.CompareUsingMostPreciseType(lhsResult, rhsResult, this.context) >= 0;
-        }
+        protected override object EvaluateImpl(object lhsResult, IExpression rightHandSide, IDictionary<string, object> variables) => 
+            Comparison.CompareUsingMostPreciseType(lhsResult, rightHandSide.Evaluate(variables), this.context) >= 0;
 
         #endregion
     }
diff --git a/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/LessThanExpression.cs b/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/LessThanExpression.cs
index 12818d4..e855ce5 100644
--- a/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/LessThanExpression.cs
+++ b/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/LessThanExpression.cs
@@ -15,22 +15,8 @@ public LessThanExpression(IExpression lhs, IExpression rhs, Context context) : b
 
         #region BinaryExpressionBase Members
 
-        protected override object EvaluateImpl(object lhsResult, IExpression rightHandSide, IDictionary<string, object> variables)
-        {
-            // Use the type of the left operand to make the comparison
-            if (lhsResult is null)
-            {
-                return null;
-            }
-
-            var rhsResult = rightHandSide.Evaluate(variables);
-            if (rhsResult is null)
-            {
-                return null;
-            }
-
-            return Comparison.CompareUsingMostPreciseType(lhsResult, rhsResult, this.context) < 0;
-        }
+        protected override object EvaluateImpl(object lhsResult, IExpression rightHandSide, IDictionary<string, object> variables) => 
+            Comparison.CompareUsingMostPreciseType(lhsResult, rightHandSide.Evaluate(variables), this.context) < 0;
 
         #endregion
     }
diff --git a/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/LessThanOrEqualExpression.cs b/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/LessThanOrEqualExpression.cs
index a0f106c..0cf605d 100644
--- a/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/LessThanOrEqualExpression.cs
+++ b/Source/CSharp/Expressive/Expressive/Expressions/Binary/Relational/LessThanOrEqualExpression.cs
@@ -15,22 +15,8 @@ public LessThanOrEqualExpression(IExpression lhs, IExpression rhs, Context conte
 
         #region BinaryExpressionBase Members
 
-        protected override object EvaluateImpl(object lhsResult, IExpression rightHandSide, IDictionary<string, object> variables)
-        {
-            // Use the type of the left operand to make the comparison
-            if (lhsResult is null)
-            {
-                return null;
-            }
-
-            var rhsResult = rightHandSide.Evaluate(variables);
-            if (rhsResult is null)
-            {
-                return null;
-            }
-
-            return Comparison.CompareUsingMostPreciseType(lhsResult, rhsResult, this.context) <= 0;
-        }
+        protected override object EvaluateImpl(object lhsResult, IExpression rightHandSide, IDictionary<string, object> variables) => 
+            Comparison.CompareUsingMostPreciseType(lhsResult, rightHandSide.Evaluate(variables), this.context) <= 0;
 
         #endregion
     }