Merge pull request #143 from bijington/feature/sl-consistent-unit-tes…

…ting Provide a more consistent unit testing approach
bijington · Oct 1, 2024 · 1aa8fd9 · 1aa8fd9
2 parents 61facd2 + fbaa8a3
commit 1aa8fd9
Show file tree

Hide file tree

Showing 86 changed files with 776 additions and 965 deletions.
diff --git a/Source/Expressive.Tests/ExpressionTests.cs b/Source/Expressive.Tests/ExpressionTests.cs
diff --git a/Source/Expressive.Tests/Expressions/Binary/Additive/AddExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Additive/AddExpressionTests.cs
@@ -1,45 +1,44 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Additive;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Moq;
+using System;
 
 namespace Expressive.Tests.Expressions.Binary.Additive
 {
-    [TestClass]
+    [TestFixture]
     public class AddExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestEvaluate()
         {
             var expression = new AddExpression(
-                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)2),
+                MockExpression.ThatEvaluatesTo(1),
+                MockExpression.ThatEvaluatesTo(2),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(3, expression.Evaluate(null));
         }
 
-        [TestMethod]
+        [Test]
         public void TestEvaluateWithDifferentSizedArrays()
         {
             var expression = new AddExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)new[] { 1, 2, 3 }),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)new[] { 1 }),
+                MockExpression.ThatEvaluatesTo(new[] { 1, 2, 3 }),
+                MockExpression.ThatEvaluatesTo(new[] { 1 }),
                 new Context(ExpressiveOptions.None));
 
             Assert.IsNull(expression.Evaluate(null));
         }
 
-        [TestMethod]
+        [Test]
         public void TestEvaluateWithEmptyLeftArray()
         {
-#pragma warning disable CA1825 // Avoid zero-length array allocations. - Array.Empty does not exist in net 4.5
             var expression = new AddExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)new int[0]),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)new[] { 1, 2, 3 }),
+                MockExpression.ThatEvaluatesTo(Array.Empty<int>()),
+                MockExpression.ThatEvaluatesTo(new[] { 1, 2, 3 }),
                 new Context(ExpressiveOptions.None));
-#pragma warning restore CA1825 // Avoid zero-length array allocations.
 
             var result = (object[])expression.Evaluate(null);
             Assert.IsTrue(result.Length == 3);
@@ -50,12 +49,12 @@ public void TestEvaluateWithEmptyLeftArray()
             Assert.AreEqual(result[2], null);
         }
 
-        [TestMethod]
+        [Test]
         public void TestEvaluateWithOneSidedArray()
         {
             var expression = new AddExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)new[] { 1, 2, 3 }),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)2),
+                MockExpression.ThatEvaluatesTo(new[] { 1, 2, 3 }),
+                MockExpression.ThatEvaluatesTo(2),
                 new Context(ExpressiveOptions.None));
 
             var result = (object[])expression.Evaluate(null);
@@ -65,12 +64,12 @@ public void TestEvaluateWithOneSidedArray()
             Assert.AreEqual(result[2], 5);
         }
 
-        [TestMethod]
+        [Test]
         public void TestEvaluateWithSameSizedArrays()
         {
             var expression = new AddExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)new[] { 1, 2, 3 }),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)new[] { 1, 2, 3 }),
+                MockExpression.ThatEvaluatesTo(new[] { 1, 2, 3 }),
+                MockExpression.ThatEvaluatesTo(new[] { 1, 2, 3 }),
                 new Context(ExpressiveOptions.None));
 
             var result = (object[])expression.Evaluate(null);
@@ -80,12 +79,12 @@ public void TestEvaluateWithSameSizedArrays()
             Assert.AreEqual(result[2], 6);
         }
 
-        [TestMethod]
+        [Test]
         public void TestStringAddition()
         {
             var expression = new AddExpression(
-                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)2),
+                MockExpression.ThatEvaluatesTo("1"),
+                MockExpression.ThatEvaluatesTo(2),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual("12", expression.Evaluate(null));

diff --git a/Source/Expressive.Tests/Expressions/Binary/Additive/SubtractExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Additive/SubtractExpressionTests.cs
@@ -1,20 +1,17 @@
-using System.Collections.Generic;
-using Expressive.Expressions;
-using Expressive.Expressions.Binary.Additive;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq;
+using Expressive.Expressions.Binary.Additive;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Additive
 {
-    [TestClass]
+    [TestFixture]
     public class SubtractExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestEvaluate()
         {
             var expression = new SubtractExpression(
-                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)2),
+                MockExpression.ThatEvaluatesTo(1),
+                MockExpression.ThatEvaluatesTo(2),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(-1, expression.Evaluate(null));

diff --git a/Source/Expressive.Tests/Expressions/Binary/Bitwise/BitwiseAndExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Bitwise/BitwiseAndExpressionTests.cs
@@ -1,20 +1,17 @@
-using System.Collections.Generic;
-using Expressive.Expressions;
-using Expressive.Expressions.Binary.Bitwise;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq;
+using Expressive.Expressions.Binary.Bitwise;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Bitwise
 {
-    [TestClass]
+    [TestFixture]
     public class BitwiseAndExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestEvaluate()
         {
             var expression = new BitwiseAndExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)0x1001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)0x0001),
+                MockExpression.ThatEvaluatesTo(0x1001),
+                MockExpression.ThatEvaluatesTo(0x0001),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(0x0001, expression.Evaluate(null));

diff --git a/Source/Expressive.Tests/Expressions/Binary/Bitwise/BitwiseExclusiveOrExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Bitwise/BitwiseExclusiveOrExpressionTests.cs
@@ -1,20 +1,17 @@
-using System.Collections.Generic;
-using Expressive.Expressions;
-using Expressive.Expressions.Binary.Bitwise;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq;
+using Expressive.Expressions.Binary.Bitwise;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Bitwise
 {
-    [TestClass]
+    [TestFixture]
     public class BitwiseExclusiveOrExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestEvaluate()
         {
             var expression = new BitwiseExclusiveOrExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1111),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)0001),
+                MockExpression.ThatEvaluatesTo(1111),
+                MockExpression.ThatEvaluatesTo(0001),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(1110, expression.Evaluate(null));

diff --git a/Source/Expressive.Tests/Expressions/Binary/Bitwise/BitwiseOrExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Bitwise/BitwiseOrExpressionTests.cs
@@ -1,20 +1,17 @@
-using System.Collections.Generic;
-using Expressive.Expressions;
-using Expressive.Expressions.Binary.Bitwise;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq;
+using Expressive.Expressions.Binary.Bitwise;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Bitwise
 {
-    [TestClass]
+    [TestFixture]
     public class BitwiseOrExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestEvaluate()
         {
             var expression = new BitwiseOrExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)1001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)0001),
+                MockExpression.ThatEvaluatesTo(1001),
+                MockExpression.ThatEvaluatesTo(0001),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(1001, expression.Evaluate(null));

diff --git a/Source/Expressive.Tests/Expressions/Binary/Bitwise/LeftShiftExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Bitwise/LeftShiftExpressionTests.cs
@@ -1,20 +1,17 @@
-using System.Collections.Generic;
-using Expressive.Expressions;
-using Expressive.Expressions.Binary.Bitwise;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq;
+using Expressive.Expressions.Binary.Bitwise;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Bitwise
 {
-    [TestClass]
+    [TestFixture]
     public class LeftShiftExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestEvaluate()
         {
             var expression = new LeftShiftExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)0x1001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)0x0001),
+                MockExpression.ThatEvaluatesTo(0x1001),
+                MockExpression.ThatEvaluatesTo(0x0001),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(0x1001 << 0x0001, expression.Evaluate(null));

diff --git a/Source/Expressive.Tests/Expressions/Binary/Bitwise/RightShiftExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Bitwise/RightShiftExpressionTests.cs
@@ -1,20 +1,17 @@
-using System.Collections.Generic;
-using Expressive.Expressions;
-using Expressive.Expressions.Binary.Bitwise;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq;
+using Expressive.Expressions.Binary.Bitwise;
+using NUnit.Framework;
 
 namespace Expressive.Tests.Expressions.Binary.Bitwise
 {
-    [TestClass]
+    [TestFixture]
     public class RightShiftExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestEvaluate()
         {
             var expression = new RightShiftExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)0x1001),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)0x0001),
+                MockExpression.ThatEvaluatesTo(0x1001),
+                MockExpression.ThatEvaluatesTo(0x0001),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(0x1001 >> 0x0001, expression.Evaluate(null));

diff --git a/Source/Expressive.Tests/Expressions/Binary/Conditional/NullCoalescingExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Conditional/NullCoalescingExpressionTests.cs
@@ -1,31 +1,31 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Conditional;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Moq;
 
 namespace Expressive.Tests.Expressions.Binary.Conditional
 {
-    [TestClass]
+    [TestFixture]
     public class NullCoalescingExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestNotNullEvaluate()
         {
             var expression = new NullCoalescingExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)"Non null"),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)"Never used"),
+                MockExpression.ThatEvaluatesTo("Non null"),
+                MockExpression.ThatEvaluatesTo("Never used"),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual("Non null", expression.Evaluate(null));
         }
 
-        [TestMethod]
+        [Test]
         public void TestNullEvaluate()
         {
             var expression = new NullCoalescingExpression(
-                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)"Now used"),
+                MockExpression.ThatEvaluatesTo(null),
+                MockExpression.ThatEvaluatesTo("Now used"),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual("Now used", expression.Evaluate(null));

diff --git a/Source/Expressive.Tests/Expressions/Binary/Logical/AndExpressionTests.cs b/Source/Expressive.Tests/Expressions/Binary/Logical/AndExpressionTests.cs
@@ -1,65 +1,65 @@
 using System.Collections.Generic;
 using Expressive.Expressions;
 using Expressive.Expressions.Binary.Logical;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Moq;
 
 namespace Expressive.Tests.Expressions.Binary.Logical
 {
-    [TestClass]
+    [TestFixture]
     public class AndExpressionTests
     {
-        [TestMethod]
+        [Test]
         public void TestBothTrueEvaluate()
         {
             var expression = new AndExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object) true),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object) true),
+                MockExpression.ThatEvaluatesTo(true),
+                MockExpression.ThatEvaluatesTo(true),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(true, expression.Evaluate(null));
         }
 
-        [TestMethod]
+        [Test]
         public void TestLeftTrueEvaluate()
         {
             var expression = new AndExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object) true),
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object) false),
+                MockExpression.ThatEvaluatesTo(true),
+                MockExpression.ThatEvaluatesTo(false),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(false, expression.Evaluate(null));
         }
 
-        [TestMethod]
+        [Test]
         public void TestNeitherTrueEvaluate()
         {
             var expression = new AndExpression(
-                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) false),
+                MockExpression.ThatEvaluatesTo(false),
+                MockExpression.ThatEvaluatesTo(false),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(false, expression.Evaluate(null));
         }
 
-        [TestMethod]
+        [Test]
         public void TestRightTrueEvaluate()
         {
             var expression = new AndExpression(
-                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) true),
+                MockExpression.ThatEvaluatesTo(false),
+                MockExpression.ThatEvaluatesTo(true),
                 new Context(ExpressiveOptions.None));
 
             Assert.AreEqual(false, expression.Evaluate(null));
         }
 
-        [TestMethod]
+        [Test]
         public void TestShortCircuit()
         {
             var rightHandMock = new Mock<IExpression>();
 
             var expression = new AndExpression(
-                Mock.Of<IExpression>(e => e.Evaluate(It.IsAny<IDictionary<string, object>>()) == (object)false),
+                MockExpression.ThatEvaluatesTo(false),
                 rightHandMock.Object,
                 new Context(ExpressiveOptions.None));