diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 57f03d8c..3951621c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,9 +15,9 @@ jobs:
     runs-on: windows-2019
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
         dotnet-version: 8.0.x
     - name: Restore dependencies
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/Caching/HybridCacheServiceProviderTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/Caching/HybridCacheServiceProviderTests.cs
index 2c77cf86..76d478c0 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/Caching/HybridCacheServiceProviderTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/Caching/HybridCacheServiceProviderTests.cs
@@ -36,7 +36,7 @@ public void Init()
                 .Stub(x => x.UnderlyingContext)
                 .Return(httpContext);
 
-            foreach (var key in HttpRuntime.Cache.OfType<DictionaryEntry>().Select(x=>x.Key))
+            foreach (var key in HttpRuntime.Cache.OfType<DictionaryEntry>().Select(x => x.Key))
                 HttpRuntime.Cache.Remove(Convert.ToString(key));
         }
 
@@ -115,9 +115,12 @@ public void StoreAndGetToBothMonorailAndHttpCacheWorkSideBySide()
             cacheService.Store("xfoo1", null, null, "bar1");
             cacheService.Store("xfoo2", null, signal, "bar2");
 
-            Assert.That(cacheService.Get("xfoo1"), Is.EqualTo("bar1"));
-            Assert.That(cacheService.Get("xfoo2"), Is.EqualTo("bar2"));
-            Assert.That(cacheService.Get("xfoo3"), Is.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(cacheService.Get("xfoo1"), Is.EqualTo("bar1"));
+                Assert.That(cacheService.Get("xfoo2"), Is.EqualTo("bar2"));
+                Assert.That(cacheService.Get("xfoo3"), Is.Null);
+            });
 
             _context.Services.CacheProvider.VerifyAllExpectations();
 
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/Castle.MonoRail.Views.Spark.Tests.csproj b/src/Castle.MonoRail.Views.Spark.Tests/Castle.MonoRail.Views.Spark.Tests.csproj
index 779bb8fc..44d0e88c 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/Castle.MonoRail.Views.Spark.Tests.csproj
+++ b/src/Castle.MonoRail.Views.Spark.Tests/Castle.MonoRail.Views.Spark.Tests.csproj
@@ -28,10 +28,14 @@
     <Reference Include="System.Web" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-	<PackageReference Include="NUnit" Version="3.14.0" />
-	<PackageReference Include="NUnit.Console" Version="3.16.3" />
-	<PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+	<PackageReference Include="NUnit" Version="4.2.2" />
+	<PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+	  <PrivateAssets>all</PrivateAssets>
+	  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	</PackageReference>
+	<PackageReference Include="NUnit.Console" Version="3.18.3" />
+	<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   <PackageReference Include="RhinoMocks" Version="3.6.1" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/Constraints.cs b/src/Castle.MonoRail.Views.Spark.Tests/Constraints.cs
index bae527a8..c02e4807 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/Constraints.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/Constraints.cs
@@ -85,7 +85,7 @@ public override ConstraintResult ApplyTo<TActual>(TActual actual)
 
                     index = nextIndex + value.Length;
                 }
-                
+
                 return new ConstraintResult(this, index, true);
             }
 
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/HelperExtensionMethodsTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/HelperExtensionMethodsTests.cs
index 669ddf9a..821b273c 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/HelperExtensionMethodsTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/HelperExtensionMethodsTests.cs
@@ -72,7 +72,7 @@ public void VerifyAppropriateMethodsPresent()
                     missingMethods.Add(neededMethod);
             }
 
-            Assert.IsEmpty(string.Concat<MethodDescriptor>(missingMethods.ToArray()), "{0} methods not represented", missingMethods.Count);
+            Assert.That(string.Concat<MethodDescriptor>(missingMethods.ToArray()), Is.Empty, $"{missingMethods.Count} methods not represented");
         }
 
         class HelperDescriptor
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/ModelDictionaryTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/ModelDictionaryTests.cs
index 3f993692..5a9204f3 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/ModelDictionaryTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/ModelDictionaryTests.cs
@@ -23,10 +23,13 @@ public class ModelDictionaryTests
         [Test]
         public void AnonymousObjectPropertiesInDictionary()
         {
-            IDictionary<string, object> args = new ModelDictionary(new {name = "foo", bar = "quux"});
-            Assert.AreEqual(2, args.Count);
-            Assert.AreEqual("foo", args["name"]);
-            Assert.AreEqual("quux", args["bar"]);
+            IDictionary<string, object> args = new ModelDictionary(new { name = "foo", bar = "quux" });
+            Assert.That(args.Count, Is.EqualTo(2));
+            Assert.Multiple(() =>
+            {
+                Assert.That(args["name"], Is.EqualTo("foo"));
+                Assert.That(args["bar"], Is.EqualTo("quux"));
+            });
         }
     }
 }
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/Models/UserInfo.cs b/src/Castle.MonoRail.Views.Spark.Tests/Models/UserInfo.cs
index 4cc0a643..6845df4e 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/Models/UserInfo.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/Models/UserInfo.cs
@@ -20,17 +20,17 @@
 
 namespace Castle.MonoRail.Views.Spark.Tests.Models
 {
-	public class UserInfo
-	{
-		public string Name { get; set; }
-		public UserType UserType { get; set; }
-	}
+    public class UserInfo
+    {
+        public string Name { get; set; }
+        public UserType UserType { get; set; }
+    }
 
 
-	public enum UserType
-	{
-		Anonymous,
-		Registered,
-		Administrator,
-	}
+    public enum UserType
+    {
+        Anonymous,
+        Registered,
+        Administrator,
+    }
 }
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/PrecompileInstallerTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/PrecompileInstallerTests.cs
index 7cbdef4e..1c2bb0fa 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/PrecompileInstallerTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/PrecompileInstallerTests.cs
@@ -35,10 +35,11 @@ public void RunPrecompiler()
             File.Delete(targetFile);
 
             var parent = new ParentInstaller();
-            var precompile = new PrecompileInstaller();
-
-            precompile.TargetAssemblyFile = targetFile;
-            precompile.ViewPath = "MonoRail.Tests.Views";
+            var precompile = new PrecompileInstaller
+            {
+                TargetAssemblyFile = targetFile,
+                ViewPath = "MonoRail.Tests.Views"
+            };
             precompile.DescribeBatch += ((sender, e) => e.Batch.For<StubController>().Include("*").Include("_*"));
 
             var state = new Hashtable();
@@ -54,7 +55,7 @@ public void RunPrecompiler()
             var views = result.GetTypes().Where(x => x.BaseType == typeof(SparkView))
                 .ToArray();
 
-            Assert.AreEqual(3, views.Length);
+            Assert.That(views.Length, Is.EqualTo(3));
         }
 
         public class ParentInstaller : Installer
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/SparkBatchCompilerTester.cs b/src/Castle.MonoRail.Views.Spark.Tests/SparkBatchCompilerTester.cs
index 3ae4bb27..b6ebdc62 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/SparkBatchCompilerTester.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/SparkBatchCompilerTester.cs
@@ -59,8 +59,8 @@ public void CompileBatchDescriptor()
 
             var assembly = _factory.Precompile(batch);
 
-            Assert.IsNotNull(assembly);
-            Assert.AreEqual(3, assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)));
+            Assert.That(assembly, Is.Not.Null);
+            Assert.That(assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)), Is.EqualTo(3));
         }
 
         [Test]
@@ -72,20 +72,23 @@ public void DefaultEntryBehavior()
 
             var descriptors = _factory.CreateDescriptors(batch);
 
-            Assert.AreEqual(2, descriptors.Count);
-            Assert.AreEqual(2, descriptors[0].Templates.Count);
-            Assert.AreEqual(2, descriptors[1].Templates.Count);
-
-            Assert.That(
-                descriptors.Any(
-                    d =>
-                    d.Templates.Contains(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar)) &&
-                    d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
-            Assert.That(
-                descriptors.Any(
-                    d =>
-                    d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar)) &&
-                    d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
+            Assert.That(descriptors.Count, Is.EqualTo(2));
+            Assert.Multiple(() =>
+            {
+                Assert.That(descriptors[0].Templates.Count, Is.EqualTo(2));
+                Assert.That(descriptors[1].Templates.Count, Is.EqualTo(2));
+
+                Assert.That(
+                    descriptors.Any(
+                        d =>
+                        d.Templates.Contains(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar)) &&
+                        d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
+                Assert.That(
+                    descriptors.Any(
+                        d =>
+                        d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar)) &&
+                        d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
+            });
         }
 
         [Test]
@@ -98,8 +101,8 @@ public void MultipleLayoutFiles()
 
             var assembly = _factory.Precompile(batch);
 
-            Assert.IsNotNull(assembly);
-            Assert.AreEqual(4, assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)));
+            Assert.That(assembly, Is.Not.Null);
+            Assert.That(assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)), Is.EqualTo(4));
         }
 
         [Test]
@@ -112,27 +115,30 @@ public void WildcardIncludeRules()
                 .For<StubController>().Layout("ajax").Include("_*");
 
             var descriptors = _factory.CreateDescriptors(batch);
-            Assert.AreEqual(3, descriptors.Count);
-            Assert.That(
-                descriptors.Any(
-                    d =>
-                    d.Templates.Contains(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar)) &&
-                    d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
-            Assert.That(
-                descriptors.Any(
-                    d =>
-                    d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar)) &&
-                    d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
-            Assert.That(
-                descriptors.Any(
-                    d =>
-                    d.Templates.Contains(string.Format("Stub{0}_Widget.spark", Path.DirectorySeparatorChar)) &&
-                    d.Templates.Contains(string.Format("Shared{0}ajax.spark", Path.DirectorySeparatorChar))));
+            Assert.That(descriptors.Count, Is.EqualTo(3));
+            Assert.Multiple(() =>
+            {
+                Assert.That(
+                            descriptors.Any(
+                                d =>
+                                d.Templates.Contains(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar)) &&
+                                d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
+                Assert.That(
+                    descriptors.Any(
+                        d =>
+                        d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar)) &&
+                        d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
+                Assert.That(
+                    descriptors.Any(
+                        d =>
+                        d.Templates.Contains(string.Format("Stub{0}_Widget.spark", Path.DirectorySeparatorChar)) &&
+                        d.Templates.Contains(string.Format("Shared{0}ajax.spark", Path.DirectorySeparatorChar))));
+            });
 
             var assembly = _factory.Precompile(batch);
 
-            Assert.IsNotNull(assembly);
-            Assert.AreEqual(3, assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)));
+            Assert.That(assembly, Is.Not.Null);
+            Assert.That(assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)), Is.EqualTo(3));
         }
 
         [Test]
@@ -144,19 +150,22 @@ public void ExcludeRules()
 
             var descriptors = _factory.CreateDescriptors(batch);
 
-            Assert.AreEqual(2, descriptors.Count);
-            Assert.AreEqual(2, descriptors[0].Templates.Count);
-            Assert.AreEqual(2, descriptors[1].Templates.Count);
-            Assert.That(
-                descriptors.Any(
-                    d =>
-                    d.Templates.Contains(string.Format("Stub{0}_Widget.spark", Path.DirectorySeparatorChar)) &&
-                    d.Templates.Contains(string.Format("Shared{0}ajax.spark", Path.DirectorySeparatorChar))));
-            Assert.That(
-                descriptors.Any(
-                    d =>
-                    d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar)) &&
-                    d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
+            Assert.That(descriptors.Count, Is.EqualTo(2));
+            Assert.Multiple(() =>
+            {
+                Assert.That(descriptors[0].Templates.Count, Is.EqualTo(2));
+                Assert.That(descriptors[1].Templates.Count, Is.EqualTo(2));
+                Assert.That(
+                    descriptors.Any(
+                        d =>
+                        d.Templates.Contains(string.Format("Stub{0}_Widget.spark", Path.DirectorySeparatorChar)) &&
+                        d.Templates.Contains(string.Format("Shared{0}ajax.spark", Path.DirectorySeparatorChar))));
+                Assert.That(
+                    descriptors.Any(
+                        d =>
+                        d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar)) &&
+                        d.Templates.Contains(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar))));
+            });
         }
 
         [Test]
@@ -165,9 +174,9 @@ public void FileWithoutSparkExtensionAreIgnored()
             var batch = new SparkBatchDescriptor();
             batch.For<StubController>();
             var descriptors = _factory.CreateDescriptors(batch);
-            
+
             // no templates
-            Assert.That(descriptors.SelectMany(d=>d.Templates).All(t=>!t.Contains("Helper")));
+            Assert.That(descriptors.SelectMany(d => d.Templates).All(t => !t.Contains("Helper")));
         }
 
         [Test]
@@ -176,12 +185,12 @@ public void ControllersWithHelpersGenerateAccessors()
             var batch = new SparkBatchDescriptor();
             batch.For<FooController>().Include("index");
             _factory.Engine.ViewFolder = new InMemoryViewFolder { { string.Format("foo{0}index.spark", Path.DirectorySeparatorChar), "<p>foo</p>" } };
-            
+
             var descriptors = _factory.CreateDescriptors(batch);
 
-            Assert.AreEqual(1, descriptors.Count);
-            Assert.AreEqual(1, descriptors[0].Accessors.Count);
-            Assert.AreEqual(typeof(FooHelper).FullName + " Foo", descriptors[0].Accessors[0].Property);            
+            Assert.That(descriptors.Count, Is.EqualTo(1));
+            Assert.That(descriptors[0].Accessors.Count, Is.EqualTo(1));
+            Assert.That(descriptors[0].Accessors[0].Property, Is.EqualTo(typeof(FooHelper).FullName + " Foo"));
         }
     }
 
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/SparkViewDataTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/SparkViewDataTests.cs
index 9a06af17..3f03a951 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/SparkViewDataTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/SparkViewDataTests.cs
@@ -48,7 +48,7 @@ public void PropertyBagAvailable()
             mocks.ReplayAll();
             view.Contextualize(engineContext, controllerContext, null, null, null);
 
-            Assert.AreEqual("bar", view.ViewData["foo"]);
+            Assert.That(view.ViewData["foo"], Is.EqualTo("bar"));
         }
 
         [Test]
@@ -73,11 +73,15 @@ public void MergingCollectionsLikeVelocity()
 
             view.Contextualize(engineContext, controllerContext, null, null, null);
 
-            Assert.AreEqual("controllerPropertyBagValue", view.ViewData["controllerPropertyBagKey"]);
-            Assert.AreEqual("contextFlashValue", view.ViewData["contextFlashKey"]);
-            Assert.AreEqual("controllerHelpersValue", view.ViewData["controllerHelpersKey"]);
-            Assert.AreEqual("contextParamsValue", view.ViewData["contextParamsKey"]);
-            Assert.AreSame(resource, view.ViewData["controllerResourcesKey"]);
+            Assert.Multiple(() =>
+            {
+                Assert.That(view.ViewData["controllerPropertyBagKey"], Is.EqualTo("controllerPropertyBagValue"));
+                Assert.That(view.ViewData["contextFlashKey"], Is.EqualTo("contextFlashValue"));
+                Assert.That(view.ViewData["controllerHelpersKey"], Is.EqualTo("controllerHelpersValue"));
+                Assert.That(view.ViewData["contextParamsKey"], Is.EqualTo("contextParamsValue"));
+
+                Assert.That(view.ViewData["controllerResourcesKey"], Is.SameAs(resource));
+            });
         }
     }
 }
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryStrictNullBehaviourTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryStrictNullBehaviourTests.cs
index 0f0078c6..71243b04 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryStrictNullBehaviourTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryStrictNullBehaviourTests.cs
@@ -27,7 +27,7 @@ public class SparkViewFactoryStrictNullBehaviourTests : SparkViewFactoryTestsBas
     {
         protected override void Configure()
         {
-            var settings = 
+            var settings =
                 new SparkSettings()
                     .SetBaseClassTypeName(typeof(SparkView));
 
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryTests.cs
index 043f055e..4ff8e82b 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryTests.cs
@@ -24,7 +24,7 @@ namespace Castle.MonoRail.Views.Spark.Tests
     using Castle.MonoRail.Framework.Services;
     using NUnit.Framework;
     using global::Spark;
-    
+
     [TestFixture]
     public class SparkViewFactoryTests : SparkViewFactoryTestsBase
     {
@@ -44,7 +44,7 @@ protected override void Configure()
             manager.Service(serviceProvider);
             serviceProvider.ViewEngineManager = manager;
             serviceProvider.AddService(typeof(IViewEngineManager), manager);
-            
+
             manager.RegisterEngineForExtesionLookup(factory);
             manager.RegisterEngineForView(factory);
         }
@@ -53,7 +53,7 @@ protected override void Configure()
         public void ExtensionIsSpark()
         {
             mocks.ReplayAll();
-            Assert.AreEqual("spark", factory.ViewFileExtension);
+            Assert.That(factory.ViewFileExtension, Is.EqualTo("spark"));
         }
 
         [Test]
@@ -61,7 +61,7 @@ public void ProcessBasicTemplate()
         {
             mocks.ReplayAll();
             manager.Process(string.Format("Home{0}Index", Path.DirectorySeparatorChar), output, engineContext, controller, controllerContext);
-            Assert.That(output.ToString().Contains("<h1>Simple test</h1>"));
+            Assert.That(output.ToString(), Does.Contain("<h1>Simple test</h1>"));
         }
 
         [Test]
@@ -69,19 +69,23 @@ public void ContextAndControllerContextAvailable()
         {
             mocks.ReplayAll();
             manager.Process(string.Format("Home{0}Index", Path.DirectorySeparatorChar), output, engineContext, controller, controllerContext);
-            
+
             var descriptor = new SparkViewDescriptor();
             descriptor.Templates.Add(string.Format("Home{0}Index.spark", Path.DirectorySeparatorChar));
             descriptor.Templates.Add(string.Format("Shared{0}default.spark", Path.DirectorySeparatorChar));
             var entry = factory.Engine.GetEntry(descriptor);
             var view = (SparkView)entry.CreateInstance();
             view.Contextualize(engineContext, controllerContext, serviceProvider.GetService<IResourcePathManager>(), factory, null);
-            
+
             var result = new StringWriter();
             view.RenderView(result);
-            Assert.AreEqual(result.ToString(), output.ToString());
-            Assert.AreSame(engineContext, view.Context);
-            Assert.AreSame(controllerContext, view.ControllerContext);
+            Assert.Multiple(() =>
+            {
+                Assert.That(output.ToString(), Is.EqualTo(result.ToString()));
+
+                Assert.That(view.Context, Is.SameAs(engineContext));
+                Assert.That(view.ControllerContext, Is.SameAs(controllerContext));
+            });
         }
 
         [Test, Ignore("Need to get the helpers to function again using the stub objects")]
@@ -121,7 +125,7 @@ public void NullBehaviourConfiguredToLenient()
             mocks.ReplayAll();
             manager.Process(string.Format("Home{0}NullBehaviourConfiguredToLenient", Path.DirectorySeparatorChar), output, engineContext, controller, controllerContext);
             var content = output.ToString();
-            Assert.IsFalse(content.Contains("default"));
+            Assert.That(content.Contains("default"), Is.False);
 
             ContainsInOrder(content,
                 "<p>name kaboom *${user.Name}*</p>",
@@ -134,7 +138,7 @@ public void TerseHtmlEncode()
         {
             mocks.ReplayAll();
             manager.Process(string.Format("Home{0}TerseHtmlEncode", Path.DirectorySeparatorChar), output, engineContext, controller, controllerContext);
-            
+
             // See AutomaticEncoding = true in Configure() method
             ContainsInOrder(output.ToString(),
                 "<p>This &lt;contains/&gt; html</p>");
@@ -149,8 +153,8 @@ public void IncludingStatementsDirectly()
                 "<p>was true</p>");
 
 
-            Assert.IsFalse(output.ToString().Contains("<p>was false</p>"));
-            
+            Assert.That(output.ToString().Contains("<p>was false</p>"), Is.False);
+
         }
 
         [Test]
@@ -161,8 +165,11 @@ public void Rescue404Rendering()
             mocks.ReplayAll();
             var handler = new MonoRailHttpHandlerFactory.NotFoundHandler("", "nosuchcontroller", engineContext);
             handler.ProcessRequest(null);
-            Assert.AreEqual(404, response.StatusCode);
-            Assert.AreEqual("<p>404 message rendered</p>\r\n", output.ToString());
+            Assert.Multiple(() =>
+            {
+                Assert.That(response.StatusCode, Is.EqualTo(404));
+                Assert.That(output.ToString(), Is.EqualTo("<p>404 message rendered</p>\r\n"));
+            });
         }
 
         [Test, Ignore("Controller Type effects are no longer supported in 1.1")]
@@ -173,7 +180,7 @@ public void ControllerHelperAttributeCanBeUsed()
             controllerContext.Helpers.Add("bar", new Helpers.TestingHelper());
             mocks.ReplayAll();
             manager.Process(string.Format("Home{0}ControllerHelperAttributeCanBeUsed", Path.DirectorySeparatorChar), output, engineContext, controller, controllerContext);
-            Assert.That(output.ToString().Contains("<p>Hello</p>"));            
+            Assert.That(output.ToString(), Does.Contain("<p>Hello</p>"));
         }
 
         [Test, Ignore("No way to mock HttpContext.Current")]
@@ -184,7 +191,7 @@ public void ControllerHelpersCanBeUsedWhenRenderingMailView()
             controllerContext.Helpers.Add("bar", new Helpers.TestingHelper());
             mocks.ReplayAll();
             manager.Process(string.Format("Home{0}ControllerHelperAttributeCanBeUsed", Path.DirectorySeparatorChar), null, output, null);
-            Assert.That(output.ToString().Contains("<p>Hello</p>"));
+            Assert.That(output.ToString(), Does.Contain("<p>Hello</p>"));
         }
 
         [Test]
@@ -216,4 +223,4 @@ public void Dispose()
         }
     }
 }
-    
+
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryTestsBase.cs b/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryTestsBase.cs
index 7256eb4f..6031a4f2 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryTestsBase.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/SparkViewFactoryTestsBase.cs
@@ -38,7 +38,6 @@ public abstract class SparkViewFactoryTestsBase
         protected SparkViewFactory factory;
         protected StubMonoRailServices serviceProvider;
 
-
         [SetUp]
         public void Init()
         {
@@ -54,8 +53,8 @@ public void Init()
 
             controllerContext = new ControllerContext();
             propertyBag = controllerContext.PropertyBag;
-            
-            controllerContext.LayoutNames = new []{"default"};
+
+            controllerContext.LayoutNames = new[] { "default" };
             output = new StringWriter();
 
             server = new StubServerUtility();
@@ -69,20 +68,24 @@ public void Init()
             response = engineContext.Response;
         }
 
+        [TearDown]
+        public void TearDown()
+        {
+            output.Dispose();
+        }
 
         protected abstract void Configure();
 
-
         protected void InitUrlInfo(string areaName, string controllerName, string actionName)
         {
-            var urlInfo = new UrlInfo(areaName, controllerName, actionName, "/", "castle");
+            _ = new UrlInfo(areaName, controllerName, actionName, "/", "castle");
 
             engineContext = new StubEngineContext();
             engineContext.AddService(typeof(IUrlBuilder), serviceProvider.UrlBuilder);
             engineContext.CurrentController = controller;
             engineContext.CurrentControllerContext = controllerContext;
             engineContext.Services.ViewEngineManager = serviceProvider.ViewEngineManager;
-            output = (StringWriter) engineContext.Response.Output;
+            output = (StringWriter)engineContext.Response.Output;
 
             var routeMatch = new RouteMatch();
             controllerContext.RouteMatch = routeMatch;
@@ -95,7 +98,8 @@ protected static void ContainsInOrder(string content, params string[] values)
             foreach (string value in values)
             {
                 int nextIndex = content.IndexOf(value, index);
-                Assert.GreaterOrEqual(nextIndex, 0, string.Format("Looking for {0}", value));
+
+                Assert.That(nextIndex, Is.GreaterThanOrEqualTo(0), () => $"Looking for {value}");
                 index = nextIndex + value.Length;
             }
         }
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/Stubs/StubController.cs b/src/Castle.MonoRail.Views.Spark.Tests/Stubs/StubController.cs
index 9572c999..08de0aef 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/Stubs/StubController.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/Stubs/StubController.cs
@@ -23,7 +23,7 @@ public class StubController : SmartDispatcherController
         public void Index()
         {
         }
-        
+
         public void List()
         {
         }
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/AllFrameworkComponentTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/AllFrameworkComponentTests.cs
index 80daaed1..81d0c052 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/AllFrameworkComponentTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/AllFrameworkComponentTests.cs
@@ -26,8 +26,8 @@ public void AuthenticatedContent()
         {
             var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-AuthenticatedContent.spark", Path.DirectorySeparatorChar));
 
-            Assert.That(content.Contains("two"));
-            Assert.IsFalse(content.Contains("one"));
+            Assert.That(content, Does.Contain("two"));
+            Assert.That(content.Contains("one"), Is.False);
         }
 
         [Test]
@@ -35,7 +35,7 @@ public void CaptureFor()
         {
             var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-CaptureFor.spark", Path.DirectorySeparatorChar));
 
-            Assert.That(content.Contains("onetwothreefour"));
+            Assert.That(content, Does.Contain("onetwothreefour"));
         }
 
         [Test]
@@ -69,43 +69,43 @@ public void ColumnRenderer()
         [Test, Ignore("Creating a test for each built-in component")]
         public void DiggStylePagination()
         {
-            var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-DiggStylePagination.spark", Path.DirectorySeparatorChar));
+            _ = ExecuteView(string.Format("Home{0}AllFrameworkComponents-DiggStylePagination.spark", Path.DirectorySeparatorChar));
         }
 
         [Test, Ignore("Creating a test for each built-in component")]
         public void Security()
         {
-            var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-Security.spark", Path.DirectorySeparatorChar));
+            _ = ExecuteView(string.Format("Home{0}AllFrameworkComponents-Security.spark", Path.DirectorySeparatorChar));
         }
 
         [Test, Ignore("Creating a test for each built-in component")]
         public void SelectStylePagination()
         {
-            var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-SelectStylePagination.spark", Path.DirectorySeparatorChar));
+            _ = ExecuteView(string.Format("Home{0}AllFrameworkComponents-SelectStylePagination.spark", Path.DirectorySeparatorChar));
         }
 
         [Test, Ignore("Creating a test for each built-in component")]
         public void SiteMap()
         {
-            var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-SiteMap.spark", Path.DirectorySeparatorChar));
+            _ = ExecuteView(string.Format("Home{0}AllFrameworkComponents-SiteMap.spark", Path.DirectorySeparatorChar));
         }
 
         [Test, Ignore("Creating a test for each built-in component")]
         public void TreeMaker()
         {
-            var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-TreeMaker.spark", Path.DirectorySeparatorChar));
+            _ = ExecuteView(string.Format("Home{0}AllFrameworkComponents-TreeMaker.spark", Path.DirectorySeparatorChar));
         }
 
         [Test, Ignore("Creating a test for each built-in component")]
         public void UpdatePage()
         {
-            var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-UpdatePage.spark", Path.DirectorySeparatorChar));
+            _ = ExecuteView(string.Format("Home{0}AllFrameworkComponents-UpdatePage.spark", Path.DirectorySeparatorChar));
         }
 
         [Test, Ignore("Creating a test for each built-in component")]
         public void UpdateTag()
         {
-            var content = ExecuteView(string.Format("Home{0}AllFrameworkComponents-UpdateTag.spark", Path.DirectorySeparatorChar));
+            _ = ExecuteView(string.Format("Home{0}AllFrameworkComponents-UpdateTag.spark", Path.DirectorySeparatorChar));
         }
 
         string ExecuteView(string page)
@@ -117,8 +117,8 @@ string ExecuteView(string page)
 
             mocks.VerifyAll();
 
-            Assert.IsNotNull(writer.ToString());
-            Assert.IsNotEmpty(writer.ToString());
+            Assert.That(writer.ToString(), Is.Not.Null);
+            Assert.That(writer.ToString(), Is.Not.Empty);
             return writer.ToString();
         }
 
@@ -128,7 +128,7 @@ static void ContainsInOrder(string content, params string[] values)
             foreach (string value in values)
             {
                 int nextIndex = content.IndexOf(value, index);
-                Assert.GreaterOrEqual(nextIndex, 0, string.Format("Looking for {0}", value));
+                Assert.That(nextIndex, Is.GreaterThanOrEqualTo(0), () => $"Looking for {value}");
                 index = nextIndex + value.Length;
             }
         }
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/BaseViewComponentTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/BaseViewComponentTests.cs
index 68ccc496..8ac85e11 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/BaseViewComponentTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/BaseViewComponentTests.cs
@@ -29,14 +29,16 @@ public class BaseViewComponentTests
         protected StubEngineContext engineContext;
         protected SparkViewFactory factory;
         protected IController controller;
-        
+
         [SetUp]
         public virtual void Init()
         {
             mocks = new MockRepository();
 
-            var services = new StubMonoRailServices();
-            services.ViewSourceLoader = new FileAssemblyViewSourceLoader("MonoRail.Tests.Views");
+            var services = new StubMonoRailServices
+            {
+                ViewSourceLoader = new FileAssemblyViewSourceLoader("MonoRail.Tests.Views")
+            };
             services.AddService(typeof(IViewSourceLoader), services.ViewSourceLoader);
 
             viewComponentFactory = new DefaultViewComponentFactory();
@@ -55,12 +57,20 @@ public virtual void Init()
 
             controller = MockRepository.GenerateMock<IController>();
             controllerContext = new ControllerContext();
-            var request = new StubRequest();
-            request.FilePath = "";
+            var request = new StubRequest
+            {
+                FilePath = ""
+            };
             var response = new StubResponse();
             engineContext = new StubEngineContext(request, response, new UrlInfo("", "Home", "Index", "/", "castle"));
             engineContext.AddService(typeof(IViewComponentFactory), viewComponentFactory);
             engineContext.AddService(typeof(IViewComponentRegistry), viewComponentFactory.Registry);
         }
+
+        [TearDown]
+        public virtual void TearDown()
+        {
+            controller.Dispose();
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentExtensionTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentExtensionTests.cs
index 2d7a7994..a2e5777f 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentExtensionTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentExtensionTests.cs
@@ -26,14 +26,14 @@ namespace Castle.MonoRail.Views.Spark.Tests.ViewComponents
     [TestFixture]
     public class ViewComponentExtensionTests : BaseViewComponentTests
     {
-        
+
 
         [Test]
         public void DiggPaginationComponent()
         {
             var writer = new StringWriter();
             IList<string> dataSource = new List<string>();
-            for(int i = 100; i != 200; i++)
+            for (int i = 100; i != 200; i++)
                 dataSource.Add(i.ToString());
 
             controllerContext.PropertyBag["items"] = PaginationHelper.CreatePagination(dataSource, 10, 3);
@@ -51,69 +51,72 @@ static void ContainsInOrder(string content, params string[] values)
             foreach (string value in values)
             {
                 int nextIndex = content.IndexOf(value, index);
-                Assert.GreaterOrEqual(nextIndex, 0, string.Format("Looking for {0}", value));
+                Assert.That(nextIndex, Is.GreaterThanOrEqualTo(0), () => $"Looking for {value}");
                 index = nextIndex + value.Length;
             }
         }
 
 
-		[ViewComponentDetails("Simple")]
-		public class SimpleViewComponent : ViewComponent
-		{
-			[ViewComponentParam]
-			public string Caption { get; set; }
-
-			public override void Render()
-			{
-				RenderText("<p>" + Caption + "</p>");
-			}
-		}
-
-		[Test]
-		public void ComponentsSupportEachAttribute()
-		{
-			viewComponentFactory.Registry.AddViewComponent("Simple", typeof(SimpleViewComponent));
-
-			var writer = new StringWriter();
-		    factory.Process(string.Format("Home{0}ComponentsSupportEachAttribute", Path.DirectorySeparatorChar), writer,
-		                    engineContext, controller, controllerContext);
-
-			ContainsInOrder(writer.ToString(),
-							"<p>alpha</p>",
-							"<p>beta</p>",
-							"<p>gamma</p>");
-		}
-
-    	[Test]
-		public void ComponentsSupportIfAttribute()
-		{
-			viewComponentFactory.Registry.AddViewComponent("Simple", typeof(SimpleViewComponent));
-
-			var writer = new StringWriter();
-    	    factory.Process(string.Format("Home{0}ComponentsSupportIfAttribute", Path.DirectorySeparatorChar), writer,
-    	                    engineContext, controller, controllerContext);
-
-			ContainsInOrder(writer.ToString(),
-							"<p>foo1</p>",
-							"<p>alpha</p>",
-							"<p>gamma</p>");
-			Assert.IsFalse(writer.ToString().Contains("foo2"));
-			Assert.IsFalse(writer.ToString().Contains("beta"));
-		}
-
-		[Test]
-		public void ComponentsSupportOnceAttribute()
-		{
-			viewComponentFactory.Registry.AddViewComponent("Simple", typeof(SimpleViewComponent));
-
-			var writer = new StringWriter();
-		    factory.Process(string.Format("Home{0}ComponentsSupportOnceAttribute", Path.DirectorySeparatorChar), writer,
-		                    engineContext, controller, controllerContext);
-
-			ContainsInOrder(writer.ToString(),
-							"<p>foo1</p>",
-							"<p>foo2</p>");
-			Assert.IsFalse(writer.ToString().Contains("foo3"));
-		}
-	}
+        [ViewComponentDetails("Simple")]
+        public class SimpleViewComponent : ViewComponent
+        {
+            [ViewComponentParam]
+            public string Caption { get; set; }
+
+            public override void Render()
+            {
+                RenderText("<p>" + Caption + "</p>");
+            }
+        }
+
+        [Test]
+        public void ComponentsSupportEachAttribute()
+        {
+            viewComponentFactory.Registry.AddViewComponent("Simple", typeof(SimpleViewComponent));
+
+            var writer = new StringWriter();
+            factory.Process(string.Format("Home{0}ComponentsSupportEachAttribute", Path.DirectorySeparatorChar), writer,
+                            engineContext, controller, controllerContext);
+
+            ContainsInOrder(writer.ToString(),
+                            "<p>alpha</p>",
+                            "<p>beta</p>",
+                            "<p>gamma</p>");
+        }
+
+        [Test]
+        public void ComponentsSupportIfAttribute()
+        {
+            viewComponentFactory.Registry.AddViewComponent("Simple", typeof(SimpleViewComponent));
+
+            var writer = new StringWriter();
+            factory.Process(string.Format("Home{0}ComponentsSupportIfAttribute", Path.DirectorySeparatorChar), writer,
+                            engineContext, controller, controllerContext);
+
+            ContainsInOrder(writer.ToString(),
+                            "<p>foo1</p>",
+                            "<p>alpha</p>",
+                            "<p>gamma</p>");
+            Assert.Multiple(() =>
+            {
+                Assert.That(writer.ToString().Contains("foo2"), Is.False);
+                Assert.That(writer.ToString().Contains("beta"), Is.False);
+            });
+        }
+
+        [Test]
+        public void ComponentsSupportOnceAttribute()
+        {
+            viewComponentFactory.Registry.AddViewComponent("Simple", typeof(SimpleViewComponent));
+
+            var writer = new StringWriter();
+            factory.Process(string.Format("Home{0}ComponentsSupportOnceAttribute", Path.DirectorySeparatorChar), writer,
+                            engineContext, controller, controllerContext);
+
+            ContainsInOrder(writer.ToString(),
+                            "<p>foo1</p>",
+                            "<p>foo2</p>");
+            Assert.That(writer.ToString().Contains("foo3"), Is.False);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentRenderBodyTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentRenderBodyTests.cs
index aeaee085..706c606c 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentRenderBodyTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentRenderBodyTests.cs
@@ -45,9 +45,12 @@ public void ComponentBodySimpleHtml()
             mocks.VerifyAll();
 
             var content = writer.ToString();
-            Assert.That(content.Contains("<p>This is text</p>"));
-            Assert.IsFalse(content.Contains("<ComponentWithBody>"));
-            Assert.IsFalse(content.Contains("</ComponentWithBody>"));
+            Assert.That(content, Does.Contain("<p>This is text</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content.Contains("<ComponentWithBody>"), Is.False);
+                Assert.That(content.Contains("</ComponentWithBody>"), Is.False);
+            });
         }
 
 
@@ -63,13 +66,16 @@ public void ComponentBodyHtmlHasAttributes()
             mocks.VerifyAll();
 
             var content = writer.ToString();
-            Assert.That(content.Contains("<script src=\"foo.js\"></script>"));
-            Assert.That(content.Contains("<link href=\"bar.css\"/>"));
-            Assert.IsFalse(content.Contains("<ComponentWithBody>"));
-            Assert.IsFalse(content.Contains("</ComponentWithBody>"));
+            Assert.That(content, Does.Contain("<script src=\"foo.js\"></script>"));
+            Assert.That(content, Does.Contain("<link href=\"bar.css\"/>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content.Contains("<ComponentWithBody>"), Is.False);
+                Assert.That(content.Contains("</ComponentWithBody>"), Is.False);
+            });
         }
 
-        
+
         [Test]
         public void RenderingComponentWithBodyAndNoDetailsAttrib()
         {
@@ -83,9 +89,12 @@ public void RenderingComponentWithBodyAndNoDetailsAttrib()
             mocks.VerifyAll();
 
             var content = writer.ToString();
-            Assert.That(content.Contains("<p>This is text</p>"));
-            Assert.IsFalse(content.Contains("<ComponentWithBodyAndNoDetailsAttrib>"));
-            Assert.IsFalse(content.Contains("</ComponentWithBodyAndNoDetailsAttrib>"));
+            Assert.That(content, Does.Contain("<p>This is text</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content.Contains("<ComponentWithBodyAndNoDetailsAttrib>"), Is.False);
+                Assert.That(content.Contains("</ComponentWithBodyAndNoDetailsAttrib>"), Is.False);
+            });
         }
     }
 
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentRenderViewTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentRenderViewTests.cs
index c4dbf1dd..251d36a4 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentRenderViewTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentRenderViewTests.cs
@@ -41,7 +41,7 @@ public void ComponentCallingRenderView()
                             writer, engineContext, controller, controllerContext);
 
             var output = writer.ToString();
-            Assert.IsTrue(output.Contains("This is a widget"));
+            Assert.That(output, Does.Contain("This is a widget"));
         }
 
         [Test]
@@ -55,8 +55,8 @@ public void ComponentRenderViewWithParameters()
                 engineContext, controller, controllerContext);
 
             var output = writer.ToString();
-            Assert.IsTrue(output.Contains("Mode Alpha and 123"));
-            Assert.IsTrue(output.Contains("Mode Beta and 456"));
+            Assert.That(output, Does.Contain("Mode Alpha and 123"));
+            Assert.That(output, Does.Contain("Mode Beta and 456"));
         }
 
         [Test]
@@ -69,8 +69,8 @@ public void ComponentRenderViewWithContent()
                             writer, engineContext, controller, controllerContext);
 
             var output = writer.ToString();
-            Assert.IsTrue(output.Contains("Mode Delta and 789"));
-            Assert.IsTrue(output.Contains("<p class=\"message\">!!Delta!!</p>"));
+            Assert.That(output, Does.Contain("Mode Delta and 789"));
+            Assert.That(output, Does.Contain("<p class=\"message\">!!Delta!!</p>"));
         }
 
         [Test]
@@ -94,7 +94,7 @@ public void ComponentRenderViewFromEmbeddedResource()
             mocks.VerifyAll();
 
             var content = writer.ToString();
-            Assert.That(content.Contains("<p>This was embedded</p>"));
+            Assert.That(content, Does.Contain("<p>This was embedded</p>"));
         }
 
         [Test]
@@ -112,9 +112,9 @@ public void ComponentRenderViewSharesOnceFlags()
             mocks.VerifyAll();
 
             var content = writer.ToString();
-            Assert.That(content.Contains("<p>ok1</p>"));
-            Assert.That(content.Contains("<p>ok2</p>"));
-            Assert.IsFalse(content.Contains("fail"));
+            Assert.That(content, Does.Contain("<p>ok1</p>"));
+            Assert.That(content, Does.Contain("<p>ok2</p>"));
+            Assert.That(content.Contains("fail"), Is.False);
         }
 
         [Test]
@@ -132,7 +132,7 @@ public void ComponentRenderViewUsesGlobalSpark()
             mocks.VerifyAll();
 
             var content = writer.ToString();
-            Assert.That(content.Contains("<p>ok1</p>"));
+            Assert.That(content, Does.Contain("<p>ok1</p>"));
         }
 
         [ViewComponentDetails("WidgetComponent")]
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentSectionChunkBuilderVisitorTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentSectionChunkBuilderVisitorTests.cs
index a6dce210..79905963 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentSectionChunkBuilderVisitorTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentSectionChunkBuilderVisitorTests.cs
@@ -31,13 +31,16 @@ public void CorrectSectionsCreated()
             var nodes = grammar.Nodes(new Position(new SourceContext(
                                                        "<foo>1<tr>2<td>3</foo> <bar>4</td>5</tr>6</bar> stuff <baaz>yadda<baaz></baaz><quux><quux/></baaz>")));
             var details = new ViewComponentDetailsAttribute("Testing") { Sections = "foo,baaz,bar,quux" };
-            var visitor = new ViewComponentVisitor(new ChunkBuilderVisitor(new VisitorContext{Paint=nodes.Rest.GetPaint()}), new ViewComponentInfo { Details = details });
+            var visitor = new ViewComponentVisitor(new ChunkBuilderVisitor(new VisitorContext { Paint = nodes.Rest.GetPaint() }), new ViewComponentInfo { Details = details });
             visitor.Accept(nodes.Value);
-            Assert.AreEqual(3, visitor.Sections.Count);
+            Assert.That(visitor.Sections.Count, Is.EqualTo(3));
 
-            Assert.AreEqual(1, visitor.Sections["foo"].Count);
+            Assert.Multiple(() =>
+            {
+                Assert.That(visitor.Sections["foo"].Count, Is.EqualTo(1));
 
-            Assert.AreEqual("1<tr>2<td>3", ((SendLiteralChunk)visitor.Sections["foo"][0]).Text);
+                Assert.That(((SendLiteralChunk)visitor.Sections["foo"][0]).Text, Is.EqualTo("1<tr>2<td>3"));
+            });
         }
 
 
diff --git a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentSectionTests.cs b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentSectionTests.cs
index e222aac5..ecdf9717 100644
--- a/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentSectionTests.cs
+++ b/src/Castle.MonoRail.Views.Spark.Tests/ViewComponents/ViewComponentSectionTests.cs
@@ -44,9 +44,9 @@ public void ComponentWithSimpleSections()
                             writer, engineContext, controller, controllerContext);
 
             var output = writer.ToString();
-            Assert.IsTrue(output.Contains("this-is-a-header"));
-            Assert.IsTrue(output.Contains("this-is-a-body"));
-            Assert.IsTrue(output.Contains("this-is-a-footer"));
+            Assert.That(output, Does.Contain("this-is-a-header"));
+            Assert.That(output, Does.Contain("this-is-a-body"));
+            Assert.That(output, Does.Contain("this-is-a-footer"));
         }
 
         [Test]
@@ -59,9 +59,12 @@ public void ComponentWithIfConditionInSection()
                             writer, engineContext, controller, controllerContext);
 
             var output = writer.ToString();
-            Assert.IsTrue(output.Contains("this-should-show-up"));
-            Assert.IsFalse(output.Contains("this-should-not-show-up"));
-            Assert.IsFalse(output.Contains("if condition"));
+            Assert.That(output, Does.Contain("this-should-show-up"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(output.Contains("this-should-not-show-up"), Is.False);
+                Assert.That(output.Contains("if condition"), Is.False);
+            });
         }
 
         [Test]
@@ -79,8 +82,11 @@ public void ComponentWithForEachInSection()
                 "<span>10</span>",
                 "<span>9</span>",
                 "<span>8</span>"));
-            Assert.IsFalse(output.Contains("for each"));
-            Assert.IsFalse(output.Contains("span each"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(output.Contains("for each"), Is.False);
+                Assert.That(output.Contains("span each"), Is.False);
+            });
         }
 
         [Test]
@@ -93,7 +99,7 @@ public void ComponentWithPartialsInSection()
                             engineContext, controller, controllerContext);
 
             var output = writer.ToString();
-            Assert.IsTrue(output.Contains("this is some text: test123"));
+            Assert.That(output, Does.Contain("this is some text: test123"));
         }
 
         [Test]
@@ -106,20 +112,23 @@ public void NestedComponentInSection()
                             engineContext, controller, controllerContext);
 
             var output = writer.ToString();
-            Assert.IsTrue(output.Contains("header1"));
-            Assert.IsTrue(output.Contains("header2"));
-            Assert.IsTrue(output.Contains("body1"));
-            Assert.IsTrue(output.Contains("body2"));
-            Assert.IsTrue(output.Contains("footer1"));
-            Assert.IsTrue(output.Contains("footer2"));
-
-            Assert.IsFalse(output.Contains("<header>"));
-            Assert.IsFalse(output.Contains("<body>"));
-            Assert.IsFalse(output.Contains("<footer>"));
-            Assert.IsFalse(output.Contains("</ComponentWithSections>"));
+            Assert.That(output, Does.Contain("header1"));
+            Assert.That(output, Does.Contain("header2"));
+            Assert.That(output, Does.Contain("body1"));
+            Assert.That(output, Does.Contain("body2"));
+            Assert.That(output, Does.Contain("footer1"));
+            Assert.That(output, Does.Contain("footer2"));
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(output.Contains("<header>"), Is.False);
+                Assert.That(output.Contains("<body>"), Is.False);
+                Assert.That(output.Contains("<footer>"), Is.False);
+                Assert.That(output.Contains("</ComponentWithSections>"), Is.False);
+            });
         }
 
-        [ViewComponentDetails("ComponentWithSections",Sections="header,body,footer")]
+        [ViewComponentDetails("ComponentWithSections", Sections = "header,body,footer")]
         class ComponentWithSections : ViewComponent
         {
             public override void Render()
diff --git a/src/Castle.Monorail.Pdf.Tests/Castle.Monorail.Pdf.Tests.csproj b/src/Castle.Monorail.Pdf.Tests/Castle.Monorail.Pdf.Tests.csproj
index 9f13eac9..7ff22af4 100644
--- a/src/Castle.Monorail.Pdf.Tests/Castle.Monorail.Pdf.Tests.csproj
+++ b/src/Castle.Monorail.Pdf.Tests/Castle.Monorail.Pdf.Tests.csproj
@@ -20,8 +20,12 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-	<PackageReference Include="NUnit" Version="3.14.0" />
-	<PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+	<PackageReference Include="NUnit" Version="4.2.2" />
+	<PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+	  <PrivateAssets>all</PrivateAssets>
+	  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	</PackageReference>
+	<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
 	<PackageReference Include="RhinoMocks" Version="3.6.1" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Castle.Monorail.Pdf.Tests/FormatReturnBinderTests.cs b/src/Castle.Monorail.Pdf.Tests/FormatReturnBinderTests.cs
index 97068bc3..2ad543e1 100644
--- a/src/Castle.Monorail.Pdf.Tests/FormatReturnBinderTests.cs
+++ b/src/Castle.Monorail.Pdf.Tests/FormatReturnBinderTests.cs
@@ -8,24 +8,24 @@
 namespace Castle.MonoRail.Pdf.Tests
 {
     [TestFixture]
-    public class FormatReturnBinderTests: BaseControllerTest
+    public class FormatReturnBinderTests : BaseControllerTest
     {
         protected Controller controller;
         protected StubMonoRailServices services;
         protected InjectableStubViewEngineManager viewEngineManager;
         protected StubEngineContext engineContext;
         protected IControllerContext controllerContext;
-        
+
         [Test]
         public void RequestsForNonHandledExtensionsAreIgnored()
         {
             engineContext.UrlInfo = new UrlInfo(null, "ReturnBinderTest", "Index", null, "rails");
             controller.Process(controller.Context, controllerContext);
 
-            Assert.AreEqual(200, controller.Context.Response.StatusCode);
-            Assert.AreEqual("OK", controller.Context.Response.StatusDescription);
-            Assert.AreEqual(string.Format("ReturnBinderTest{0}Index", Path.DirectorySeparatorChar), viewEngineManager.TemplateRendered);
-            Assert.AreEqual(0, controller.Context.Response.Output.ToString().Length);
+            Assert.That(controller.Context.Response.StatusCode, Is.EqualTo(200));
+            Assert.That(controller.Context.Response.StatusDescription, Is.EqualTo("OK"));
+            Assert.That(viewEngineManager.TemplateRendered, Is.EqualTo(string.Format("ReturnBinderTest{0}Index", Path.DirectorySeparatorChar)));
+            Assert.That(controller.Context.Response.Output.ToString().Length, Is.EqualTo(0));
         }
 
         [Test]
@@ -34,12 +34,12 @@ public void RequestsForJsonAreHandled()
             engineContext.UrlInfo = new UrlInfo(null, "ReturnBinderTest", "Index", null, "json");
             controller.Process(controller.Context, controllerContext);
 
-            Assert.AreEqual(200, controller.Context.Response.StatusCode);
-            Assert.AreEqual("OK", controller.Context.Response.StatusDescription);
-            Assert.IsNull(viewEngineManager.TemplateRendered);
-            Assert.AreEqual("application/json, text/javascript", controller.Context.Response.ContentType);
-            Assert.AreEqual("{\"Foo\":\"Bar\"}", controller.Context.Response.Output.ToString());
- 
+            Assert.That(controller.Context.Response.StatusCode, Is.EqualTo(200));
+            Assert.That(controller.Context.Response.StatusDescription, Is.EqualTo("OK"));
+            Assert.That(viewEngineManager.TemplateRendered, Is.Null);
+            Assert.That(controller.Context.Response.ContentType, Is.EqualTo("application/json, text/javascript"));
+            Assert.That(controller.Context.Response.Output.ToString(), Is.EqualTo("{\"Foo\":\"Bar\"}"));
+
         }
 
         [Test]
@@ -49,11 +49,11 @@ public void RequestsForPdfAreHandled()
             viewEngineManager.SetRenderedOutPut("<itext><paragraph>hello</paragraph></itext>");
             controller.Process(controller.Context, controllerContext);
 
-            Assert.AreEqual(200, controller.Context.Response.StatusCode);
-            Assert.AreEqual("OK", controller.Context.Response.StatusDescription);
-            Assert.AreEqual(string.Format("ReturnBinderTest{0}Index.pdf.spark", Path.DirectorySeparatorChar), viewEngineManager.TemplateRendered);
-            Assert.AreEqual("application/pdf", controller.Context.Response.ContentType);
-            Assert.Greater(controller.Context.Response.OutputStream.Length, 0);
+            Assert.That(controller.Context.Response.StatusCode, Is.EqualTo(200));
+            Assert.That(controller.Context.Response.StatusDescription, Is.EqualTo("OK"));
+            Assert.That(viewEngineManager.TemplateRendered, Is.EqualTo(string.Format("ReturnBinderTest{0}Index.pdf.spark", Path.DirectorySeparatorChar)));
+            Assert.That(controller.Context.Response.ContentType, Is.EqualTo("application/pdf"));
+            Assert.That(controller.Context.Response.OutputStream.Length, Is.GreaterThan(0));
         }
 
         [SetUp]
@@ -75,7 +75,12 @@ public void SetUp()
             controller.Contextualize(controller.Context, controllerContext);
             viewEngineManager.RegisterTemplate(string.Format("ReturnBinderTest{0}Index", Path.DirectorySeparatorChar));
         }
-        
+
+        [TearDown]
+        public void TearDown()
+        {
+            controller.Dispose();
+        }
     }
 
     public class SampleViewModel
diff --git a/src/Castle.Monorail.Pdf.Tests/Stubs/InjectableStubViewEngineManager.cs b/src/Castle.Monorail.Pdf.Tests/Stubs/InjectableStubViewEngineManager.cs
index e60b7b7e..827a3006 100644
--- a/src/Castle.Monorail.Pdf.Tests/Stubs/InjectableStubViewEngineManager.cs
+++ b/src/Castle.Monorail.Pdf.Tests/Stubs/InjectableStubViewEngineManager.cs
@@ -59,7 +59,7 @@ public void RegisterTemplate(string template)
         public bool HasTemplate(string templateName)
         {
             return templates.Exists(
-                delegate(string item) { return item.Equals(templateName, StringComparison.InvariantCultureIgnoreCase); });
+                delegate (string item) { return item.Equals(templateName, StringComparison.InvariantCultureIgnoreCase); });
         }
 
 
diff --git a/src/Spark.AspNetCore.Mvc/Spark.AspNetCore.Mvc.csproj b/src/Spark.AspNetCore.Mvc/Spark.AspNetCore.Mvc.csproj
index e541238c..d1c09075 100644
--- a/src/Spark.AspNetCore.Mvc/Spark.AspNetCore.Mvc.csproj
+++ b/src/Spark.AspNetCore.Mvc/Spark.AspNetCore.Mvc.csproj
@@ -1,20 +1,36 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
-    
     <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
+        <SignAssembly>False</SignAssembly>
+        <AssemblyOriginatorKeyFile>..\SparkKey.snk</AssemblyOriginatorKeyFile>
+        <Company>Louis DeJardin</Company>
+        <PackageProjectUrl>https://github.com/SparkViewEngine/</PackageProjectUrl>
+        <PackageReadmeFile>README.md</PackageReadmeFile>
+        <RepositoryUrl>https://github.com/SparkViewEngine/spark</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+        <IncludeSymbols>True</IncludeSymbols>
+        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+        <PackageLicenseFile>license.txt</PackageLicenseFile>
+        <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
+        <PackageTags>spark;view engine</PackageTags>
+        <Copyright>Copyright (c) Louis DeJardin 2008-2024</Copyright>
+        <Description>Spark is a view engine allowing the HTML to dominate the flow and any code to fit seamlessly.</Description>
+    </PropertyGroup>
+    <PropertyGroup>
+        <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" />
-        <PackageReference Include="System.Configuration.ConfigurationManager" Version="8.0.0" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.12.0" />
+        <PackageReference Include="System.Configuration.ConfigurationManager" Version="9.0.0" />
     </ItemGroup>
 
     <ItemGroup>
       <ProjectReference Include="..\Spark\Spark.csproj" />
     </ItemGroup>
 
+
     <ItemGroup>
         <None Include="..\..\license.txt">
             <Pack>True</Pack>
diff --git a/src/Spark.Python.Tests/PythonViewCompilerTests.cs b/src/Spark.Python.Tests/PythonViewCompilerTests.cs
index 259d984f..35ba5bee 100644
--- a/src/Spark.Python.Tests/PythonViewCompilerTests.cs
+++ b/src/Spark.Python.Tests/PythonViewCompilerTests.cs
@@ -75,10 +75,13 @@ public void CreatedViewHasScriptProperty()
             var source = _compiler.SourceCode;
             var script = view.ScriptSource;
 
-            Assert.IsNotNull(source);
-            Assert.IsNotEmpty(source);
-            Assert.IsNotNull(script);
-            Assert.IsNotEmpty(script);
+            Assert.That(source, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(source, Is.Not.Empty);
+                Assert.That(script, Is.Not.Null);
+            });
+            Assert.That(script, Is.Not.Empty);
         }
 
         [Test]
@@ -88,7 +91,7 @@ public void CodeInheritsBaseClass()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains(": Spark.Tests.Stubs.StubSparkView"));
+            Assert.That(_compiler.SourceCode, Does.Contain(": Spark.Tests.Stubs.StubSparkView"));
         }
 
         [Test]
@@ -98,7 +101,7 @@ public void CodeInheritsBaseClassWithTModel()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains(": Spark.Tests.Stubs.StubSparkView<ThisIsTheModelClass>"));
+            Assert.That(_compiler.SourceCode, Does.Contain(": Spark.Tests.Stubs.StubSparkView<ThisIsTheModelClass>"));
         }
 
         [Test]
@@ -113,17 +116,17 @@ public void LayeredTemplates()
             _compiler.CompileView(chunks, chunks);
             var content = ExecuteView();
 
-            Assert.AreEqual("420", content);
+            Assert.That(content, Is.EqualTo("420"));
         }
 
         [/*Test,*/ Ignore("Not really sure if namespaces play a role in a dlr based spark view")]
-        public void UsingNamespaces()
+        private void UsingNamespaces()
         {
             var chunks = Chunks(new UseNamespaceChunk { Namespace = "AnotherNamespace.ToBe.Used" });
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("Imports AnotherNamespace.ToBe.Used"));
+            Assert.That(_compiler.SourceCode, Does.Contain("Imports AnotherNamespace.ToBe.Used"));
         }
 
         [Test]
@@ -134,19 +137,19 @@ public void TargetNamespace()
             _compiler.Descriptor = new SparkViewDescriptor { TargetNamespace = "TargetNamespace.ForThe.GeneratedView" };
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("namespace TargetNamespace.ForThe.GeneratedView"));
+            Assert.That(_compiler.SourceCode, Does.Contain("namespace TargetNamespace.ForThe.GeneratedView"));
         }
 
         [/*Test,*/ Ignore("Not really sure if namespaces play a role in a dlr based spark view")]
-        public void TargetNamespaceWithUsingNamespaces()
+        private void TargetNamespaceWithUsingNamespaces()
         {
             var chunks = Chunks(new UseNamespaceChunk { Namespace = "AnotherNamespace.ToBe.Used" });
 
             _compiler.Descriptor = new SparkViewDescriptor { TargetNamespace = "TargetNamespace.ForThe.GeneratedView" };
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("Namespace TargetNamespace.ForThe.GeneratedView"));
-            Assert.That(_compiler.SourceCode.Contains("Imports AnotherNamespace.ToBe.Used"));
+            Assert.That(_compiler.SourceCode, Does.Contain("Namespace TargetNamespace.ForThe.GeneratedView"));
+            Assert.That(_compiler.SourceCode, Does.Contain("Imports AnotherNamespace.ToBe.Used"));
         }
 
         [Test]
@@ -157,10 +160,10 @@ public void ViewDescriptorAttribute()
             _compiler.Descriptor = new SparkViewDescriptor { TargetNamespace = "TargetNamespace.ForThe.GeneratedView", Templates = new[] { "one", "two", "three" } };
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("SparkViewAttribute"));
-            Assert.That(_compiler.SourceCode.Contains("one"));
-            Assert.That(_compiler.SourceCode.Contains("two"));
-            Assert.That(_compiler.SourceCode.Contains("three"));
+            Assert.That(_compiler.SourceCode, Does.Contain("SparkViewAttribute"));
+            Assert.That(_compiler.SourceCode, Does.Contain("one"));
+            Assert.That(_compiler.SourceCode, Does.Contain("two"));
+            Assert.That(_compiler.SourceCode, Does.Contain("three"));
         }
 
         [Test]
@@ -170,8 +173,8 @@ public void ContainsGeneratedViewIdProperty()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("GeneratedViewId"));
-            Assert.That(_compiler.SourceCode.Contains("\"" + _compiler.GeneratedViewId + "\""));
+            Assert.That(_compiler.SourceCode, Does.Contain("GeneratedViewId"));
+            Assert.That(_compiler.SourceCode, Does.Contain("\"" + _compiler.GeneratedViewId + "\""));
         }
 
         [Test]
@@ -181,7 +184,7 @@ public void SendingLiteralOutput()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("Hello World"));
+            Assert.That(_compiler.SourceCode, Does.Contain("Hello World"));
         }
 
         [Test]
@@ -191,7 +194,7 @@ public void SendingIndentedExpressionOutput()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("5 + 3"));
+            Assert.That(_compiler.SourceCode, Does.Contain("5 + 3"));
         }
 
         [Test]
@@ -200,7 +203,7 @@ public void RenderingSimpleView()
             var chunks = Chunks(new SendLiteralChunk { Text = "Hello World" });
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
-            Assert.AreEqual("Hello World", contents);
+            Assert.That(contents, Is.EqualTo("Hello World"));
         }
 
         [Test]
@@ -223,7 +226,7 @@ public void SettingLocalVariable()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("42", contents);
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
 
@@ -238,7 +241,7 @@ public void SettingGlobalVariable()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("42", contents);
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [Test]
@@ -249,11 +252,11 @@ public void UsingViewData()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView(new StubViewData { { "hello", 42 } });
 
-            Assert.AreEqual("42", contents);
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [/*Test,*/ Ignore("Not really sure if namespaces play a role in a dlr based spark view")]
-        public void UsingViewDataDefault()
+        private void UsingViewDataDefault()
         {
             var chunks = Chunks(
                 new ViewDataChunk { Type = "int", Name = "HelloNumber", Key = "hello", Default = "55" },
@@ -263,11 +266,11 @@ public void UsingViewDataDefault()
 
             var contents = ExecuteView(new StubViewData { { "hello", 42 } });
 
-            Assert.AreEqual("42", contents);
+            Assert.That(contents, Is.EqualTo("42"));
 
             var contents2 = ExecuteView();
 
-            Assert.AreEqual("55", contents2);
+            Assert.That(contents2, Is.EqualTo("55"));
         }
 
         [Test]
@@ -281,7 +284,7 @@ public void InlineCodeStatements()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual(contents, "42");
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [Test]
@@ -298,7 +301,7 @@ public void ScopeTest()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual(contents, "42");
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [Test]
@@ -312,17 +315,17 @@ public void ForEachLoopOverArray()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView(new StubViewData { { "numbers", new[] { 1, 2, 3, 4, 5 } } });
 
-            Assert.AreEqual("12345", contents);
+            Assert.That(contents, Is.EqualTo("12345"));
         }
 
         [Test]
         public void MacroAddsFunction()
         {
             var macro = new MacroChunk
-                        {
-                            Name = "foo",
-                            Parameters = new[] { new MacroParameter { Name = "x", Type = "string" } }
-                        };
+            {
+                Name = "foo",
+                Parameters = new[] { new MacroParameter { Name = "x", Type = "string" } }
+            };
             macro.Body.Add(new SendExpressionChunk { Code = "x" });
             var chunks = Chunks(
                 new SendExpressionChunk { Code = "foo(\"hello\")" },
@@ -330,7 +333,7 @@ public void MacroAddsFunction()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("hello", contents);
+            Assert.That(contents, Is.EqualTo("hello"));
         }
 
         [Test]
@@ -349,7 +352,7 @@ public void ConditionalChunkControlsExecution()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("aok1b", contents);
+            Assert.That(contents, Is.EqualTo("aok1b"));
         }
 
         [Test]
@@ -376,7 +379,7 @@ public void ElseBlockFollowsIf()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("aok1ok2b", contents);
+            Assert.That(contents, Is.EqualTo("aok1ok2b"));
         }
 
         [Test]
@@ -395,7 +398,7 @@ public void ConditionalChunkUnlessNegates()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("aok1b", contents);
+            Assert.That(contents, Is.EqualTo("aok1b"));
         }
 
         [Test]
@@ -421,7 +424,7 @@ public void ChainingElseIfNestsProperly()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView(new StubViewData { { "numbers", new[] { 0, 1, 2, 3, 4, 7, 2, -4 } } });
 
-            Assert.AreEqual("dabcddbd", contents);
+            Assert.That(contents, Is.EqualTo("dabcddbd"));
         }
 
         [Test]
@@ -438,7 +441,7 @@ public void RenderPartial()
             _compiler.CompileView(chunks, new[] { chunks[0], partial[0] });
             var contents = ExecuteView();
 
-            Assert.AreEqual("(Hello world)", contents);
+            Assert.That(contents, Is.EqualTo("(Hello world)"));
         }
 
         [Test]
@@ -460,7 +463,7 @@ public void RenderPartialWithContainedContent()
             _compiler.CompileView(chunks, new[] { chunks[0], partial[0] });
             var contents = ExecuteView();
 
-            Assert.AreEqual("([From inside caller])", contents);
+            Assert.That(contents, Is.EqualTo("([From inside caller])"));
         }
 
         [Test]
@@ -486,7 +489,7 @@ public void RenderPartialWithSectionContent()
             _compiler.CompileView(chunks, new[] { chunks[0], partial[0] });
             var contents = ExecuteView();
 
-            Assert.AreEqual("([From inside caller])", contents);
+            Assert.That(contents, Is.EqualTo("([From inside caller])"));
         }
 
         [Test]
@@ -505,7 +508,7 @@ public void CaptureContentToVariable()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("bac", contents);
+            Assert.That(contents, Is.EqualTo("bac"));
         }
 
         [Test]
@@ -520,7 +523,7 @@ public void CaptureContentToNamedSpool()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("abc", contents);
+            Assert.That(contents, Is.EqualTo("abc"));
         }
 
         [Test]
@@ -539,7 +542,7 @@ public void DefaultVariablesWorking()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("abe", contents);
+            Assert.That(contents, Is.EqualTo("abe"));
         }
 
         [Test]
@@ -568,7 +571,7 @@ public void OnceTestSendsThingsOnce()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("42", contents);
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [Test]
@@ -585,7 +588,7 @@ public void HandleNullReferences()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("1${user.Name}23", contents);
+            Assert.That(contents, Is.EqualTo("1${user.Name}23"));
         }
 
         [Test]
@@ -606,7 +609,7 @@ public void ForLoopAutovariables()
                                            {"stuff", new[] {6, 2, 7, 4}}
                                        });
 
-            Assert.AreEqual("04TrueFalse14FalseFalse24FalseFalse34FalseTrue", contents);
+            Assert.That(contents, Is.EqualTo("04TrueFalse14FalseFalse24FalseFalse34FalseTrue"));
         }
 
         [Test]
@@ -625,7 +628,7 @@ public void CallingMacro()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("213", contents);
+            Assert.That(contents, Is.EqualTo("213"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Python.Tests/ScriptingLanguageFactoryTests.cs b/src/Spark.Python.Tests/ScriptingLanguageFactoryTests.cs
index b167ac6c..fc7b7830 100644
--- a/src/Spark.Python.Tests/ScriptingLanguageFactoryTests.cs
+++ b/src/Spark.Python.Tests/ScriptingLanguageFactoryTests.cs
@@ -34,7 +34,7 @@ public void Init()
             var sp = new ServiceCollection()
                 .AddSpark(settings)
                 .AddSingleton<ISparkLanguageFactory, PythonLanguageFactory>()
-                .BuildServiceProvider();;
+                .BuildServiceProvider(); ;
 
             _engine = (SparkViewEngine)sp.GetService<ISparkViewEngine>();
 
@@ -47,7 +47,7 @@ public void CreatePythonViewCompiler()
             var descriptor = new SparkViewDescriptor().SetLanguage(LanguageType.Python);
             var viewCompiler = _engine.LanguageFactory.CreateViewCompiler(_engine, descriptor);
 
-            Assert.IsAssignableFrom(typeof(PythonViewCompiler), viewCompiler);
+            Assert.That(viewCompiler, Is.AssignableFrom(typeof(PythonViewCompiler)));
         }
 
         [Test]
@@ -57,7 +57,7 @@ public void CreateEntryForView()
             var entry = _engine.CreateEntry(descriptor);
             var view = entry.CreateInstance();
 
-            Assert.IsInstanceOf(typeof(StubSparkView), view);
+            Assert.That(view, Is.InstanceOf(typeof(StubSparkView)));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Python.Tests/ScriptingViewSymbolDictionaryTests.cs b/src/Spark.Python.Tests/ScriptingViewSymbolDictionaryTests.cs
index 8726d824..45a03b6b 100644
--- a/src/Spark.Python.Tests/ScriptingViewSymbolDictionaryTests.cs
+++ b/src/Spark.Python.Tests/ScriptingViewSymbolDictionaryTests.cs
@@ -40,7 +40,7 @@ public class TestView : StubSparkView, IScriptingSparkView
         {
             public override void Render()
             {
-                
+
             }
 
             public override Guid GeneratedViewId
@@ -69,7 +69,7 @@ public CompiledCode CompiledCode
         public void GuidCanBeLocated()
         {
             var viewId = (Guid)_scope.GetVariable("GeneratedViewId");
-            Assert.AreEqual(new Guid("12345678-1234-1234-1234-123456123456"), viewId);
+            Assert.That(viewId, Is.EqualTo(new Guid("12345678-1234-1234-1234-123456123456")));
         }
 
         [Test]
@@ -78,14 +78,14 @@ public void ViewDataCanBeUsed()
             _view.ViewData["foo"] = "bar";
 
             var viewData = (IDictionary<string, object>)_scope.GetVariable("ViewData");
-            Assert.AreEqual("bar", viewData["foo"]);
+            Assert.That(viewData["foo"], Is.EqualTo("bar"));
         }
 
         [Test]
         public void MembersCanBeCalled()
         {
             var siteResource = (Delegate)_scope.GetVariable("SiteResource");
-            Assert.AreEqual("/TestApp/Hello", siteResource.DynamicInvoke("/Hello"));
+            Assert.That(siteResource.DynamicInvoke("/Hello"), Is.EqualTo("/TestApp/Hello"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Python.Tests/Spark.Python.Tests.csproj b/src/Spark.Python.Tests/Spark.Python.Tests.csproj
index d05dcf03..0d0c7fad 100644
--- a/src/Spark.Python.Tests/Spark.Python.Tests.csproj
+++ b/src/Spark.Python.Tests/Spark.Python.Tests.csproj
@@ -20,9 +20,13 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-	<PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="NUnit" Version="4.2.2" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+	<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Spark.Python\Spark.Python.csproj" />
diff --git a/src/Spark.Ruby.Tests/RubyEngineTests.cs b/src/Spark.Ruby.Tests/RubyEngineTests.cs
index 9fa7da60..4909e811 100644
--- a/src/Spark.Ruby.Tests/RubyEngineTests.cs
+++ b/src/Spark.Ruby.Tests/RubyEngineTests.cs
@@ -45,7 +45,7 @@ def render
             scope.SetVariable("view", new View1234 { Output = output });
             compiled.Execute(scope);
 
-            Assert.AreEqual("hello, world", output.ToString());
+            Assert.That(output.ToString(), Is.EqualTo("hello, world"));
         }
     }
 
diff --git a/src/Spark.Ruby.Tests/RubyViewCompilerTests.cs b/src/Spark.Ruby.Tests/RubyViewCompilerTests.cs
index ad38a50a..40ba037b 100644
--- a/src/Spark.Ruby.Tests/RubyViewCompilerTests.cs
+++ b/src/Spark.Ruby.Tests/RubyViewCompilerTests.cs
@@ -76,10 +76,13 @@ public void CreatedViewHasScriptProperty()
             var source = _compiler.SourceCode;
             var script = view.ScriptSource;
 
-            Assert.IsNotNull(source);
-            Assert.IsNotEmpty(source);
-            Assert.IsNotNull(script);
-            Assert.IsNotEmpty(script);
+            Assert.That(source, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(source, Is.Not.Empty);
+                Assert.That(script, Is.Not.Null);
+            });
+            Assert.That(script, Is.Not.Empty);
         }
 
         [Test]
@@ -89,7 +92,7 @@ public void CodeInheritsBaseClass()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains(": Spark.Tests.Stubs.StubSparkView"));
+            Assert.That(_compiler.SourceCode, Does.Contain(": Spark.Tests.Stubs.StubSparkView"));
         }
 
         [Test]
@@ -99,7 +102,7 @@ public void CodeInheritsBaseClassWithTModel()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains(": Spark.Tests.Stubs.StubSparkView<ThisIsTheModelClass>"));
+            Assert.That(_compiler.SourceCode, Does.Contain(": Spark.Tests.Stubs.StubSparkView<ThisIsTheModelClass>"));
         }
 
         [Test]
@@ -114,17 +117,17 @@ public void LayeredTemplates()
             _compiler.CompileView(chunks, chunks);
             var content = ExecuteView();
 
-            Assert.AreEqual("420", content);
+            Assert.That(content, Is.EqualTo("420"));
         }
 
         [/*Test,*/ Ignore("Not really sure if namespaces play a role in a dlr based spark view")]
-        public void UsingNamespaces()
+        private void UsingNamespaces()
         {
             var chunks = Chunks(new UseNamespaceChunk { Namespace = "AnotherNamespace.ToBe.Used" });
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("Imports AnotherNamespace.ToBe.Used"));
+            Assert.That(_compiler.SourceCode, Does.Contain("Imports AnotherNamespace.ToBe.Used"));
         }
 
         [Test]
@@ -135,19 +138,19 @@ public void TargetNamespace()
             _compiler.Descriptor = new SparkViewDescriptor { TargetNamespace = "TargetNamespace.ForThe.GeneratedView" };
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("namespace TargetNamespace.ForThe.GeneratedView"));
+            Assert.That(_compiler.SourceCode, Does.Contain("namespace TargetNamespace.ForThe.GeneratedView"));
         }
 
         [/*Test,*/ Ignore("Not really sure if namespaces play a role in a dlr based spark view")]
-        public void TargetNamespaceWithUsingNamespaces()
+        private void TargetNamespaceWithUsingNamespaces()
         {
             var chunks = Chunks(new UseNamespaceChunk { Namespace = "AnotherNamespace.ToBe.Used" });
 
             _compiler.Descriptor = new SparkViewDescriptor { TargetNamespace = "TargetNamespace.ForThe.GeneratedView" };
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("Namespace TargetNamespace.ForThe.GeneratedView"));
-            Assert.That(_compiler.SourceCode.Contains("Imports AnotherNamespace.ToBe.Used"));
+            Assert.That(_compiler.SourceCode, Does.Contain("Namespace TargetNamespace.ForThe.GeneratedView"));
+            Assert.That(_compiler.SourceCode, Does.Contain("Imports AnotherNamespace.ToBe.Used"));
         }
 
         [Test]
@@ -158,10 +161,10 @@ public void ViewDescriptorAttribute()
             _compiler.Descriptor = new SparkViewDescriptor { TargetNamespace = "TargetNamespace.ForThe.GeneratedView", Templates = new[] { "one", "two", "three" } };
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("SparkViewAttribute"));
-            Assert.That(_compiler.SourceCode.Contains("one"));
-            Assert.That(_compiler.SourceCode.Contains("two"));
-            Assert.That(_compiler.SourceCode.Contains("three"));
+            Assert.That(_compiler.SourceCode, Does.Contain("SparkViewAttribute"));
+            Assert.That(_compiler.SourceCode, Does.Contain("one"));
+            Assert.That(_compiler.SourceCode, Does.Contain("two"));
+            Assert.That(_compiler.SourceCode, Does.Contain("three"));
         }
 
         [Test]
@@ -171,8 +174,8 @@ public void ContainsGeneratedViewIdProperty()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("GeneratedViewId"));
-            Assert.That(_compiler.SourceCode.Contains("\"" + _compiler.GeneratedViewId + "\""));
+            Assert.That(_compiler.SourceCode, Does.Contain("GeneratedViewId"));
+            Assert.That(_compiler.SourceCode, Does.Contain("\"" + _compiler.GeneratedViewId + "\""));
         }
 
         [Test]
@@ -182,7 +185,7 @@ public void SendingLiteralOutput()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("Hello World"));
+            Assert.That(_compiler.SourceCode, Does.Contain("Hello World"));
         }
 
         [Test]
@@ -192,7 +195,7 @@ public void SendingIndentedExpressionOutput()
 
             _compiler.GenerateSourceCode(chunks, chunks);
 
-            Assert.That(_compiler.SourceCode.Contains("5 + 3"));
+            Assert.That(_compiler.SourceCode, Does.Contain("5 + 3"));
         }
 
 
@@ -203,7 +206,7 @@ public void RenderingSimpleView()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("Hello World", contents);
+            Assert.That(contents, Is.EqualTo("Hello World"));
         }
 
 
@@ -228,7 +231,7 @@ public void SettingLocalVariable()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("42", contents);
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
 
@@ -243,7 +246,7 @@ public void SettingGlobalVariable()
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView();
 
-            Assert.AreEqual("42", contents);
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [Test]
@@ -253,12 +256,12 @@ public void UsingViewData()
                 new SendExpressionChunk { Code = "@hello" });
             _compiler.CompileView(chunks, chunks);
             var contents = ExecuteView(new StubViewData { { "hello", 42 } });
-            
-            Assert.AreEqual("42", contents);
+
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [/*Test,*/ Ignore("Not really sure if namespaces play a role in a dlr based spark view")]
-        public void UsingViewDataDefault()
+        private void UsingViewDataDefault()
         {
             var chunks = Chunks(
                 new ViewDataChunk { Type = "int", Name = "HelloNumber", Key = "hello", Default = "55" },
@@ -268,11 +271,11 @@ public void UsingViewDataDefault()
 
             var contents = ExecuteView(new StubViewData { { "hello", 42 } });
 
-            Assert.AreEqual("42", contents);
+            Assert.That(contents, Is.EqualTo("42"));
 
             var contents2 = ExecuteView();
 
-            Assert.AreEqual("55", contents2);
+            Assert.That(contents2, Is.EqualTo("55"));
         }
 
         [Test]
@@ -282,10 +285,10 @@ public void InlineCodeStatements()
                 new CodeStatementChunk { Code = "x = 20" },
                 new SendExpressionChunk { Code = "x + 22" });
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
 
-            Assert.AreEqual(contents, "42");
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [Test]
@@ -300,10 +303,10 @@ public void ScopeTest()
 
             var chunks = Chunks(scope1, scope2);
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
 
-            Assert.AreEqual(contents, "42");
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [Test]
@@ -317,18 +320,18 @@ public void ForEachLoopOverArray()
             _compiler.CompileView(chunks, chunks);
 
             var contents = ExecuteView(new StubViewData { { "numbers", new[] { 1, 2, 3, 4, 5 } } });
-            
-            Assert.AreEqual("12345", contents);
+
+            Assert.That(contents, Is.EqualTo("12345"));
         }
 
         [Test]
         public void MacroAddsFunction()
         {
             var macro = new MacroChunk
-                        {
-                            Name = "foo",
-                            Parameters = new[] { new MacroParameter { Name = "x", Type = "string" } }
-                        };
+            {
+                Name = "foo",
+                Parameters = new[] { new MacroParameter { Name = "x", Type = "string" } }
+            };
             macro.Body.Add(new SendExpressionChunk { Code = "x" });
             var chunks = Chunks(
                 new SendExpressionChunk { Code = "foo(\"hello\")" },
@@ -336,8 +339,8 @@ public void MacroAddsFunction()
             _compiler.CompileView(chunks, chunks);
 
             var contents = ExecuteView();
-            
-            Assert.AreEqual("hello", contents);
+
+            Assert.That(contents, Is.EqualTo("hello"));
         }
 
         [Test]
@@ -354,10 +357,10 @@ public void ConditionalChunkControlsExecution()
                 condition2,
                 new SendLiteralChunk { Text = "b" });
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
 
-            Assert.AreEqual("aok1b", contents);
+            Assert.That(contents, Is.EqualTo("aok1b"));
         }
 
         [Test]
@@ -382,10 +385,10 @@ public void ElseBlockFollowsIf()
                 else2,
                 new SendLiteralChunk { Text = "b" });
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("aok1ok2b", contents);
+
+            Assert.That(contents, Is.EqualTo("aok1ok2b"));
         }
 
         [Test]
@@ -402,10 +405,10 @@ public void ConditionalChunkUnlessNegates()
                 condition2,
                 new SendLiteralChunk { Text = "b" });
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("aok1b", contents);
+
+            Assert.That(contents, Is.EqualTo("aok1b"));
         }
 
         [Test]
@@ -429,10 +432,10 @@ public void ChainingElseIfNestsProperly()
             var chunks = Chunks(
                 loop);
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView(new StubViewData { { "numbers", new[] { 0, 1, 2, 3, 4, 7, 2, -4 } } });
-            
-            Assert.AreEqual("dabcddbd", contents);
+
+            Assert.That(contents, Is.EqualTo("dabcddbd"));
         }
 
         [Test]
@@ -447,10 +450,10 @@ public void RenderPartial()
                 new SendLiteralChunk { Text = ")" });
 
             _compiler.CompileView(chunks, new[] { chunks[0], partial[0] });
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("(Hello world)", contents);
+
+            Assert.That(contents, Is.EqualTo("(Hello world)"));
         }
 
         [Test]
@@ -471,10 +474,10 @@ public void RenderPartialWithContainedContent()
             renderPartial.Body.Add(new SendLiteralChunk { Text = "From inside caller" });
 
             _compiler.CompileView(chunks, new[] { chunks[0], partial[0] });
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("([From inside caller])", contents);
+
+            Assert.That(contents, Is.EqualTo("([From inside caller])"));
         }
 
         [Test]
@@ -498,10 +501,10 @@ public void RenderPartialWithSectionContent()
                 new SendLiteralChunk { Text = ")" });
 
             _compiler.CompileView(chunks, new[] { chunks[0], partial[0] });
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("([From inside caller])", contents);
+
+            Assert.That(contents, Is.EqualTo("([From inside caller])"));
         }
 
         [Test]
@@ -518,10 +521,10 @@ public void CaptureContentToVariable()
                 new SendExpressionChunk { Code = "foo" });
 
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("bac", contents);
+
+            Assert.That(contents, Is.EqualTo("bac"));
         }
 
 
@@ -535,10 +538,10 @@ public void CaptureContentToNamedSpool()
                 new SendLiteralChunk { Text = "c" });
 
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("abc", contents);
+
+            Assert.That(contents, Is.EqualTo("abc"));
         }
 
         [Test]
@@ -555,10 +558,10 @@ public void DefaultVariablesWorking()
                 new SendExpressionChunk { Code = "x3" });
 
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("abe", contents);
+
+            Assert.That(contents, Is.EqualTo("abe"));
         }
 
         [Test]
@@ -585,10 +588,10 @@ public void OnceTestSendsThingsOnce()
                 });
 
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("42", contents);
+
+            Assert.That(contents, Is.EqualTo("42"));
         }
 
         [Test]
@@ -603,10 +606,10 @@ public void HandleNullReferences()
                 new SendLiteralChunk { Text = "3" });
 
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("1${user.Name => undefined method `Name' for nil:NilClass}23", contents);
+
+            Assert.That(contents, Is.EqualTo("1${user.Name => undefined method `Name' for nil:NilClass}23"));
         }
 
         [Test]
@@ -622,13 +625,13 @@ public void ForLoopAutovariables()
                 new ForEachChunk { Code = "foo in @stuff", Body = loop[0] });
 
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView(new StubViewData
                                        {
                                            {"stuff", new[] {6, 2, 7, 4}}
                                        });
-            
-            Assert.AreEqual("04TrueFalse14FalseFalse24FalseFalse34FalseTrue", contents);
+
+            Assert.That(contents, Is.EqualTo("04TrueFalse14FalseFalse24FalseFalse34FalseTrue"));
         }
 
         [Test]
@@ -645,10 +648,10 @@ public void CallingMacro()
                 new SendLiteralChunk { Text = "3" });
 
             _compiler.CompileView(chunks, chunks);
-            
+
             var contents = ExecuteView();
-            
-            Assert.AreEqual("213", contents);
+
+            Assert.That(contents, Is.EqualTo("213"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Ruby.Tests/Spark.Ruby.Tests.csproj b/src/Spark.Ruby.Tests/Spark.Ruby.Tests.csproj
index 7199cc3b..7a4f78a3 100644
--- a/src/Spark.Ruby.Tests/Spark.Ruby.Tests.csproj
+++ b/src/Spark.Ruby.Tests/Spark.Ruby.Tests.csproj
@@ -24,9 +24,13 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-	<PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="NUnit" Version="4.2.2" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+	<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Spark.Ruby\Spark.Ruby.csproj" />
diff --git a/src/Spark.Tests/Bindings/BindingExpansionVisitorTester.cs b/src/Spark.Tests/Bindings/BindingExpansionVisitorTester.cs
index 561fe34c..d8bb03af 100644
--- a/src/Spark.Tests/Bindings/BindingExpansionVisitorTester.cs
+++ b/src/Spark.Tests/Bindings/BindingExpansionVisitorTester.cs
@@ -28,7 +28,7 @@ public void CallVisitorToProcessNodes()
         {
             var nodes = new Node[] { new ElementNode("hello", Array.Empty<AttributeNode>(), true) };
             _visitor.Accept(nodes);
-            Assert.That(_visitor.Nodes.Count, Is.EqualTo(1));
+            Assert.That(_visitor.Nodes, Has.Count.EqualTo(1));
             Assert.That(_visitor.Nodes[0], Is.SameAs(nodes[0]));
         }
 
@@ -54,7 +54,7 @@ public void MatchingElementReplacedWithExpression()
 
             var nodes = CreateElement("hello");
             _visitor.Accept(nodes);
-            Assert.That(_visitor.Nodes.Count, Is.EqualTo(1));
+            Assert.That(_visitor.Nodes, Has.Count.EqualTo(1));
             Assert.That(_visitor.Nodes[0], Is.Not.SameAs(nodes[0]));
             Assert.That(_visitor.Nodes[0], Is.TypeOf(typeof(ExpressionNode)));
             var expression = (ExpressionNode)_visitor.Nodes[0];
@@ -68,7 +68,7 @@ public void ReplacementTakesAttributesByNameAndTextBecomesStringLiteral()
 
             var nodes = CreateElement("hello", CreateAttribute("foo", new TextNode("bar")));
             _visitor.Accept(nodes);
-            Assert.That(_visitor.Nodes.Count, Is.EqualTo(1));
+            Assert.That(_visitor.Nodes, Has.Count.EqualTo(1));
             Assert.That(_visitor.Nodes[0], Is.Not.SameAs(nodes[0]));
             Assert.That(_visitor.Nodes[0], Is.TypeOf(typeof(ExpressionNode)));
             var expression = (ExpressionNode)_visitor.Nodes[0];
@@ -83,7 +83,7 @@ public void ExpressionsInAttributeBecomeCode()
 
             var nodes = CreateElement("hello", CreateAttribute("foo", new ExpressionNode("bar")));
             _visitor.Accept(nodes);
-            Assert.That(_visitor.Nodes.Count, Is.EqualTo(1));
+            Assert.That(_visitor.Nodes, Has.Count.EqualTo(1));
             Assert.That(_visitor.Nodes[0], Is.Not.SameAs(nodes[0]));
             Assert.That(_visitor.Nodes[0], Is.TypeOf(typeof(ExpressionNode)));
             var expression = (ExpressionNode)_visitor.Nodes[0];
diff --git a/src/Spark.Tests/Bindings/BindingGrammarTester.cs b/src/Spark.Tests/Bindings/BindingGrammarTester.cs
index daa462db..9a3de539 100644
--- a/src/Spark.Tests/Bindings/BindingGrammarTester.cs
+++ b/src/Spark.Tests/Bindings/BindingGrammarTester.cs
@@ -33,8 +33,11 @@ public void AttrsRecognizedStartingWithAtAndEndAfterName()
             var result1 = grammar.NameReference(Source("@caption"));
             var result2 = grammar.NameReference(Source(" @caption"));
 
-            Assert.That(result1.Value, Is.InstanceOf(typeof(BindingNameReference)));
-            Assert.That(result2, Is.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result1.Value, Is.InstanceOf(typeof(BindingNameReference)));
+                Assert.That(result2, Is.Null);
+            });
 
             var value1 = (BindingNameReference)result1.Value;
             Assert.That(value1.Name, Is.EqualTo("caption"));
@@ -64,13 +67,16 @@ public void MixedResultsComeBackAtTheRightPlaces()
             var grammar = new BindingGrammar();
             var result = grammar.Nodes(Source("Html.ActionLink(@caption, @action)"));
 
-            Assert.That(result.Value.Count(), Is.EqualTo(5));
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Count(), Is.EqualTo(5));
 
-            Assert.That(((BindingLiteral)result.Value[0]).Text, Is.EqualTo("Html.ActionLink("));
-            Assert.That(((BindingNameReference)result.Value[1]).Name, Is.EqualTo("caption"));
-            Assert.That(((BindingLiteral)result.Value[2]).Text, Is.EqualTo(", "));
-            Assert.That(((BindingNameReference)result.Value[3]).Name, Is.EqualTo("action"));
-            Assert.That(((BindingLiteral)result.Value[4]).Text, Is.EqualTo(")"));
+                Assert.That(((BindingLiteral)result.Value[0]).Text, Is.EqualTo("Html.ActionLink("));
+                Assert.That(((BindingNameReference)result.Value[1]).Name, Is.EqualTo("caption"));
+                Assert.That(((BindingLiteral)result.Value[2]).Text, Is.EqualTo(", "));
+                Assert.That(((BindingNameReference)result.Value[3]).Name, Is.EqualTo("action"));
+                Assert.That(((BindingLiteral)result.Value[4]).Text, Is.EqualTo(")"));
+            });
         }
 
         [Test]
@@ -80,13 +86,19 @@ public void PrefixRequiresTrailingAsterisk()
 
             var result1 = grammar.PrefixReference(Source("@caption.*x"));
             var value1 = (BindingPrefixReference)result1.Value;
-            Assert.That(value1.Prefix, Is.EqualTo("caption."));
-            Assert.That(result1.Rest.Peek(), Is.EqualTo('x'));
+            Assert.Multiple(() =>
+            {
+                Assert.That(value1.Prefix, Is.EqualTo("caption."));
+                Assert.That(result1.Rest.Peek(), Is.EqualTo('x'));
+            });
 
             var result2 = grammar.PrefixReference(Source("@*y"));
             var value2 = (BindingPrefixReference)result2.Value;
-            Assert.That(value2.Prefix ?? "", Is.EqualTo(""));
-            Assert.That(result2.Rest.Peek(), Is.EqualTo('y'));
+            Assert.Multiple(() =>
+            {
+                Assert.That(value2.Prefix ?? "", Is.EqualTo(""));
+                Assert.That(result2.Rest.Peek(), Is.EqualTo('y'));
+            });
         }
 
         [Test]
@@ -95,13 +107,16 @@ public void PrefixLetsYouWildcardAsTheLastCharacter()
             var grammar = new BindingGrammar();
             var result = grammar.Nodes(Source("Html.ActionLink(@caption.**, @**)"));
 
-            Assert.That(result.Value.Count(), Is.EqualTo(5));
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Count(), Is.EqualTo(5));
 
-            Assert.That(((BindingLiteral)result.Value[0]).Text, Is.EqualTo("Html.ActionLink("));
-            Assert.That(((BindingPrefixReference)result.Value[1]).Prefix, Is.EqualTo("caption."));
-            Assert.That(((BindingLiteral)result.Value[2]).Text, Is.EqualTo("*, "));
-            Assert.That(((BindingPrefixReference)result.Value[3]).Prefix ?? "", Is.EqualTo(""));
-            Assert.That(((BindingLiteral)result.Value[4]).Text, Is.EqualTo("*)"));
+                Assert.That(((BindingLiteral)result.Value[0]).Text, Is.EqualTo("Html.ActionLink("));
+                Assert.That(((BindingPrefixReference)result.Value[1]).Prefix, Is.EqualTo("caption."));
+                Assert.That(((BindingLiteral)result.Value[2]).Text, Is.EqualTo("*, "));
+                Assert.That(((BindingPrefixReference)result.Value[3]).Prefix ?? "", Is.EqualTo(""));
+                Assert.That(((BindingLiteral)result.Value[4]).Text, Is.EqualTo("*)"));
+            });
         }
 
         [Test]
@@ -117,12 +132,15 @@ public void OptionalQuotesMarkAssumeStringValueAsTrue()
             var five = (BindingPrefixReference)result.Value[4];
             var six = (BindingPrefixReference)result.Value[5];
 
-            Assert.That(one.AssumeStringValue, Is.False);
-            Assert.That(two.AssumeStringValue, Is.True);
-            Assert.That(three.AssumeStringValue, Is.True);
-            Assert.That(four.AssumeStringValue, Is.False);
-            Assert.That(five.AssumeStringValue, Is.True);
-            Assert.That(six.AssumeStringValue, Is.True);
+            Assert.Multiple(() =>
+            {
+                Assert.That(one.AssumeStringValue, Is.False);
+                Assert.That(two.AssumeStringValue, Is.True);
+                Assert.That(three.AssumeStringValue, Is.True);
+                Assert.That(four.AssumeStringValue, Is.False);
+                Assert.That(five.AssumeStringValue, Is.True);
+                Assert.That(six.AssumeStringValue, Is.True);
+            });
         }
 
         [Test]
@@ -139,13 +157,16 @@ public void ChildContentCanAppearWithOrWithoutQuotes()
             var child3 = (BindingChildReference)result.Value[5];
             var d = (BindingLiteral)result.Value[6];
 
-            Assert.That(a.Text, Is.EqualTo("a"));
-            Assert.That(b.Text, Is.EqualTo("b"));
-            Assert.That(c.Text, Is.EqualTo("c"));
-            Assert.That(d.Text, Is.EqualTo("d"));
-            Assert.That(child1, Is.Not.Null);
-            Assert.That(child2, Is.Not.Null);
-            Assert.That(child3, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Text, Is.EqualTo("a"));
+                Assert.That(b.Text, Is.EqualTo("b"));
+                Assert.That(c.Text, Is.EqualTo("c"));
+                Assert.That(d.Text, Is.EqualTo("d"));
+                Assert.That(child1, Is.Not.Null);
+                Assert.That(child2, Is.Not.Null);
+                Assert.That(child3, Is.Not.Null);
+            });
         }
 
         [Test]
@@ -160,14 +181,17 @@ public void CurleyBracesAroundWildcardIndicateDictionaryInitializingSyntax()
             var match2 = (BindingPrefixReference)result.Value[2];
             var b = (BindingLiteral)result.Value[3];
 
-            Assert.That(a.Text, Is.EqualTo("a"));
-            Assert.That(b.Text, Is.EqualTo("b"));
-            Assert.That(match1.Prefix, Is.Null);
-            Assert.That(match2.Prefix, Is.EqualTo("hello"));
-            Assert.That(match1.AssumeDictionarySyntax, Is.True);
-            Assert.That(match2.AssumeDictionarySyntax, Is.True);
-            Assert.That(match1.AssumeStringValue, Is.False);
-            Assert.That(match2.AssumeStringValue, Is.False);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Text, Is.EqualTo("a"));
+                Assert.That(b.Text, Is.EqualTo("b"));
+                Assert.That(match1.Prefix, Is.Null);
+                Assert.That(match2.Prefix, Is.EqualTo("hello"));
+                Assert.That(match1.AssumeDictionarySyntax, Is.True);
+                Assert.That(match2.AssumeDictionarySyntax, Is.True);
+                Assert.That(match1.AssumeStringValue, Is.False);
+                Assert.That(match2.AssumeStringValue, Is.False);
+            });
         }
 
         [Test]
@@ -182,12 +206,15 @@ public void BothBracesMustBePresentToMatch()
             var match2 = (BindingPrefixReference)result.Value[2];
             var b = (BindingLiteral)result.Value[3];
 
-            Assert.That(a.Text, Is.EqualTo("a{{"));
-            Assert.That(b.Text, Is.EqualTo("}}b"));
-            Assert.That(match1.Prefix, Is.Null);
-            Assert.That(match2.Prefix, Is.EqualTo("hello"));
-            Assert.That(match1.AssumeDictionarySyntax, Is.False);
-            Assert.That(match2.AssumeDictionarySyntax, Is.False);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Text, Is.EqualTo("a{{"));
+                Assert.That(b.Text, Is.EqualTo("}}b"));
+                Assert.That(match1.Prefix, Is.Null);
+                Assert.That(match2.Prefix, Is.EqualTo("hello"));
+                Assert.That(match1.AssumeDictionarySyntax, Is.False);
+                Assert.That(match2.AssumeDictionarySyntax, Is.False);
+            });
         }
 
         [Test]
@@ -202,18 +229,22 @@ public void BracesMayAppearAroundStrings()
             var match2 = (BindingPrefixReference)result.Value[2];
             var b = (BindingLiteral)result.Value[3];
 
-            Assert.That(a.Text, Is.EqualTo("a"));
-            Assert.That(b.Text, Is.EqualTo("b"));
-            Assert.That(match1.Prefix, Is.Null);
-            Assert.That(match2.Prefix, Is.EqualTo("hello"));
-            Assert.That(match1.AssumeDictionarySyntax, Is.True);
-            Assert.That(match2.AssumeDictionarySyntax, Is.True);
-            Assert.That(match1.AssumeStringValue, Is.True);
-            Assert.That(match2.AssumeStringValue, Is.True);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Text, Is.EqualTo("a"));
+                Assert.That(b.Text, Is.EqualTo("b"));
+                Assert.That(match1.Prefix, Is.Null);
+                Assert.That(match2.Prefix, Is.EqualTo("hello"));
+                Assert.That(match1.AssumeDictionarySyntax, Is.True);
+                Assert.That(match2.AssumeDictionarySyntax, Is.True);
+                Assert.That(match1.AssumeStringValue, Is.True);
+                Assert.That(match2.AssumeStringValue, Is.True);
+            });
         }
 
         [Test]
-        public void DoubleSquareBracketIsAliasForAngleBracket() {
+        public void DoubleSquareBracketIsAliasForAngleBracket()
+        {
             var grammar = new BindingGrammar();
             var result = grammar.Nodes(Source("this[[that]]"));
 
diff --git a/src/Spark.Tests/Bindings/ViewFolderBindingProviderTester.cs b/src/Spark.Tests/Bindings/ViewFolderBindingProviderTester.cs
index a2d64645..df970ecc 100644
--- a/src/Spark.Tests/Bindings/ViewFolderBindingProviderTester.cs
+++ b/src/Spark.Tests/Bindings/ViewFolderBindingProviderTester.cs
@@ -22,11 +22,14 @@ public void BindingTableCanLoadFromViewFolder()
             var provider = new DefaultBindingProvider();
             var bindings = provider.GetBindings(new BindingRequest(viewFolder)).ToList();
 
-            Assert.That(bindings.Count, Is.EqualTo(1));
-            Assert.That(bindings[0].ElementName, Is.EqualTo("foo"));
-            Assert.That(bindings[0].Phrases.Single().Nodes.Count, Is.EqualTo(1));
-            Assert.That(((BindingLiteral)bindings[0].Phrases.Single().Nodes[0]).Text, Is.EqualTo("bar"));
-            Assert.That(bindings[0].Phrases.All(phrase => phrase.Type == BindingPhrase.PhraseType.Expression));
+            Assert.That(bindings, Has.Count.EqualTo(1));
+            Assert.Multiple(() =>
+            {
+                Assert.That(bindings[0].ElementName, Is.EqualTo("foo"));
+                Assert.That(bindings[0].Phrases.Single().Nodes, Has.Count.EqualTo(1));
+                Assert.That(((BindingLiteral)bindings[0].Phrases.Single().Nodes[0]).Text, Is.EqualTo("bar"));
+                Assert.That(bindings[0].Phrases.All(phrase => phrase.Type == BindingPhrase.PhraseType.Expression));
+            });
         }
 
 
@@ -47,14 +50,17 @@ public void TwoPartBindingsAreRecognized()
             var provider = new DefaultBindingProvider();
             var bindings = provider.GetBindings(new BindingRequest(viewFolder)).ToList();
 
-            Assert.That(bindings.Count, Is.EqualTo(1));
-            Assert.That(bindings[0].ElementName, Is.EqualTo("foo"));
-            Assert.That(bindings[0].Phrases.Count(), Is.EqualTo(2));
-            Assert.That(bindings[0].Phrases.First().Nodes.Count, Is.EqualTo(1));
-            Assert.That(bindings[0].Phrases.Last().Nodes.Count, Is.EqualTo(1));
-            Assert.That(((BindingLiteral)bindings[0].Phrases.First().Nodes[0]).Text, Is.EqualTo("bar"));
-            Assert.That(((BindingLiteral)bindings[0].Phrases.Last().Nodes[0]).Text, Is.EqualTo("quux"));
-            Assert.That(bindings[0].Phrases.All(phrase => phrase.Type == BindingPhrase.PhraseType.Expression));
+            Assert.That(bindings, Has.Count.EqualTo(1));
+            Assert.Multiple(() =>
+            {
+                Assert.That(bindings[0].ElementName, Is.EqualTo("foo"));
+                Assert.That(bindings[0].Phrases.Count(), Is.EqualTo(2));
+                Assert.That(bindings[0].Phrases.First().Nodes, Has.Count.EqualTo(1));
+                Assert.That(bindings[0].Phrases.Last().Nodes, Has.Count.EqualTo(1));
+                Assert.That(((BindingLiteral)bindings[0].Phrases.First().Nodes[0]).Text, Is.EqualTo("bar"));
+                Assert.That(((BindingLiteral)bindings[0].Phrases.Last().Nodes[0]).Text, Is.EqualTo("quux"));
+                Assert.That(bindings[0].Phrases.All(phrase => phrase.Type == BindingPhrase.PhraseType.Expression));
+            });
         }
 
         [Test]
diff --git a/src/Spark.Tests/CompiledViewHolderTester.cs b/src/Spark.Tests/CompiledViewHolderTester.cs
index 4361dac6..19bf82e8 100644
--- a/src/Spark.Tests/CompiledViewHolderTester.cs
+++ b/src/Spark.Tests/CompiledViewHolderTester.cs
@@ -37,9 +37,9 @@ public void Init()
         private SparkViewDescriptor BuildKey(params string[] templates)
         {
             return new SparkViewDescriptor
-                   {
-                       Templates = templates
-                   };
+            {
+                Templates = templates
+            };
         }
 
         [Test]
@@ -47,7 +47,7 @@ public void LookupNonExistentReturnsNull()
         {
             var key = BuildKey(Path.Combine("c", "v"), Path.Combine("shared", "m"));
             var entry = holder.Lookup(key);
-            Assert.IsNull(entry);
+            Assert.That(entry, Is.Null);
         }
 
         [Test]
@@ -69,9 +69,10 @@ public void LookupReturnsStoredInstance()
                 null);
 
             var entry = new CompiledViewEntry { Descriptor = key, Loader = viewLoader };
-            Assert.IsNull(holder.Lookup(key));
+            Assert.That(holder.Lookup(key), Is.Null);
             holder.Store(entry);
-            Assert.AreSame(entry, holder.Lookup(key));
+
+            Assert.That(holder.Lookup(key), Is.SameAs(entry));
         }
 
         [Test]
@@ -80,18 +81,20 @@ public void VariousKeyEqualities()
             var key1 = BuildKey(Path.Combine("c", "v"), Path.Combine("shared", "m"));
             var key2 = BuildKey(Path.Combine("c", "v"), Path.Combine("shared", "m"));
 
-            Assert.AreNotSame(key1, key2);
-            Assert.AreEqual(key1, key2);
+            Assert.That(key2, Is.Not.SameAs(key1));
+            Assert.That(key2, Is.EqualTo(key1));
 
             var key3 = BuildKey(Path.Combine("c", "v"));
-            Assert.AreNotEqual(key1, key3);
-            Assert.AreNotEqual(key2, key3);
+            Assert.That(key3, Is.Not.EqualTo(key1));
+            Assert.That(key3, Is.Not.EqualTo(key2));
 
             var key4 = BuildKey(Path.Combine("c", "v"), Path.Combine("shared", "M"));
-            Assert.AreEqual(key1, key4);
+            Assert.Multiple(() =>
+            {
+                Assert.That(key4, Is.EqualTo(key1));
 
-            Assert.That(!Equals(key1, null));
-            Assert.That(!Equals(null, key1));
+                Assert.That(key1, Is.Not.Null);
+            });
         }
 
         public class FakeViewLoader : ViewLoader
@@ -126,11 +129,11 @@ public void ExpiredEntryReturnsNull()
 
             holder.Store(entry);
 
-            Assert.AreSame(entry, holder.Lookup(key));
+            Assert.That(holder.Lookup(key), Is.SameAs(entry));
 
             loader.IsCurrentValue = false;
 
-            Assert.IsNull(holder.Lookup(key));
+            Assert.That(holder.Lookup(key), Is.Null);
         }
 
         [Test]
diff --git a/src/Spark.Tests/Compiler/ExpressionBuilderTester.cs b/src/Spark.Tests/Compiler/ExpressionBuilderTester.cs
index 4ff3b724..b6573bc9 100644
--- a/src/Spark.Tests/Compiler/ExpressionBuilderTester.cs
+++ b/src/Spark.Tests/Compiler/ExpressionBuilderTester.cs
@@ -30,15 +30,15 @@ public void AddSeveralLiterals()
             var builder = new ExpressionBuilder();
             builder.AppendLiteral("hello");
             builder.AppendLiteral("world");
-            Assert.AreEqual("\"helloworld\"", builder.ToCode());
+            Assert.That(builder.ToCode(), Is.EqualTo("\"helloworld\""));
         }
 
         [Test]
         public void TextIsEscaped()
         {
             var builder = new ExpressionBuilder();
-            builder.AppendLiteral("\"\\\t");            
-            Assert.AreEqual("\"\\\"\\\\\\t\"", builder.ToCode());
+            builder.AppendLiteral("\"\\\t");
+            Assert.That(builder.ToCode(), Is.EqualTo("\"\\\"\\\\\\t\""));
         }
 
         [Test]
@@ -48,7 +48,7 @@ public void CodeEndsUpConcatinated()
             builder.AppendExpression("x");
             builder.AppendExpression("y");
             builder.AppendExpression("z");
-            Assert.AreEqual("string.Concat(x,y,z)", builder.ToCode());
+            Assert.That(builder.ToCode(), Is.EqualTo("string.Concat(x,y,z)"));
         }
     }
 }
diff --git a/src/Spark.Tests/Compiler/ForEachInspectorTester.cs b/src/Spark.Tests/Compiler/ForEachInspectorTester.cs
index 7ab2f0ed..3f6086b8 100644
--- a/src/Spark.Tests/Compiler/ForEachInspectorTester.cs
+++ b/src/Spark.Tests/Compiler/ForEachInspectorTester.cs
@@ -28,9 +28,12 @@ public class ForEachInspectorTester
         public void LocatingTheVariable()
         {
             var inspector = new ForEachInspector("my var thing in collection.thing foo");
-            Assert.AreEqual("my var", inspector.VariableType); 
-            Assert.AreEqual("thing", inspector.VariableName);
-            Assert.AreEqual("collection.thing foo", inspector.CollectionCode);
+            Assert.Multiple(() =>
+            {
+                Assert.That(inspector.VariableType, Is.EqualTo("my var"));
+                Assert.That(inspector.VariableName, Is.EqualTo("thing"));
+                Assert.That(inspector.CollectionCode, Is.EqualTo("collection.thing foo"));
+            });
         }
     }
 }
diff --git a/src/Spark.Tests/Compiler/SourceWriterTester.cs b/src/Spark.Tests/Compiler/SourceWriterTester.cs
index 4c725d1a..33235ec3 100644
--- a/src/Spark.Tests/Compiler/SourceWriterTester.cs
+++ b/src/Spark.Tests/Compiler/SourceWriterTester.cs
@@ -11,7 +11,7 @@ namespace Spark.Tests.Compiler
 {
     [TestFixture]
     public class SourceWriterTester
-    {		
+    {
         [Test]
         public void IndentationShouldAddLeadingSpace()
         {
@@ -25,16 +25,16 @@ public void IndentationShouldAddLeadingSpace()
                 .WriteLine("two")
                 .RemoveIndent()
                 .WriteLine("three");
-			
-			var expected = new StringBuilder()
-				.AppendLine()
-				.AppendLine("one")
-				.AppendLine("    two")
-				.AppendLine("three");
-									
-			Assert.That(source.ToString(), Is.EqualTo(expected.ToString()));
-        }		
-		
+
+            var expected = new StringBuilder()
+                .AppendLine()
+                .AppendLine("one")
+                .AppendLine("    two")
+                .AppendLine("three");
+
+            Assert.That(source.ToString(), Is.EqualTo(expected.ToString()));
+        }
+
         [Test]
         public void EscrowLineWritesFirstAtIndentationWhenItWasAdded()
         {
@@ -50,18 +50,18 @@ public void EscrowLineWritesFirstAtIndentationWhenItWasAdded()
                 .RemoveIndent()
                 .WriteLine("three")
                 .RemoveIndent();
-			
-			var expected = new StringBuilder()
-				.AppendLine()
-				.AppendLine("    one")
-				.AppendLine("        two")
-				.AppendLine("        two-b")
-				.AppendLine("    three");
-						
+
+            var expected = new StringBuilder()
+                .AppendLine()
+                .AppendLine("    one")
+                .AppendLine("        two")
+                .AppendLine("        two-b")
+                .AppendLine("    three");
+
             Assert.That(source.ToString(), Is.EqualTo(expected.ToString()));
-        }		
-		
-		[Test]
+        }
+
+        [Test]
         public void CancelEscrowPreventsOutputOfPendingLine()
         {
             var writer = new StringWriter();
@@ -84,18 +84,18 @@ public void CancelEscrowPreventsOutputOfPendingLine()
                 .EscrowLine("endif")
                 .RemoveIndent()
                 .WriteLine("done");
-			
-			var expected = new StringBuilder()
-				.AppendLine()
-				.AppendLine("begin")
-				.AppendLine("    if")
-				.AppendLine("        do this")
-				.AppendLine("    else")
-				.AppendLine("        do that")
-				.AppendLine("    endif")
-				.AppendLine("done");
-			
+
+            var expected = new StringBuilder()
+                .AppendLine()
+                .AppendLine("begin")
+                .AppendLine("    if")
+                .AppendLine("        do this")
+                .AppendLine("    else")
+                .AppendLine("        do that")
+                .AppendLine("    endif")
+                .AppendLine("done");
+
             Assert.That(source.ToString(), Is.EqualTo(expected.ToString()));
-        }				
+        }
     }
 }
diff --git a/src/Spark.Tests/Constraints.cs b/src/Spark.Tests/Constraints.cs
index 6cc96ada..b7bfbdf9 100644
--- a/src/Spark.Tests/Constraints.cs
+++ b/src/Spark.Tests/Constraints.cs
@@ -85,7 +85,7 @@ public override ConstraintResult ApplyTo<TActual>(TActual actual)
 
                     index = nextIndex + value.Length;
                 }
-                
+
                 return new ConstraintResult(this, index, true);
             }
 
diff --git a/src/Spark.Tests/InMemoryServiceTest.cs b/src/Spark.Tests/InMemoryServiceTest.cs
index 8599b4dd..20eb102e 100644
--- a/src/Spark.Tests/InMemoryServiceTest.cs
+++ b/src/Spark.Tests/InMemoryServiceTest.cs
@@ -19,7 +19,7 @@ public void TestStoreValueThenRetrieveIt()
 
             var retrieved = service.Get("identifier");
 
-            Assert.AreSame(item, retrieved);
+            Assert.That(retrieved, Is.SameAs(item));
         }
 
         [Test]
@@ -35,7 +35,7 @@ public void TestStoreValueThenRetrieveItAfterAbsoluteExpiration()
 
             var retrieved = service.Get("identifier");
 
-            Assert.IsNull(retrieved);
+            Assert.That(retrieved, Is.Null);
         }
 
         [Test]
@@ -53,14 +53,14 @@ public void TestStoreValueThenRetrieveItWhenExpirationSlides()
             {
                 Thread.Sleep(50);
 
-                retrieved = service.Get("identifier");
+                _ = service.Get("identifier");
             }
 
             retrieved = service.Get("identifier");
 
-            Assert.IsNotNull(retrieved);
+            Assert.That(retrieved, Is.Not.Null);
 
-            Assert.AreSame(item, retrieved);
+            Assert.That(retrieved, Is.SameAs(item));
         }
 
         [Test]
@@ -76,13 +76,13 @@ public void TestStoreValueWithSignal()
 
             var retrieved = service.Get("identifier");
 
-            Assert.AreSame(item, retrieved);
+            Assert.That(retrieved, Is.SameAs(item));
 
             signal.FireChanged();
 
             retrieved = service.Get("identifier");
 
-            Assert.IsNull(retrieved);
+            Assert.That(retrieved, Is.Null);
         }
     }
 }
diff --git a/src/Spark.Tests/Models/Comment.cs b/src/Spark.Tests/Models/Comment.cs
index d1ffcf32..88b7f11d 100644
--- a/src/Spark.Tests/Models/Comment.cs
+++ b/src/Spark.Tests/Models/Comment.cs
@@ -19,8 +19,8 @@
 
 namespace Spark.Tests.Models
 {
-	public class Comment
-	{
-		public string Text { get; set; }
-	}
+    public class Comment
+    {
+        public string Text { get; set; }
+    }
 }
\ No newline at end of file
diff --git a/src/Spark.Tests/Parser/CharGrammarTester.cs b/src/Spark.Tests/Parser/CharGrammarTester.cs
index 7f999030..766375e3 100644
--- a/src/Spark.Tests/Parser/CharGrammarTester.cs
+++ b/src/Spark.Tests/Parser/CharGrammarTester.cs
@@ -60,7 +60,7 @@ static string Combine(IEnumerable<char> value)
         public void AllText()
         {
             var result = _grammar.AllText(Source("hello world"));
-            Assert.That(Combine(result.Value), Is.EqualTo("hello world") );
+            Assert.That(Combine(result.Value), Is.EqualTo("hello world"));
         }
 
         [Test]
diff --git a/src/Spark.Tests/Parser/CodeGrammarTester.cs b/src/Spark.Tests/Parser/CodeGrammarTester.cs
index 825e709c..82fe6332 100644
--- a/src/Spark.Tests/Parser/CodeGrammarTester.cs
+++ b/src/Spark.Tests/Parser/CodeGrammarTester.cs
@@ -45,7 +45,7 @@ static string Combine(IList<Snippet> snippets)
         public void SimpleStatement()
         {
             var result = _grammar.Expression(Source("hello world"));
-            Assert.AreEqual("hello world", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("hello world"));
         }
 
 
@@ -53,46 +53,46 @@ public void SimpleStatement()
         public void StringConstants()
         {
             var result = _grammar.Expression(Source("double\"quote\"strings"));
-            Assert.AreEqual("double\"quote\"strings", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("double\"quote\"strings"));
 
             var result2 = _grammar.Expression(Source("single\'quote\'strings"));
-            Assert.AreEqual("single\"quote\"strings", Combine(result2.Value));
+            Assert.That(Combine(result2.Value), Is.EqualTo("single\"quote\"strings"));
         }
 
         [Test]
         public void EnclosedEscapes()
         {
             var result = _grammar.Expression(Source("double\"quote-'-\\\'-\\\"-\"strings"));
-            Assert.AreEqual("double\"quote-'-\\\'-\\\"-\"strings", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("double\"quote-'-\\\'-\\\"-\"strings"));
 
             var result2 = _grammar.Expression(Source("single\'quote-\"-\\\'-\\\"-\'strings"));
-            Assert.AreEqual("single\"quote-\\\"-\\\'-\\\"-\"strings", Combine(result2.Value));
+            Assert.That(Combine(result2.Value), Is.EqualTo("single\"quote-\\\"-\\\'-\\\"-\"strings"));
         }
 
         [Test]
         public void BraceMatching()
         {
             var result = _grammar.Expression(Source("Html.Link(new {x='ten', y=20}) a}b "));
-            Assert.AreEqual("Html.Link(new {x=\"ten\", y=20}) a", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("Html.Link(new {x=\"ten\", y=20}) a"));
         }
 
         [Test]
         public void StopAtExpressionTerminators()
         {
             var result = _grammar.Expression(Source("ab{cde{fgh}ijk}lm\"n}o\"p'}}%>'qrs}tuv"));
-            Assert.AreEqual("ab{cde{fgh}ijk}lm\"n}o\"p\"}}%>\"qrs", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("ab{cde{fgh}ijk}lm\"n}o\"p\"}}%>\"qrs"));
 
             var result2 = _grammar.Expression(Source("ab{cde{fgh}ijk}lm\"n}o\"p'}}%>'qrs%>tuv"));
-            Assert.AreEqual("ab{cde{fgh}ijk}lm\"n}o\"p\"}}%>\"qrs", Combine(result2.Value));
-            
+            Assert.That(Combine(result2.Value), Is.EqualTo("ab{cde{fgh}ijk}lm\"n}o\"p\"}}%>\"qrs"));
+
         }
 
         [Test]
         public void SpecialCastAllowsCharConstant()
         {
             var result = _grammar.Expression(Source("..(char)'u'..'u'.."));
-            Assert.AreEqual("..(char)'u'..\"u\"..", Combine(result.Value));
-            
+            Assert.That(Combine(result.Value), Is.EqualTo("..(char)'u'..\"u\".."));
+
         }
 
 
@@ -100,7 +100,7 @@ public void SpecialCastAllowsCharConstant()
         public void ChangeDoubleBraceAliases()
         {
             var result = _grammar.Expression(Source("one < two > three [[ four '[[fi\"ve]]' ]] six \"[[']]\" seven"));
-            Assert.AreEqual("one < two > three < four \"[[fi\\\"ve]]\" > six \"[[']]\" seven", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("one < two > three < four \"[[fi\\\"ve]]\" > six \"[[']]\" seven"));
 
         }
 
@@ -108,14 +108,14 @@ public void ChangeDoubleBraceAliases()
         public void Statement1StopsWithEndOfLine()
         {
             var result = _grammar.Statement1(Source("before%>and\r\nafter"));
-            Assert.AreEqual("before%>and", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("before%>and"));
         }
 
         [Test]
         public void Statement2StopsWithPercentAngle()
         {
             var result = _grammar.Statement2(Source("before\r\nand%>after"));
-            Assert.AreEqual("before\r\nand", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("before\r\nand"));
         }
 
 
@@ -123,32 +123,32 @@ public void Statement2StopsWithPercentAngle()
         public void StringsMayHavePercentAngle()
         {
             var result = _grammar.Statement1(Source("before\"%>\"and'%>'after\r\nagain"));
-            Assert.AreEqual("before\"%>\"and\"%>\"after", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("before\"%>\"and\"%>\"after"));
             var result2 = _grammar.Statement2(Source("before\"%>\"and'%>'after%>again"));
-            Assert.AreEqual("before\"%>\"and\"%>\"after", Combine(result2.Value));
+            Assert.That(Combine(result2.Value), Is.EqualTo("before\"%>\"and\"%>\"after"));
         }
 
         [Test]
         public void StatementMayContainUnmatchedBraces()
         {
             var result = _grammar.Statement1(Source("this{that"));
-            Assert.AreEqual("this{that", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("this{that"));
             var result2 = _grammar.Statement1(Source("this}that"));
-            Assert.AreEqual("this}that", Combine(result2.Value));
+            Assert.That(Combine(result2.Value), Is.EqualTo("this}that"));
             var result3 = _grammar.Statement2(Source("this{that"));
-            Assert.AreEqual("this{that", Combine(result3.Value));
+            Assert.That(Combine(result3.Value), Is.EqualTo("this{that"));
             var result4 = _grammar.Statement2(Source("this}that"));
-            Assert.AreEqual("this}that", Combine(result4.Value));
+            Assert.That(Combine(result4.Value), Is.EqualTo("this}that"));
         }
 
         [Test]
         public void VerbatimDoubleQuotes()
         {
             var result = _grammar.Expression(Source("a@\" \\\"\" \"b"));
-            Assert.AreEqual("a@\" \\\"\" \"b", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("a@\" \\\"\" \"b"));
 
             var result2 = _grammar.Expression(Source("a@\" \\\"\"} \"b"));
-            Assert.AreEqual("a@\" \\\"\"} \"b", Combine(result2.Value));
+            Assert.That(Combine(result2.Value), Is.EqualTo("a@\" \\\"\"} \"b"));
         }
 
         [Test]
@@ -156,75 +156,75 @@ public void VerbatimSingleQuotes()
         {
             //@' \'' ' becomes @" \' "
             var result = _grammar.Expression(Source("a@' \\'' 'b"));
-            Assert.AreEqual("a@\" \\' \"b", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo("a@\" \\' \"b"));
 
             //@' \''} ' becomes @" \'} "
             var result2 = _grammar.Expression(Source("a@' \\''} 'b"));
-            Assert.AreEqual("a@\" \\'} \"b", Combine(result2.Value));
+            Assert.That(Combine(result2.Value), Is.EqualTo("a@\" \\'} \"b"));
 
             //@' " '' ' becomes @" "" ' "
             var result3 = _grammar.Expression(Source("a@' \" '' 'b"));
-            Assert.AreEqual("a@\" \"\" ' \"b", Combine(result3.Value));
+            Assert.That(Combine(result3.Value), Is.EqualTo("a@\" \"\" ' \"b"));
         }
 
         [Test]
         public void CommentHasQuotes()
         {
             var result = _grammar.Statement1(Source(" // this ' has \" quotes \r\n after "));
-            Assert.AreEqual(" // this ' has \" quotes ", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo(" // this ' has \" quotes "));
 
             var result2 = _grammar.Statement1(Source(" /* this ' has \" quotes \r\n */ more \r\n after "));
-            Assert.AreEqual(" /* this ' has \" quotes \r\n */ more ", Combine(result2.Value));
+            Assert.That(Combine(result2.Value), Is.EqualTo(" /* this ' has \" quotes \r\n */ more "));
 
             var result3 = _grammar.Statement2(Source(" // this ' has \" quotes \r\n more %> after "));
-            Assert.AreEqual(" // this ' has \" quotes \r\n more ", Combine(result3.Value));
+            Assert.That(Combine(result3.Value), Is.EqualTo(" // this ' has \" quotes \r\n more "));
 
             var result4 = _grammar.Statement2(Source(" /* this ' has \" quotes \r\n */ more %> after "));
-            Assert.AreEqual(" /* this ' has \" quotes \r\n */ more ", Combine(result4.Value));
+            Assert.That(Combine(result4.Value), Is.EqualTo(" /* this ' has \" quotes \r\n */ more "));
         }
 
         [Test]
         public void ClassKeywordUsedAsIdentifier()
         {
             var result = _grammar.Expression(Source("Form.FormTag(new {action='foo', class='bar'})"));
-            Assert.AreEqual(@"Form.FormTag(new {action=""foo"", @class=""bar""})", Combine(result.Value));
+            Assert.That(Combine(result.Value), Is.EqualTo(@"Form.FormTag(new {action=""foo"", @class=""bar""})"));
 
             var result2 = _grammar.Expression(Source("Form.FormTag(new {action='foo', @class='bar'})"));
-            Assert.AreEqual(@"Form.FormTag(new {action=""foo"", @class=""bar""})", Combine(result2.Value));
+            Assert.That(Combine(result2.Value), Is.EqualTo(@"Form.FormTag(new {action=""foo"", @class=""bar""})"));
 
             var result3 = _grammar.Expression(Source("Form.FormTag(new {@action='foo', class='bar'})"));
-            Assert.AreEqual(@"Form.FormTag(new {@action=""foo"", @class=""bar""})", Combine(result3.Value));
+            Assert.That(Combine(result3.Value), Is.EqualTo(@"Form.FormTag(new {@action=""foo"", @class=""bar""})"));
 
             var result4 = _grammar.Expression(Source("var classless=1;"));
-            Assert.AreEqual(@"var classless=1;", Combine(result4.Value));
+            Assert.That(Combine(result4.Value), Is.EqualTo(@"var classless=1;"));
 
             var result5 = _grammar.Expression(Source("var yaddaclass=1;"));
-            Assert.AreEqual(@"var yaddaclass=1;", Combine(result5.Value));
+            Assert.That(Combine(result5.Value), Is.EqualTo(@"var yaddaclass=1;"));
 
             var result6 = _grammar.Expression(Source("var declassified=1;"));
-            Assert.AreEqual(@"var declassified=1;", Combine(result6.Value));
+            Assert.That(Combine(result6.Value), Is.EqualTo(@"var declassified=1;"));
 
             var result7 = _grammar.Expression(Source("var class=1;"));
-            Assert.AreEqual(@"var @class=1;", Combine(result7.Value));
+            Assert.That(Combine(result7.Value), Is.EqualTo(@"var @class=1;"));
         }
 
-        [Test]        
+        [Test]
         public void LateBoundSyntaxBecomesEvalFunction()
         {
             var result1 = _grammar.Expression(Source("#foo.bar"));
-            Assert.AreEqual(@"Eval(""foo.bar"")", (string) result1.Value);
+            Assert.That((string)result1.Value, Is.EqualTo(@"Eval(""foo.bar"")"));
 
             var result2 = _grammar.Expression(Source("#foo .bar"));
-            Assert.AreEqual(@"Eval(""foo"") .bar", (string)result2.Value);
+            Assert.That((string)result2.Value, Is.EqualTo(@"Eval(""foo"") .bar"));
 
             var result3 = _grammar.Expression(Source("(string)#foo+'bar'"));
-            Assert.AreEqual(@"(string)Eval(""foo"")+""bar""", (string)result3.Value);
+            Assert.That((string)result3.Value, Is.EqualTo(@"(string)Eval(""foo"")+""bar"""));
 
             var result4 = _grammar.Statement1(Source("Logger.Warn(#some.thing)"));
-            Assert.AreEqual(@"Logger.Warn(Eval(""some.thing""))", (string)new Snippets(result4.Value));
+            Assert.That((string)new Snippets(result4.Value), Is.EqualTo(@"Logger.Warn(Eval(""some.thing""))"));
 
             var result5 = _grammar.Statement1(Source("Logger.Warn(#some.thing)"));
-            Assert.AreEqual(@"Logger.Warn(Eval(""some.thing""))", (string)new Snippets(result5.Value));
+            Assert.That((string)new Snippets(result5.Value), Is.EqualTo(@"Logger.Warn(Eval(""some.thing""))"));
         }
 
     }
diff --git a/src/Spark.Tests/Parser/JavascriptAnonymousTypeGrammarTester.cs b/src/Spark.Tests/Parser/JavascriptAnonymousTypeGrammarTester.cs
index d79daa34..98f77986 100644
--- a/src/Spark.Tests/Parser/JavascriptAnonymousTypeGrammarTester.cs
+++ b/src/Spark.Tests/Parser/JavascriptAnonymousTypeGrammarTester.cs
@@ -28,7 +28,7 @@ static Position Source(string content)
         static string Parse(ParseAction<string> parser, string content)
         {
             var result = parser(Source(content));
-            return result != null ? result.Value : null;
+            return result?.Value;
         }
 
         [Test]
@@ -42,78 +42,102 @@ public void WsShouldMatchWhitespace()
         public void PropertyNameIsAlphaOrScoreFollowedByAlnumscore()
         {
             var p = _grammar.test_propName;
-            Assert.That(Parse(p, "hello"), Is.EqualTo("hello"));
-            Assert.That(Parse(p, "h_ello4-6"), Is.EqualTo("h_ello4"));
-            Assert.That(Parse(p, "_foo2+4"), Is.EqualTo("_foo2"));
-            Assert.That(Parse(p, "45ee-2"), Is.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, "hello"), Is.EqualTo("hello"));
+                Assert.That(Parse(p, "h_ello4-6"), Is.EqualTo("h_ello4"));
+                Assert.That(Parse(p, "_foo2+4"), Is.EqualTo("_foo2"));
+                Assert.That(Parse(p, "45ee-2"), Is.Null);
+            });
         }
 
         [Test]
         public void PropertyValueStopsAtUnprotectedCloseBraceOrComma()
         {
             var p = _grammar.test_propValue;
-            Assert.That(Parse(p, " 45 - 3;}"), Is.EqualTo(" 45 - 3;"));
-            Assert.That(Parse(p, "x'},'x}"), Is.EqualTo("x'},'x"));
-            Assert.That(Parse(p, "x\"},\"x}"), Is.EqualTo("x\"},\"x"));
-            Assert.That(Parse(p, "x'},'x,"), Is.EqualTo("x'},'x"));
-            Assert.That(Parse(p, "x\"},\"x,"), Is.EqualTo("x\"},\"x"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, " 45 - 3;}"), Is.EqualTo(" 45 - 3;"));
+                Assert.That(Parse(p, "x'},'x}"), Is.EqualTo("x'},'x"));
+                Assert.That(Parse(p, "x\"},\"x}"), Is.EqualTo("x\"},\"x"));
+                Assert.That(Parse(p, "x'},'x,"), Is.EqualTo("x'},'x"));
+                Assert.That(Parse(p, "x\"},\"x,"), Is.EqualTo("x\"},\"x"));
+            });
         }
 
         [Test]
         public void DoubleAndSingleStringStopAtCorrectCharacter()
         {
             var p = _grammar.test_doubleString;
-            Assert.That(Parse(p, "\"hello world\" 2"), Is.EqualTo("\"hello world\""));
-            Assert.That(Parse(p, " \"x\" "), Is.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, "\"hello world\" 2"), Is.EqualTo("\"hello world\""));
+                Assert.That(Parse(p, " \"x\" "), Is.Null);
+            });
 
             p = _grammar.test_singleString;
-            Assert.That(Parse(p, "'foo'-"), Is.EqualTo("'foo'"));
-            Assert.That(Parse(p, " 'x' "), Is.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, "'foo'-"), Is.EqualTo("'foo'"));
+                Assert.That(Parse(p, " 'x' "), Is.Null);
+            });
         }
 
         [Test]
         public void TermShouldFindNameDelimiterValueAndWhitespace()
         {
             var p = _grammar.test_term;
-            Assert.That(Parse(p, "foo='bar'"), Is.EqualTo("foo='bar'"));
-            Assert.That(Parse(p, " foo = 'bar' "), Is.EqualTo(" foo = 'bar' "));
-            Assert.That(Parse(p, " foo  'bar' "), Is.Null);
-            Assert.That(Parse(p, "  = 'bar' "), Is.Null);
-            Assert.That(Parse(p, " 3 = 5 "), Is.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, "foo='bar'"), Is.EqualTo("foo='bar'"));
+                Assert.That(Parse(p, " foo = 'bar' "), Is.EqualTo(" foo = 'bar' "));
+                Assert.That(Parse(p, " foo  'bar' "), Is.Null);
+                Assert.That(Parse(p, "  = 'bar' "), Is.Null);
+                Assert.That(Parse(p, " 3 = 5 "), Is.Null);
+            });
         }
 
         [Test]
         public void TermValueShouldStopAtCloseBraceOrComma()
         {
             var p = _grammar.test_term;
-            Assert.That(Parse(p, "foo='bar'}"), Is.EqualTo("foo='bar'"));
-            Assert.That(Parse(p, "foo='bar',"), Is.EqualTo("foo='bar'"));
-            Assert.That(Parse(p, " foo = 'bar' }"), Is.EqualTo(" foo = 'bar' "));
-            Assert.That(Parse(p, " foo = 'bar' ,"), Is.EqualTo(" foo = 'bar' "));
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, "foo='bar'}"), Is.EqualTo("foo='bar'"));
+                Assert.That(Parse(p, "foo='bar',"), Is.EqualTo("foo='bar'"));
+                Assert.That(Parse(p, " foo = 'bar' }"), Is.EqualTo(" foo = 'bar' "));
+                Assert.That(Parse(p, " foo = 'bar' ,"), Is.EqualTo(" foo = 'bar' "));
+            });
         }
 
         [Test]
         public void SeveralTermsMayBeSeperatedByComma()
         {
             var p = _grammar.test_terms;
-            Assert.That(Parse(p, "foo='bar'}"), Is.EqualTo("foo='bar'"));
-            Assert.That(Parse(p, "foo='bar',"), Is.EqualTo("foo='bar'"));
-            Assert.That(Parse(p, " foo = 'bar' }"), Is.EqualTo(" foo = 'bar' "));
-            Assert.That(Parse(p, " foo = 'bar' ,"), Is.EqualTo(" foo = 'bar' "));
-
-            Assert.That(Parse(p, "foo='bar',quad=5}"), Is.EqualTo("foo='bar',quad=5"));
-            Assert.That(Parse(p, "foo='bar',quad=5,"), Is.EqualTo("foo='bar',quad=5"));
-            Assert.That(Parse(p, " foo = 'bar' , quad = 5 }"), Is.EqualTo(" foo = 'bar' , quad = 5 "));
-            Assert.That(Parse(p, " foo = 'bar' , quad = 5 ,"), Is.EqualTo(" foo = 'bar' , quad = 5 "));
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, "foo='bar'}"), Is.EqualTo("foo='bar'"));
+                Assert.That(Parse(p, "foo='bar',"), Is.EqualTo("foo='bar'"));
+                Assert.That(Parse(p, " foo = 'bar' }"), Is.EqualTo(" foo = 'bar' "));
+                Assert.That(Parse(p, " foo = 'bar' ,"), Is.EqualTo(" foo = 'bar' "));
+
+                Assert.That(Parse(p, "foo='bar',quad=5}"), Is.EqualTo("foo='bar',quad=5"));
+                Assert.That(Parse(p, "foo='bar',quad=5,"), Is.EqualTo("foo='bar',quad=5"));
+                Assert.That(Parse(p, " foo = 'bar' , quad = 5 }"), Is.EqualTo(" foo = 'bar' , quad = 5 "));
+                Assert.That(Parse(p, " foo = 'bar' , quad = 5 ,"), Is.EqualTo(" foo = 'bar' , quad = 5 "));
+            });
         }
 
         [Test]
         public void AnonymousTypeShouldUnderstandAndConvertSyntax()
         {
             var p = _grammar.test_anonymousType;
-            Assert.That(Parse(p, "new {x = 4} "), Is.EqualTo("{x:4}"));
-            Assert.That(Parse(p, "new {x = 4, y = 3} "), Is.EqualTo("{x:4,y:3}"));
-            Assert.That(Parse(p, "new {x = ',}', y = 3} "), Is.EqualTo("{x:',}',y:3}"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, "new {x = 4} "), Is.EqualTo("{x:4}"));
+                Assert.That(Parse(p, "new {x = 4, y = 3} "), Is.EqualTo("{x:4,y:3}"));
+                Assert.That(Parse(p, "new {x = ',}', y = 3} "), Is.EqualTo("{x:',}',y:3}"));
+            });
         }
 
         [Test]
@@ -121,9 +145,12 @@ public void ReformatCodeShouldConvertAnonymousTypesRecursively()
         {
             var p = _grammar.ReformatCode;
 
-            Assert.That(Parse(p, "hello world"), Is.EqualTo("hello world"));
-            Assert.That(Parse(p, "Html.ActionLink('a','b',new {c='d', e='f'})"), Is.EqualTo("Html.ActionLink('a','b',{c:'d',e:'f'})"));
-            Assert.That(Parse(p, "Html.ActionLink('a','b',new {c='d', e=new{f=3, g='h'}})"), Is.EqualTo("Html.ActionLink('a','b',{c:'d',e:{f:3,g:'h'}})"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(Parse(p, "hello world"), Is.EqualTo("hello world"));
+                Assert.That(Parse(p, "Html.ActionLink('a','b',new {c='d', e='f'})"), Is.EqualTo("Html.ActionLink('a','b',{c:'d',e:'f'})"));
+                Assert.That(Parse(p, "Html.ActionLink('a','b',new {c='d', e=new{f=3, g='h'}})"), Is.EqualTo("Html.ActionLink('a','b',{c:'d',e:{f:3,g:'h'}})"));
+            });
         }
     }
 }
diff --git a/src/Spark.Tests/Parser/MarkupGrammarTester.cs b/src/Spark.Tests/Parser/MarkupGrammarTester.cs
index 53a45178..a5fd978b 100644
--- a/src/Spark.Tests/Parser/MarkupGrammarTester.cs
+++ b/src/Spark.Tests/Parser/MarkupGrammarTester.cs
@@ -46,7 +46,7 @@ private Position Source(string content)
         public void RepDigits()
         {
             ParseAction<char> digit =
-                delegate(Position input)
+                delegate (Position input)
                 {
                     if (input.PotentialLength() == 0 || !char.IsDigit(input.Peek())) return null;
                     return new ParseResult<char>(input.Advance(1), input.Peek());
@@ -55,31 +55,34 @@ public void RepDigits()
             var digits = digit.Rep();
 
             var result = digits(Source("55407"));
-            Assert.AreEqual(0, result.Rest.PotentialLength());
-            Assert.AreEqual("55407", new String(result.Value.ToArray()));
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Rest.PotentialLength(), Is.EqualTo(0));
+                Assert.That(new String(result.Value.ToArray()), Is.EqualTo("55407"));
+            });
         }
 
         [Test]
         public void TextNode()
         {
             var result = grammar.Text(Source("hello world"));
-            Assert.AreEqual("hello world", result.Value.Text);
+            Assert.That(result.Value.Text, Is.EqualTo("hello world"));
 
             var result2 = grammar.Text(Source("hello&nbsp;world"));
-            Assert.AreEqual("hello", result2.Value.Text);
+            Assert.That(result2.Value.Text, Is.EqualTo("hello"));
         }
 
         [Test]
         public void EntityNode()
         {
             var result = grammar.EntityRef(Source("&lt;"));
-            Assert.AreEqual("lt", result.Value.Name);
+            Assert.That(result.Value.Name, Is.EqualTo("lt"));
 
             var result2 = grammar.EntityRef(Source("&lt;world"));
-            Assert.AreEqual("lt", result2.Value.Name);
+            Assert.That(result2.Value.Name, Is.EqualTo("lt"));
 
             var result3 = grammar.EntityRef(Source("hello&lt;world"));
-            Assert.IsNull(result3);
+            Assert.That(result3, Is.Null);
         }
 
         [Test]
@@ -87,60 +90,72 @@ public void Rep1WontBeNone()
         {
             var parser = CharGrammar.Ch('x').Rep1();
             var three = parser(Source("xxx5"));
-            Assert.IsNotNull(three);
-            Assert.AreEqual(3, three.Value.Count);
+            Assert.That(three, Is.Not.Null);
+            Assert.That(three.Value, Has.Count.EqualTo(3));
 
             var nada = parser(Source("yxxx"));
-            Assert.IsNull(nada);
+            Assert.That(nada, Is.Null);
         }
 
         [Test]
         public void EntityTextSeries()
         {
             var result = grammar.Nodes(Source("hello&nbsp;world"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(3, result.Value.Count);
-            Assert.IsAssignableFrom(typeof(TextNode), result.Value[0]);
-            Assert.IsAssignableFrom(typeof(EntityNode), result.Value[1]);
-            Assert.IsAssignableFrom(typeof(TextNode), result.Value[2]);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Has.Count.EqualTo(3));
+            Assert.That(result.Value[0], Is.AssignableFrom(typeof(TextNode)));
+            Assert.That(result.Value[1], Is.AssignableFrom(typeof(EntityNode)));
+            Assert.That(result.Value[2], Is.AssignableFrom(typeof(TextNode)));
         }
 
         [Test]
         public void ParsingAttribute()
         {
             var result = grammar.Attribute(Source("foo=\"quad\""));
-            Assert.IsNotNull(result);
-            Assert.AreEqual("foo", result.Value.Name);
-            Assert.AreEqual("quad", result.Value.Value);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("foo"));
+                Assert.That(result.Value.Value, Is.EqualTo("quad"));
+            });
 
             var result2 = grammar.Attribute(Source("foo2='quad2'"));
-            Assert.IsNotNull(result2);
-            Assert.AreEqual("foo2", result2.Value.Name);
-            Assert.AreEqual("quad2", result2.Value.Value);
+            Assert.That(result2, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result2.Value.Name, Is.EqualTo("foo2"));
+                Assert.That(result2.Value.Value, Is.EqualTo("quad2"));
+            });
 
             var result3 = grammar.Attribute(Source("foo3!='quad2'"));
-            Assert.IsNull(result3);
+            Assert.That(result3, Is.Null);
         }
 
         [Test]
         public void ParsingElement()
         {
             var result = grammar.Element(Source("<blah>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual("blah", result.Value.Name);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value.Name, Is.EqualTo("blah"));
         }
 
         [Test]
         public void ParsingElementWithAttributes()
         {
             var result = grammar.Element(Source("<blah foo=\"quad\" omg=\"w00t\">"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual("blah", result.Value.Name);
-            Assert.AreEqual(2, result.Value.Attributes.Count);
-            Assert.AreEqual("foo", result.Value.Attributes[0].Name);
-            Assert.AreEqual("quad", result.Value.Attributes[0].Value);
-            Assert.AreEqual("omg", result.Value.Attributes[1].Name);
-            Assert.AreEqual("w00t", result.Value.Attributes[1].Value);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("blah"));
+                Assert.That(result.Value.Attributes, Has.Count.EqualTo(2));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Attributes[0].Name, Is.EqualTo("foo"));
+                Assert.That(result.Value.Attributes[0].Value, Is.EqualTo("quad"));
+                Assert.That(result.Value.Attributes[1].Name, Is.EqualTo("omg"));
+                Assert.That(result.Value.Attributes[1].Value, Is.EqualTo("w00t"));
+            });
         }
 
 
@@ -149,90 +164,120 @@ public void AttributeWithEntity()
         {
             var result = grammar.Element(Source("<blah attr=\"foo &amp; bar\" />"));
 
-            Assert.IsNotNull(result);
-            Assert.AreEqual("blah", result.Value.Name);
-            Assert.AreEqual(1, result.Value.Attributes.Count);
-            Assert.AreEqual(3, result.Value.Attributes[0].Nodes.Count);
-            Assert.AreEqual("foo ", (result.Value.Attributes[0].Nodes[0] as TextNode).Text);
-            Assert.AreEqual("amp", (result.Value.Attributes[0].Nodes[1] as EntityNode).Name);
-            Assert.AreEqual(" bar", (result.Value.Attributes[0].Nodes[2] as TextNode).Text);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("blah"));
+                Assert.That(result.Value.Attributes, Has.Count.EqualTo(1));
+            });
+            Assert.That(result.Value.Attributes[0].Nodes, Has.Count.EqualTo(3));
+            Assert.That((result.Value.Attributes[0].Nodes[0] as TextNode).Text, Is.EqualTo("foo "));
+            Assert.That((result.Value.Attributes[0].Nodes[1] as EntityNode).Name, Is.EqualTo("amp"));
+            Assert.That((result.Value.Attributes[0].Nodes[2] as TextNode).Text, Is.EqualTo(" bar"));
 
             result = grammar.Element(Source("<blah attr='foo &amp; bar' />"));
 
-            Assert.IsNotNull(result);
-            Assert.AreEqual("blah", result.Value.Name);
-            Assert.AreEqual(1, result.Value.Attributes.Count);
-            Assert.AreEqual(3, result.Value.Attributes[0].Nodes.Count);
-            Assert.AreEqual("foo ", (result.Value.Attributes[0].Nodes[0] as TextNode).Text);
-            Assert.AreEqual("amp", (result.Value.Attributes[0].Nodes[1] as EntityNode).Name);
-            Assert.AreEqual(" bar", (result.Value.Attributes[0].Nodes[2] as TextNode).Text);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("blah"));
+                Assert.That(result.Value.Attributes, Has.Count.EqualTo(1));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Attributes[0].Nodes, Has.Count.EqualTo(3));
+                Assert.That((result.Value.Attributes[0].Nodes[0] as TextNode).Text, Is.EqualTo("foo "));
+                Assert.That((result.Value.Attributes[0].Nodes[1] as EntityNode).Name, Is.EqualTo("amp"));
+                Assert.That((result.Value.Attributes[0].Nodes[2] as TextNode).Text, Is.EqualTo(" bar"));
+            });
         }
 
         [Test]
         public void AttributeWithConditionalAnd()
         {
             var result = grammar.Element(Source("<blah attr=\"foo && bar\" />"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual("blah", result.Value.Name);
-            Assert.AreEqual(1, result.Value.Attributes.Count);
-            Assert.AreEqual(4, result.Value.Attributes[0].Nodes.Count);
-            Assert.AreEqual("foo ", (result.Value.Attributes[0].Nodes[0] as TextNode).Text);
-            Assert.AreEqual("&", (result.Value.Attributes[0].Nodes[1] as TextNode).Text);
-            Assert.AreEqual("&", (result.Value.Attributes[0].Nodes[2] as TextNode).Text);
-            Assert.AreEqual(" bar", (result.Value.Attributes[0].Nodes[3] as TextNode).Text);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("blah"));
+                Assert.That(result.Value.Attributes, Has.Count.EqualTo(1));
+            });
+            Assert.That(result.Value.Attributes[0].Nodes, Has.Count.EqualTo(4));
+            Assert.That((result.Value.Attributes[0].Nodes[0] as TextNode).Text, Is.EqualTo("foo "));
+            Assert.That((result.Value.Attributes[0].Nodes[1] as TextNode).Text, Is.EqualTo("&"));
+            Assert.That((result.Value.Attributes[0].Nodes[2] as TextNode).Text, Is.EqualTo("&"));
+            Assert.That((result.Value.Attributes[0].Nodes[3] as TextNode).Text, Is.EqualTo(" bar"));
 
             result = grammar.Element(Source("<blah attr='foo && bar' />"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual("blah", result.Value.Name);
-            Assert.AreEqual(1, result.Value.Attributes.Count);
-            Assert.AreEqual(4, result.Value.Attributes[0].Nodes.Count);
-            Assert.AreEqual("foo ", (result.Value.Attributes[0].Nodes[0] as TextNode).Text);
-            Assert.AreEqual("&", (result.Value.Attributes[0].Nodes[1] as TextNode).Text);
-            Assert.AreEqual("&", (result.Value.Attributes[0].Nodes[2] as TextNode).Text);
-            Assert.AreEqual(" bar", (result.Value.Attributes[0].Nodes[3] as TextNode).Text);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("blah"));
+                Assert.That(result.Value.Attributes, Has.Count.EqualTo(1));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Attributes[0].Nodes, Has.Count.EqualTo(4));
+                Assert.That((result.Value.Attributes[0].Nodes[0] as TextNode).Text, Is.EqualTo("foo "));
+                Assert.That((result.Value.Attributes[0].Nodes[1] as TextNode).Text, Is.EqualTo("&"));
+                Assert.That((result.Value.Attributes[0].Nodes[2] as TextNode).Text, Is.EqualTo("&"));
+                Assert.That((result.Value.Attributes[0].Nodes[3] as TextNode).Text, Is.EqualTo(" bar"));
+            });
         }
 
         [Test]
         public void ParsingEndElement()
         {
             var result = grammar.EndElement(Source("</blah>"));
-            Assert.IsNotNull(result);
-            Assert.IsAssignableFrom(typeof(EndElementNode), result.Value);
-            Assert.AreEqual("blah", result.Value.Name);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Is.AssignableFrom(typeof(EndElementNode)));
+            Assert.That(result.Value.Name, Is.EqualTo("blah"));
         }
 
         [Test]
         public void PassingSimpleMarkup()
         {
             var result = grammar.Nodes(Source("<foo><bar>one</bar><quad a='1' b='2'>55</quad></foo>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(0, result.Rest.PotentialLength());
-            Assert.AreEqual(8, result.Value.Count);
-            Assert.IsAssignableFrom(typeof(ElementNode), result.Value[4]);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Rest.PotentialLength(), Is.EqualTo(0));
+                Assert.That(result.Value, Has.Count.EqualTo(8));
+            });
+            Assert.That(result.Value[4], Is.AssignableFrom(typeof(ElementNode)));
             var elt = result.Value[4] as ElementNode;
-            Assert.AreEqual("quad", elt.Name);
-            Assert.AreEqual(2, elt.Attributes.Count);
-            Assert.AreEqual("2", elt.Attributes[1].Value);
+            Assert.Multiple(() =>
+            {
+                Assert.That(elt.Name, Is.EqualTo("quad"));
+                Assert.That(elt.Attributes, Has.Count.EqualTo(2));
+            });
+            Assert.That(elt.Attributes[1].Value, Is.EqualTo("2"));
         }
 
         [Test]
         public void SelfEnding()
         {
             var result = grammar.Nodes(Source("<div><br/></div>"));
-            Assert.IsAssignableFrom(typeof(ElementNode), result.Value[0]);
-            Assert.IsAssignableFrom(typeof(ElementNode), result.Value[1]);
-            Assert.IsAssignableFrom(typeof(EndElementNode), result.Value[2]);
+            Assert.That(result.Value[0], Is.AssignableFrom(typeof(ElementNode)));
+            Assert.That(result.Value[1], Is.AssignableFrom(typeof(ElementNode)));
+            Assert.That(result.Value[2], Is.AssignableFrom(typeof(EndElementNode)));
 
             var div = result.Value[0] as ElementNode;
-            Assert.AreEqual("div", div.Name);
-            Assert.That(!div.IsEmptyElement);
+            Assert.Multiple(() =>
+            {
+                Assert.That(div.Name, Is.EqualTo("div"));
+                Assert.That(!div.IsEmptyElement);
+            });
 
             var br = result.Value[1] as ElementNode;
-            Assert.AreEqual("br", br.Name);
-            Assert.That(br.IsEmptyElement);
+            Assert.Multiple(() =>
+            {
+                Assert.That(br.Name, Is.EqualTo("br"));
+                Assert.That(br.IsEmptyElement);
+            });
 
             var ediv = result.Value[2] as EndElementNode;
-            Assert.AreEqual("div", ediv.Name);
+            Assert.That(ediv.Name, Is.EqualTo("div"));
         }
 
         [Test]
@@ -243,60 +288,72 @@ public void DoctypeParser()
                     Source(
                         "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/2002/REC-xhtml1-20020801/DTD/xhtml1-strict.dtd\">"));
 
-            Assert.IsNotNull(result);
-            Assert.AreEqual("html", result.Value.Name);
-            Assert.AreEqual("PUBLIC", result.Value.ExternalId.ExternalIdType);
-            Assert.AreEqual("-//W3C//DTD XHTML 1.0 Strict//EN", result.Value.ExternalId.PublicId);
-            Assert.AreEqual("http://www.w3.org/TR/2002/REC-xhtml1-20020801/DTD/xhtml1-strict.dtd", result.Value.ExternalId.SystemId);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("html"));
+                Assert.That(result.Value.ExternalId.ExternalIdType, Is.EqualTo("PUBLIC"));
+                Assert.That(result.Value.ExternalId.PublicId, Is.EqualTo("-//W3C//DTD XHTML 1.0 Strict//EN"));
+                Assert.That(result.Value.ExternalId.SystemId, Is.EqualTo("http://www.w3.org/TR/2002/REC-xhtml1-20020801/DTD/xhtml1-strict.dtd"));
+            });
 
             var result2 =
                 grammar.DoctypeDecl(
                     Source(
                         "<!DOCTYPE html PUBLIC \"http://www.w3.org/TR/2002/REC-xhtml1-20020801/DTD/xhtml1-strict.dtd\">"));
-            Assert.IsNull(result2);
+            Assert.That(result2, Is.Null);
 
             var result3 =
                 grammar.DoctypeDecl(
                     Source(
                         "<!DOCTYPE html SYSTEM 'hello world'>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual("html", result3.Value.Name);
-            Assert.AreEqual("SYSTEM", result3.Value.ExternalId.ExternalIdType);
-            Assert.AreEqual("hello world", result3.Value.ExternalId.SystemId);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result3.Value.Name, Is.EqualTo("html"));
+                Assert.That(result3.Value.ExternalId.ExternalIdType, Is.EqualTo("SYSTEM"));
+                Assert.That(result3.Value.ExternalId.SystemId, Is.EqualTo("hello world"));
+            });
 
             var result4 =
                 grammar.DoctypeDecl(
                     Source(
                         "<!DOCTYPE foo >"));
-            Assert.IsNotNull(result4);
-            Assert.AreEqual("foo", result4.Value.Name);
-            Assert.IsNull(result4.Value.ExternalId);
+            Assert.That(result4, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result4.Value.Name, Is.EqualTo("foo"));
+                Assert.That(result4.Value.ExternalId, Is.Null);
+            });
         }
 
         [Test]
         public void CodeInText()
         {
             var result = grammar.Nodes(Source("<hello>foo${bar}ex</hello>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(5, result.Value.Count);
-            Assert.IsAssignableFrom(typeof(ExpressionNode), result.Value[2]);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Has.Count.EqualTo(5));
+            Assert.That(result.Value[2], Is.AssignableFrom(typeof(ExpressionNode)));
             var code = (ExpressionNode)result.Value[2];
-            Assert.AreEqual("bar", (string)code.Code);
+            Assert.That((string)code.Code, Is.EqualTo("bar"));
 
             result = grammar.Nodes(Source("<hello>foo<%=baaz%>ex</hello>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(5, result.Value.Count);
-            Assert.IsAssignableFrom(typeof(ExpressionNode), result.Value[2]);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Has.Count.EqualTo(5));
+            Assert.That(result.Value[2], Is.AssignableFrom(typeof(ExpressionNode)));
             var code2 = (ExpressionNode)result.Value[2];
-            Assert.AreEqual("baaz", (string)code2.Code);
+            Assert.That((string)code2.Code, Is.EqualTo("baaz"));
 
             result = grammar.Nodes(Source("<hello href='${one}' class=\"<%=two%>\"/>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(1, result.Value.Count);
-            Assert.IsAssignableFrom(typeof(ElementNode), result.Value[0]);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Has.Count.EqualTo(1));
+            Assert.That(result.Value[0], Is.AssignableFrom(typeof(ElementNode)));
             var elt = (ElementNode)result.Value[0];
-            Assert.AreEqual("one", (string)((ExpressionNode)elt.Attributes[0].Nodes[0]).Code);
-            Assert.AreEqual("two", (string)((ExpressionNode)elt.Attributes[1].Nodes[0]).Code);
+            Assert.Multiple(() =>
+            {
+                Assert.That((string)((ExpressionNode)elt.Attributes[0].Nodes[0]).Code, Is.EqualTo("one"));
+                Assert.That((string)((ExpressionNode)elt.Attributes[1].Nodes[0]).Code, Is.EqualTo("two"));
+            });
 
         }
 
@@ -304,93 +361,108 @@ public void CodeInText()
         public void AspxStyleOutputInText()
         {
             var result = grammar.Nodes(Source("<hello>foo<%=bar%>ex</hello>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(5, result.Value.Count);
-            Assert.IsAssignableFrom(typeof(ExpressionNode), result.Value[2]);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Has.Count.EqualTo(5));
+            Assert.That(result.Value[2], Is.AssignableFrom(typeof(ExpressionNode)));
             var code = result.Value[2] as ExpressionNode;
-            Assert.AreEqual("bar", (string)code.Code);
+            Assert.Multiple(() =>
+            {
+                Assert.That((string)code.Code, Is.EqualTo("bar"));
 
 
-            Assert.AreEqual("foo", ((TextNode)result.Value[1]).Text);
-            Assert.AreEqual("ex", ((TextNode)result.Value[3]).Text);
+                Assert.That(((TextNode)result.Value[1]).Text, Is.EqualTo("foo"));
+                Assert.That(((TextNode)result.Value[3]).Text, Is.EqualTo("ex"));
+            });
         }
 
         [Test]
         public void CommentParser()
         {
             var result = grammar.Comment(Source("<!-- hello world -->"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(" hello world ", result.Value.Text);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value.Text, Is.EqualTo(" hello world "));
 
             var result2 = grammar.Comment(Source("<!-- hello-world -->"));
-            Assert.IsNotNull(result2);
-            Assert.AreEqual(" hello-world ", result2.Value.Text);
+            Assert.That(result2, Is.Not.Null);
+            Assert.That(result2.Value.Text, Is.EqualTo(" hello-world "));
 
             var result3 = grammar.Comment(Source("<!-- hello--world -->"));
-            Assert.IsNull(result3);
+            Assert.That(result3, Is.Null);
         }
 
         [Test]
         public void CodeStatementsPercentSyntax()
         {
             var direct = grammar.Statement(Source("<%int x = 5;%>"));
-            Assert.AreEqual("int x = 5;", (string)direct.Value.Code);
+            Assert.That((string)direct.Value.Code, Is.EqualTo("int x = 5;"));
 
             var result = grammar.Nodes(Source("<div>hello <%int x = 5;%> world</div>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(5, result.Value.Count);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Has.Count.EqualTo(5));
             var stmt = result.Value[2] as StatementNode;
-            Assert.IsNotNull(stmt);
-            Assert.AreEqual("int x = 5;", (string)stmt.Code);
+            Assert.Multiple(() =>
+            {
+                Assert.That(stmt, Is.Not.Null);
+                Assert.That((string)stmt.Code, Is.EqualTo("int x = 5;"));
+            });
         }
 
         [Test]
         public void CodeStatementsHashSyntax()
         {
             var direct = grammar.Statement(Source("\n#int x = 5;\n"));
-            Assert.AreEqual("int x = 5;", (string)direct.Value.Code);
+            Assert.That((string)direct.Value.Code, Is.EqualTo("int x = 5;"));
 
             var result = grammar.Nodes(Source("<div>hello\n #int x = 5;\n world</div>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual(5, result.Value.Count);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Has.Count.EqualTo(5));
             var stmt = result.Value[2] as StatementNode;
-            Assert.IsNotNull(stmt);
-            Assert.AreEqual("int x = 5;", (string)stmt.Code);
+            Assert.Multiple(() =>
+            {
+                Assert.That(stmt, Is.Not.Null);
+                Assert.That((string)stmt.Code, Is.EqualTo("int x = 5;"));
+            });
         }
 
         [Test]
         public void SpecialCharactersInAttributes()
         {
             var attr1 = grammar.Attribute(Source("foo=\"bar$('hello')\""));
-            Assert.AreEqual("bar$('hello')", attr1.Value.Value);
+            Assert.That(attr1.Value.Value, Is.EqualTo("bar$('hello')"));
 
             var attr2 = grammar.Attribute(Source("foo=\"$('#hello')\""));
-            Assert.AreEqual("$('#hello')", attr2.Value.Value);
+            Assert.That(attr2.Value.Value, Is.EqualTo("$('#hello')"));
 
             var attr3 = grammar.Attribute(Source("foo='#hello'"));
-            Assert.AreEqual("#hello", attr3.Value.Value);
+            Assert.That(attr3.Value.Value, Is.EqualTo("#hello"));
         }
 
         [Test]
         public void JQueryIdSelectorInAttribute()
         {
             var attr1 = grammar.Attribute(Source("foo='javascript:$(\"#diff\").hide()'"));
-            Assert.AreEqual("javascript:$(\"#diff\").hide()", attr1.Value.Value);
+            Assert.That(attr1.Value.Value, Is.EqualTo("javascript:$(\"#diff\").hide()"));
 
             var attr2 = grammar.Attribute(Source("foo=\"javascript:$('#diff').hide()\""));
-            Assert.AreEqual("javascript:$('#diff').hide()", attr2.Value.Value);
+            Assert.That(attr2.Value.Value, Is.EqualTo("javascript:$('#diff').hide()"));
         }
 
         [Test]
         public void JQueryIdSelectorInText()
         {
             var nodes1 = grammar.Nodes(Source("<script>\r\n$(\"#diff\").hide();\r\n</script>"));
-            Assert.AreEqual(3, nodes1.Value.Count);
-            Assert.That(((TextNode)nodes1.Value[1]).Text, Tests.Contains.InOrder("$(\"#diff\").hide();"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(nodes1.Value, Has.Count.EqualTo(3));
+                Assert.That(((TextNode)nodes1.Value[1]).Text, Tests.Contains.InOrder("$(\"#diff\").hide();"));
+            });
 
             var nodes2 = grammar.Nodes(Source("<script>\r\n$('#diff').hide();\r\n</script>"));
-            Assert.AreEqual(3, nodes2.Value.Count);
-            Assert.That(((TextNode)nodes2.Value[1]).Text, Tests.Contains.InOrder("$('#diff').hide();"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(nodes2.Value, Has.Count.EqualTo(3));
+                Assert.That(((TextNode)nodes2.Value[1]).Text, Tests.Contains.InOrder("$('#diff').hide();"));
+            });
         }
 
 
@@ -398,24 +470,33 @@ public void JQueryIdSelectorInText()
         public void HashStatementMustBeFirstNonWhitespaceCharacter()
         {
             var nodes1 = grammar.Nodes(Source("<p>abc\r\n \t#Logger.Warn('Hello World');\r\ndef</p>"));
-            Assert.AreEqual(5, nodes1.Value.Count);
-            Assert.AreEqual("Logger.Warn(\"Hello World\");", (string)((StatementNode)nodes1.Value[2]).Code);
+            Assert.Multiple(() =>
+            {
+                Assert.That(nodes1.Value, Has.Count.EqualTo(5));
+                Assert.That((string)((StatementNode)nodes1.Value[2]).Code, Is.EqualTo("Logger.Warn(\"Hello World\");"));
+            });
 
             var nodes2 = grammar.Nodes(Source("<p>abc\r\n \t x#Logger.Warn('Hello World');\r\ndef</p>"));
-            Assert.AreEqual(3, nodes2.Value.Count);
-            Assert.AreEqual("abc\r\n \t x#Logger.Warn('Hello World');\r\ndef", (string)((TextNode)nodes2.Value[1]).Text);
+            Assert.Multiple(() =>
+            {
+                Assert.That(nodes2.Value, Has.Count.EqualTo(3));
+                Assert.That((string)((TextNode)nodes2.Value[1]).Text, Is.EqualTo("abc\r\n \t x#Logger.Warn('Hello World');\r\ndef"));
+            });
         }
 
         [Test]
         public void ConditionalSyntaxInAttributes()
         {
             var attr = grammar.Attribute(Source("foo=\"one?{true}\""));
-            Assert.AreEqual(0, attr.Rest.PotentialLength());
-            Assert.AreEqual("foo", attr.Value.Name);
-            Assert.AreEqual(2, attr.Value.Nodes.Count);
-            Assert.AreEqual("one?{true}", attr.Value.Value);
-            Assert.AreEqual("one", ((TextNode)attr.Value.Nodes[0]).Text);
-            Assert.AreEqual("true", (string)((ConditionNode)attr.Value.Nodes[1]).Code);
+            Assert.Multiple(() =>
+            {
+                Assert.That(attr.Rest.PotentialLength(), Is.EqualTo(0));
+                Assert.That(attr.Value.Name, Is.EqualTo("foo"));
+                Assert.That(attr.Value.Nodes, Has.Count.EqualTo(2));
+                Assert.That(attr.Value.Value, Is.EqualTo("one?{true}"));
+                Assert.That(((TextNode)attr.Value.Nodes[0]).Text, Is.EqualTo("one"));
+                Assert.That((string)((ConditionNode)attr.Value.Nodes[1]).Code, Is.EqualTo("true"));
+            });
         }
 
         [Test]
@@ -424,25 +505,34 @@ public void XMLDeclParser()
             var result =
                 grammar.XMLDecl(
                     Source("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"));
-            Assert.IsNotNull(result);
-            Assert.AreEqual("UTF-8", result.Value.Encoding);
-            Assert.IsNull(result.Value.Standalone);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Encoding, Is.EqualTo("UTF-8"));
+                Assert.That(result.Value.Standalone, Is.Null);
+            });
 
             result =
                 grammar.XMLDecl(
                     Source("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone='no'  ?>"));
-         
-            Assert.IsNotNull(result);
-            Assert.AreEqual("UTF-8", result.Value.Encoding);
-            Assert.AreEqual("no", result.Value.Standalone);
+
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Encoding, Is.EqualTo("UTF-8"));
+                Assert.That(result.Value.Standalone, Is.EqualTo("no"));
+            });
 
             result =
                 grammar.XMLDecl(
                     Source("<?xml version=\"1.0\" standalone=\"yes\"  ?>"));
 
-            Assert.IsNotNull(result);
-            Assert.IsNull(result.Value.Encoding);
-            Assert.AreEqual("yes", result.Value.Standalone);
+            Assert.That(result, Is.Not.Null);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Encoding, Is.Null);
+                Assert.That(result.Value.Standalone, Is.EqualTo("yes"));
+            });
         }
 
         [Test]
@@ -451,7 +541,7 @@ public void ProcessingInstructionWontParseXMLDecl()
             var result =
                 grammar.ProcessingInstruction(
                     Source("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"));
-            Assert.IsNull(result);
+            Assert.That(result, Is.Null);
         }
 
 
@@ -461,14 +551,20 @@ public void ProcessingInstruction()
             var result = grammar.ProcessingInstruction(
                     Source("<?foo?>"));
 
-            Assert.AreEqual("foo", result.Value.Name);
-            Assert.That(string.IsNullOrEmpty(result.Value.Body));
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("foo"));
+                Assert.That(string.IsNullOrEmpty(result.Value.Body));
+            });
 
             result = grammar.ProcessingInstruction(
                     Source("<?php hello ?>"));
 
-            Assert.AreEqual("php", result.Value.Name);
-            Assert.AreEqual("hello ", result.Value.Body);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Name, Is.EqualTo("php"));
+                Assert.That(result.Value.Body, Is.EqualTo("hello "));
+            });
         }
 
         [Test]
@@ -477,12 +573,18 @@ public void LessThanCanBeUsedAsText()
             var result = grammar.Nodes(
                     Source("<p class=\"three<four\">One<Two</p>"));
 
-            Assert.AreEqual(5, result.Value.Count);
-            Assert.AreEqual("<", ((TextNode)result.Value[2]).Text);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value, Has.Count.EqualTo(5));
+                Assert.That(((TextNode)result.Value[2]).Text, Is.EqualTo("<"));
+            });
 
-            var elt = (ElementNode) result.Value[0];
-            Assert.AreEqual(3, elt.Attributes[0].Nodes.Count);
-            Assert.AreEqual("<", ((TextNode)elt.Attributes[0].Nodes[1]).Text);
+            var elt = (ElementNode)result.Value[0];
+            Assert.Multiple(() =>
+            {
+                Assert.That(elt.Attributes[0].Nodes, Has.Count.EqualTo(3));
+                Assert.That(((TextNode)elt.Attributes[0].Nodes[1]).Text, Is.EqualTo("<"));
+            });
         }
 
         [Test]
@@ -490,33 +592,42 @@ public void StatementAtStartOfFile()
         {
             var result1 = grammar.Nodes(
                 Source("#alpha\r\n"));
-            Assert.AreEqual(2, result1.Value.Count);
-            Assert.IsInstanceOf(typeof(StatementNode), result1.Value[0]);
-            Assert.AreEqual("alpha", (string)((StatementNode)result1.Value[0]).Code);
-            Assert.IsInstanceOf(typeof(TextNode), result1.Value[1]);
-            Assert.AreEqual("\r\n", ((TextNode)result1.Value[1]).Text);
+            Assert.That(result1.Value, Has.Count.EqualTo(2));
+            Assert.Multiple(() =>
+            {
+                Assert.That(result1.Value[0], Is.InstanceOf(typeof(StatementNode)));
+                Assert.That((string)((StatementNode)result1.Value[0]).Code, Is.EqualTo("alpha"));
+                Assert.That(result1.Value[1], Is.InstanceOf(typeof(TextNode)));
+                Assert.That(((TextNode)result1.Value[1]).Text, Is.EqualTo("\r\n"));
+            });
 
             var result2 = grammar.Nodes(
                 Source("#alpha\r\ntext\r\n#beta"));
-            Assert.AreEqual(3, result2.Value.Count);
-            Assert.IsInstanceOf(typeof(StatementNode), result2.Value[0]);
-            Assert.AreEqual("alpha", (string)((StatementNode)result2.Value[0]).Code);
-            Assert.IsInstanceOf(typeof(TextNode), result2.Value[1]);
-            Assert.AreEqual("\r\ntext", ((TextNode)result2.Value[1]).Text);
-            Assert.IsInstanceOf(typeof(StatementNode), result2.Value[2]);
-            Assert.AreEqual("beta", (string)((StatementNode)result2.Value[2]).Code);
+            Assert.That(result2.Value, Has.Count.EqualTo(3));
+            Assert.Multiple(() =>
+            {
+                Assert.That(result2.Value[0], Is.InstanceOf(typeof(StatementNode)));
+                Assert.That((string)((StatementNode)result2.Value[0]).Code, Is.EqualTo("alpha"));
+                Assert.That(result2.Value[1], Is.InstanceOf(typeof(TextNode)));
+                Assert.That(((TextNode)result2.Value[1]).Text, Is.EqualTo("\r\ntext"));
+                Assert.That(result2.Value[2], Is.InstanceOf(typeof(StatementNode)));
+                Assert.That((string)((StatementNode)result2.Value[2]).Code, Is.EqualTo("beta"));
+            });
 
             var result3 = grammar.Nodes(
                 Source("\r\n#alpha\r\ntext\r\n#beta\r\n"));
-            Assert.AreEqual(4, result3.Value.Count);
-            Assert.IsInstanceOf(typeof(StatementNode), result3.Value[0]);
-            Assert.AreEqual("alpha", (string)((StatementNode)result3.Value[0]).Code);
-            Assert.IsInstanceOf(typeof(TextNode), result3.Value[1]);
-            Assert.AreEqual("\r\ntext", ((TextNode)result3.Value[1]).Text);
-            Assert.IsInstanceOf(typeof(StatementNode), result3.Value[2]);
-            Assert.AreEqual("beta", (string)((StatementNode)result3.Value[2]).Code);
-            Assert.IsInstanceOf(typeof(TextNode), result3.Value[3]);
-            Assert.AreEqual("\r\n", ((TextNode)result3.Value[3]).Text);
+            Assert.That(result3.Value, Has.Count.EqualTo(4));
+            Assert.Multiple(() =>
+            {
+                Assert.That(result3.Value[0], Is.InstanceOf(typeof(StatementNode)));
+                Assert.That((string)((StatementNode)result3.Value[0]).Code, Is.EqualTo("alpha"));
+                Assert.That(result3.Value[1], Is.InstanceOf(typeof(TextNode)));
+                Assert.That(((TextNode)result3.Value[1]).Text, Is.EqualTo("\r\ntext"));
+                Assert.That(result3.Value[2], Is.InstanceOf(typeof(StatementNode)));
+                Assert.That((string)((StatementNode)result3.Value[2]).Code, Is.EqualTo("beta"));
+                Assert.That(result3.Value[3], Is.InstanceOf(typeof(TextNode)));
+                Assert.That(((TextNode)result3.Value[3]).Text, Is.EqualTo("\r\n"));
+            });
         }
     }
 }
diff --git a/src/Spark.Tests/Parser/PaintTester.cs b/src/Spark.Tests/Parser/PaintTester.cs
index 3cf1a717..b70944ad 100644
--- a/src/Spark.Tests/Parser/PaintTester.cs
+++ b/src/Spark.Tests/Parser/PaintTester.cs
@@ -67,15 +67,18 @@ public void PaintingRangeOfText()
         {
             var pos = new Position(new SourceContext("abc123def"));
             var result = _grammar.DigitPaint(pos);
-            Assert.AreEqual("abc", result.Value.Before);
-            Assert.AreEqual("123", result.Value.Thing);
-            Assert.AreEqual("def", result.Value.After);
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value.Before, Is.EqualTo("abc"));
+                Assert.That(result.Value.Thing, Is.EqualTo("123"));
+                Assert.That(result.Value.After, Is.EqualTo("def"));
 
-            Assert.AreEqual(1, result.Rest.GetPaint().Count());
+                Assert.That(result.Rest.GetPaint().Count(), Is.EqualTo(1));
 
-            Assert.AreEqual("123", result.Rest.PaintLink.Paint.Value);
-            Assert.AreEqual(3, result.Rest.PaintLink.Paint.Begin.Offset);
-            Assert.AreEqual(6, result.Rest.PaintLink.Paint.End.Offset);
+                Assert.That(result.Rest.PaintLink.Paint.Value, Is.EqualTo("123"));
+                Assert.That(result.Rest.PaintLink.Paint.Begin.Offset, Is.EqualTo(3));
+                Assert.That(result.Rest.PaintLink.Paint.End.Offset, Is.EqualTo(6));
+            });
         }
 
         [Test]
@@ -83,7 +86,7 @@ public void PaintingArray()
         {
             var pos = new Position(new SourceContext(" abc123def a5t 34w e5 "));
             var result = _grammar.ManyPaints(pos);
-            Assert.AreEqual(4, result.Value.Count);
+            Assert.That(result.Value, Has.Count.EqualTo(4));
 
             var paints = new List<Paint>();
             foreach (var info in result.Value)
@@ -93,17 +96,20 @@ public void PaintingArray()
                 paints.Add(paint);
             }
 
-            Assert.AreEqual(1, paints[0].Begin.Offset);
-            Assert.AreEqual(10, paints[0].End.Offset);
-            Assert.AreEqual(11, paints[1].Begin.Offset);
-            Assert.AreEqual(14, paints[1].End.Offset);
-            Assert.AreEqual(15, paints[2].Begin.Offset);
-            Assert.AreEqual(18, paints[2].End.Offset);
-            Assert.AreEqual(19, paints[3].Begin.Offset);
-            Assert.AreEqual(21, paints[3].End.Offset);
-
-            Assert.AreEqual(4, result.Rest.GetPaint().OfType<Paint<string>>().Count());
-            Assert.AreEqual(4, result.Rest.GetPaint().OfType<Paint<PaintInfo>>().Count());
+            Assert.Multiple(() =>
+            {
+                Assert.That(paints[0].Begin.Offset, Is.EqualTo(1));
+                Assert.That(paints[0].End.Offset, Is.EqualTo(10));
+                Assert.That(paints[1].Begin.Offset, Is.EqualTo(11));
+                Assert.That(paints[1].End.Offset, Is.EqualTo(14));
+                Assert.That(paints[2].Begin.Offset, Is.EqualTo(15));
+                Assert.That(paints[2].End.Offset, Is.EqualTo(18));
+                Assert.That(paints[3].Begin.Offset, Is.EqualTo(19));
+                Assert.That(paints[3].End.Offset, Is.EqualTo(21));
+
+                Assert.That(result.Rest.GetPaint().OfType<Paint<string>>().Count(), Is.EqualTo(4));
+                Assert.That(result.Rest.GetPaint().OfType<Paint<PaintInfo>>().Count(), Is.EqualTo(4));
+            });
         }
 
         [Test]
@@ -112,8 +118,11 @@ public void PaintingNodes()
             var input = "<div><p class='subtle'>Hello World</p> ${Tada} </div>";
             var grammar = new MarkupGrammar();
             var result = grammar.Nodes(new Position(new SourceContext(input)));
-            Assert.AreEqual(8, result.Value.Count);
-            Assert.AreEqual(10, result.Rest.GetPaint().OfType<Paint<Node>>().Count());
+            Assert.Multiple(() =>
+            {
+                Assert.That(result.Value, Has.Count.EqualTo(8));
+                Assert.That(result.Rest.GetPaint().OfType<Paint<Node>>().Count(), Is.EqualTo(10));
+            });
         }
 
 
@@ -123,21 +132,27 @@ public void PaintingAttributes()
             var input = "<div id='rea' class='foo'/>";
             var grammar = new MarkupGrammar();
             var result = grammar.Nodes(new Position(new SourceContext(input)));
-            Assert.AreEqual(1, result.Value.Count);
-            
+            Assert.That(result.Value, Has.Count.EqualTo(1));
+
             var paints = result.Rest.GetPaint();
-            Assert.AreEqual(1, paints.Select(p => p.Value).OfType<ElementNode>().Count());
-            Assert.AreEqual(2, paints.Select(p => p.Value).OfType<AttributeNode>().Count());
-            Assert.AreEqual(2, paints.Select(p => p.Value).OfType<TextNode>().Count());
-            Assert.AreEqual(5, paints.OfType<Paint<Node>>().Count());
+            Assert.Multiple(() =>
+            {
+                Assert.That(paints.Select(p => p.Value).OfType<ElementNode>().Count(), Is.EqualTo(1));
+                Assert.That(paints.Select(p => p.Value).OfType<AttributeNode>().Count(), Is.EqualTo(2));
+                Assert.That(paints.Select(p => p.Value).OfType<TextNode>().Count(), Is.EqualTo(2));
+                Assert.That(paints.OfType<Paint<Node>>().Count(), Is.EqualTo(5));
+            });
 
             var attrId = paints.Single(p => (p.Value is AttributeNode) && ((AttributeNode)p.Value).Name == "id");
             var attrClass = paints.Single(p => (p.Value is AttributeNode) && ((AttributeNode)p.Value).Name == "class");
 
-            Assert.AreEqual(5, attrId.Begin.Offset);
-            Assert.AreEqual(13, attrId.End.Offset);
-            Assert.AreEqual(14, attrClass.Begin.Offset);
-            Assert.AreEqual(25, attrClass.End.Offset);
+            Assert.Multiple(() =>
+            {
+                Assert.That(attrId.Begin.Offset, Is.EqualTo(5));
+                Assert.That(attrId.End.Offset, Is.EqualTo(13));
+                Assert.That(attrClass.Begin.Offset, Is.EqualTo(14));
+                Assert.That(attrClass.End.Offset, Is.EqualTo(25));
+            });
         }
     }
 }
diff --git a/src/Spark.Tests/Parser/PositionTester.cs b/src/Spark.Tests/Parser/PositionTester.cs
index d7d578e0..45d6a85b 100644
--- a/src/Spark.Tests/Parser/PositionTester.cs
+++ b/src/Spark.Tests/Parser/PositionTester.cs
@@ -25,148 +25,202 @@ public class PositionTester
         public void PositionStartsOnOneOne()
         {
             Position position = new Position(new SourceContext("hello world"));
-            Assert.AreEqual(1, position.Line);
-            Assert.AreEqual(1, position.Column);
-            Assert.AreEqual(0, position.Offset);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Line, Is.EqualTo(1));
+                Assert.That(position.Column, Is.EqualTo(1));
+                Assert.That(position.Offset, Is.EqualTo(0));
+            });
         }
 
         [Test]
         public void AdvanceChangesColumnOffset()
         {
             Position position = new Position(new SourceContext("hello world"));
-            Assert.AreEqual(0, position.Offset);
-            Assert.AreEqual(1, position.Line);
-            Assert.AreEqual(1, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(0));
+                Assert.That(position.Line, Is.EqualTo(1));
+                Assert.That(position.Column, Is.EqualTo(1));
+            });
             position = position.Advance(5);
-            Assert.AreEqual(5, position.Offset);
-            Assert.AreEqual(1, position.Line);
-            Assert.AreEqual(6, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(5));
+                Assert.That(position.Line, Is.EqualTo(1));
+                Assert.That(position.Column, Is.EqualTo(6));
+            });
         }
 
         [Test]
         public void NewlineChangesLine()
         {
             Position position = new Position(new SourceContext("hello\r\nworld"));
-            Assert.AreEqual(0, position.Offset);
-            Assert.AreEqual(1, position.Line);
-            Assert.AreEqual(1, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(0));
+                Assert.That(position.Line, Is.EqualTo(1));
+                Assert.That(position.Column, Is.EqualTo(1));
+            });
             position = position.Advance(5);
-            Assert.AreEqual(5, position.Offset);
-            Assert.AreEqual(1, position.Line);
-            Assert.AreEqual(6, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(5));
+                Assert.That(position.Line, Is.EqualTo(1));
+                Assert.That(position.Column, Is.EqualTo(6));
+            });
             position = position.Advance(1);
-            Assert.AreEqual(6, position.Offset);
+            Assert.That(position.Offset, Is.EqualTo(6));
             position = position.Advance(1);
-            Assert.AreEqual(7, position.Offset);
-            Assert.AreEqual(2, position.Line);
-            Assert.AreEqual(1, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(7));
+                Assert.That(position.Line, Is.EqualTo(2));
+                Assert.That(position.Column, Is.EqualTo(1));
+            });
 
             position = new Position(new SourceContext("hello\r\nworld"));
             position = position.Advance(9);
-            Assert.AreEqual(9, position.Offset);
-            Assert.AreEqual(2, position.Line);
-            Assert.AreEqual(3, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(9));
+                Assert.That(position.Line, Is.EqualTo(2));
+                Assert.That(position.Column, Is.EqualTo(3));
+            });
         }
 
         [Test]
         public void UnixStyleNewlines()
         {
             Position position = new Position(new SourceContext("hello\nworld"));
-            Assert.AreEqual(0, position.Offset);
-            Assert.AreEqual(1, position.Line);
-            Assert.AreEqual(1, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(0));
+                Assert.That(position.Line, Is.EqualTo(1));
+                Assert.That(position.Column, Is.EqualTo(1));
+            });
             position = position.Advance(5);
-            Assert.AreEqual(5, position.Offset);
-            Assert.AreEqual(1, position.Line);
-            Assert.AreEqual(6, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(5));
+                Assert.That(position.Line, Is.EqualTo(1));
+                Assert.That(position.Column, Is.EqualTo(6));
+            });
             position = position.Advance(1);
-            Assert.AreEqual(6, position.Offset);
-            Assert.AreEqual(2, position.Line);
-            Assert.AreEqual(1, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(6));
+                Assert.That(position.Line, Is.EqualTo(2));
+                Assert.That(position.Column, Is.EqualTo(1));
+            });
             position = position.Advance(1);
-            Assert.AreEqual(7, position.Offset);
-            Assert.AreEqual(2, position.Line);
-            Assert.AreEqual(2, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(7));
+                Assert.That(position.Line, Is.EqualTo(2));
+                Assert.That(position.Column, Is.EqualTo(2));
+            });
 
             position = new Position(new SourceContext("hello\nworld"));
             position = position.Advance(9);
-            Assert.AreEqual(9, position.Offset);
-            Assert.AreEqual(2, position.Line);
-            Assert.AreEqual(4, position.Column);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Offset, Is.EqualTo(9));
+                Assert.That(position.Line, Is.EqualTo(2));
+                Assert.That(position.Column, Is.EqualTo(4));
+            });
         }
 
         [Test]
         public void PeekReturnsText()
         {
             Position position = new Position(new SourceContext("hello\r\nworld"));
-            Assert.AreEqual("hello", position.Peek(5));
+            Assert.That(position.Peek(5), Is.EqualTo("hello"));
             position = position.Advance(7);
-            Assert.AreEqual("w", position.Peek(1));
-            Assert.AreEqual("world", position.Peek(5));
-            Assert.AreEqual('w', position.Peek());
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.Peek(1), Is.EqualTo("w"));
+                Assert.That(position.Peek(5), Is.EqualTo("world"));
+                Assert.That(position.Peek(), Is.EqualTo('w'));
+            });
         }
 
         [Test]
         public void FourSpaceTabs()
         {
             Position position = new Position(new SourceContext("\t\tx"));
-            Assert.AreEqual(1, position.Column);
+            Assert.That(position.Column, Is.EqualTo(1));
             position = position.Advance(1);
-            Assert.AreEqual(5, position.Column);
+            Assert.That(position.Column, Is.EqualTo(5));
             position = position.Advance(1);
-            Assert.AreEqual(9, position.Column);
+            Assert.That(position.Column, Is.EqualTo(9));
 
             position = new Position(new SourceContext("\t   \t \tx"));
-            Assert.AreEqual(1, position.Column);
+            Assert.That(position.Column, Is.EqualTo(1));
             position = position.Advance(1);
-            Assert.AreEqual(5, position.Column);
+            Assert.That(position.Column, Is.EqualTo(5));
             position = position.Advance(1);
-            Assert.AreEqual(6, position.Column);
+            Assert.That(position.Column, Is.EqualTo(6));
             position = position.Advance(1);
-            Assert.AreEqual(7, position.Column);
+            Assert.That(position.Column, Is.EqualTo(7));
             position = position.Advance(1);
-            Assert.AreEqual(8, position.Column);
+            Assert.That(position.Column, Is.EqualTo(8));
             position = position.Advance(1);
-            Assert.AreEqual(9, position.Column);
+            Assert.That(position.Column, Is.EqualTo(9));
             position = position.Advance(1);
-            Assert.AreEqual(10, position.Column);
+            Assert.That(position.Column, Is.EqualTo(10));
             position = position.Advance(1);
-            Assert.AreEqual(13, position.Column);
+            Assert.That(position.Column, Is.EqualTo(13));
         }
 
         [Test]
         public void PotentialLengths()
         {
             Position position = new Position(new SourceContext("hello world"));
-            Assert.AreEqual(11, position.PotentialLength());
-            Assert.AreEqual(6, position.PotentialLength('w'));
-            Assert.AreEqual(2, position.PotentialLength('l'));
-            Assert.AreEqual(0, position.PotentialLength('h'));
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.PotentialLength(), Is.EqualTo(11));
+                Assert.That(position.PotentialLength('w'), Is.EqualTo(6));
+                Assert.That(position.PotentialLength('l'), Is.EqualTo(2));
+                Assert.That(position.PotentialLength('h'), Is.EqualTo(0));
+            });
             position = position.Advance(4);
-            Assert.AreEqual(7, position.PotentialLength());
-            Assert.AreEqual(2, position.PotentialLength('w'));
-            Assert.AreEqual(5, position.PotentialLength('l'));
-            Assert.AreEqual(0, position.PotentialLength('o'));
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.PotentialLength(), Is.EqualTo(7));
+                Assert.That(position.PotentialLength('w'), Is.EqualTo(2));
+                Assert.That(position.PotentialLength('l'), Is.EqualTo(5));
+                Assert.That(position.PotentialLength('o'), Is.EqualTo(0));
+            });
             position = position.Advance(7);
-            Assert.AreEqual(0, position.PotentialLength());
-            Assert.AreEqual(0, position.PotentialLength('w'));
-            Assert.AreEqual(0, position.PotentialLength('l'));
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.PotentialLength(), Is.EqualTo(0));
+                Assert.That(position.PotentialLength('w'), Is.EqualTo(0));
+                Assert.That(position.PotentialLength('l'), Is.EqualTo(0));
+            });
         }
 
         [Test]
         public void PotentialLengthMultiChar()
         {
             Position position = new Position(new SourceContext("hello world"));
-            Assert.AreEqual(11, position.PotentialLength());
-            Assert.AreEqual(0, position.PotentialLength('h', 'w', 'l'));
-            Assert.AreEqual(0, position.PotentialLength('l', 'w', 'h'));
-            Assert.AreEqual(11, position.PotentialLength('i', 'f'));
-            Assert.AreEqual(4, position.PotentialLength('b', 'o', 'o'));
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.PotentialLength(), Is.EqualTo(11));
+                Assert.That(position.PotentialLength('h', 'w', 'l'), Is.EqualTo(0));
+                Assert.That(position.PotentialLength('l', 'w', 'h'), Is.EqualTo(0));
+                Assert.That(position.PotentialLength('i', 'f'), Is.EqualTo(11));
+                Assert.That(position.PotentialLength('b', 'o', 'o'), Is.EqualTo(4));
+            });
             position = position.Advance(2);
-            Assert.AreEqual(0, position.PotentialLength('h', 'w', 'l'));
-            Assert.AreEqual(0, position.PotentialLength('l', 'w', 'h'));
-            Assert.AreEqual(9, position.PotentialLength('i', 'f'));
-            Assert.AreEqual(2, position.PotentialLength('b', 'o', 'o'));
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.PotentialLength('h', 'w', 'l'), Is.EqualTo(0));
+                Assert.That(position.PotentialLength('l', 'w', 'h'), Is.EqualTo(0));
+                Assert.That(position.PotentialLength('i', 'f'), Is.EqualTo(9));
+                Assert.That(position.PotentialLength('b', 'o', 'o'), Is.EqualTo(2));
+            });
         }
 
         [Test]
@@ -174,7 +228,7 @@ public void DefaultEndOfSourceCharacter()
         {
             var position = new Position(new SourceContext("hello world"));
             var pos2 = position.Advance(11);
-            Assert.AreEqual(default(char), pos2.Peek());
+            Assert.That(pos2.Peek(), Is.EqualTo(default(char)));
         }
 
         [Test]
@@ -184,29 +238,41 @@ public void PotentialLengthConstrained()
             var begin = position.Advance(4);
             var end = begin.Advance(3);
             var range = begin.Constrain(end);
-            Assert.AreEqual(3, range.PotentialLength());
-            Assert.AreEqual("o w", range.Peek(3));
+            Assert.Multiple(() =>
+            {
+                Assert.That(range.PotentialLength(), Is.EqualTo(3));
+                Assert.That(range.Peek(3), Is.EqualTo("o w"));
+            });
             var done = range.Advance(3);
-            Assert.AreEqual(default(char), done.Peek());
+            Assert.That(done.Peek(), Is.EqualTo(default(char)));
         }
 
         [Test]
         public void PeekTestChecksNextCharacters()
         {
             var position = new Position(new SourceContext("hello world"));
-            Assert.That(position.PeekTest("hello"), Is.True);
-            Assert.That(position.PeekTest("hello world"), Is.True);
-            Assert.That(position.PeekTest("hello world!"), Is.False);
-            Assert.That(position.PeekTest("Hello"), Is.False);
-            Assert.That(position.PeekTest(""), Is.True);
+            Assert.Multiple(() =>
+            {
+                Assert.That(position.PeekTest("hello"), Is.True);
+                Assert.That(position.PeekTest("hello world"), Is.True);
+                Assert.That(position.PeekTest("hello world!"), Is.False);
+                Assert.That(position.PeekTest("Hello"), Is.False);
+                Assert.That(position.PeekTest(""), Is.True);
+            });
             var more = position.Advance(4);
-            Assert.That(more.PeekTest("hello"), Is.False);
-            Assert.That(more.PeekTest("o"), Is.True);
-            Assert.That(more.PeekTest("o world"), Is.True);
-            Assert.That(more.PeekTest("o world!"), Is.False);
+            Assert.Multiple(() =>
+            {
+                Assert.That(more.PeekTest("hello"), Is.False);
+                Assert.That(more.PeekTest("o"), Is.True);
+                Assert.That(more.PeekTest("o world"), Is.True);
+                Assert.That(more.PeekTest("o world!"), Is.False);
+            });
             var tail = more.Advance(7);
-            Assert.That(tail.PeekTest(""), Is.True);
-            Assert.That(tail.PeekTest("d"), Is.False);
+            Assert.Multiple(() =>
+            {
+                Assert.That(tail.PeekTest(""), Is.True);
+                Assert.That(tail.PeekTest("d"), Is.False);
+            });
 
         }
     }
diff --git a/src/Spark.Tests/Parser/TypeInspectorTester.cs b/src/Spark.Tests/Parser/TypeInspectorTester.cs
index 3c166815..a08925a6 100644
--- a/src/Spark.Tests/Parser/TypeInspectorTester.cs
+++ b/src/Spark.Tests/Parser/TypeInspectorTester.cs
@@ -28,32 +28,44 @@ public class TypeInspectorTester
         public void SimpleFields()
         {
             var result = new TypeInspector("string");
-            Assert.AreEqual("string", (string)result.Type);
-            Assert.IsNull(result.Name);
+            Assert.Multiple(() =>
+            {
+                Assert.That((string)result.Type, Is.EqualTo("string"));
+                Assert.That(result.Name, Is.Null);
+            });
         }
 
         [Test]
         public void Generics()
         {
             var result = new TypeInspector("IList<something>");
-            Assert.AreEqual("IList<something>", (string)result.Type);
-            Assert.IsNull(result.Name);
+            Assert.Multiple(() =>
+            {
+                Assert.That((string)result.Type, Is.EqualTo("IList<something>"));
+                Assert.That(result.Name, Is.Null);
+            });
         }
 
         [Test]
         public void GenericsWithName()
         {
             var result = new TypeInspector("IList<something>\r\n\tSomethingList");
-            Assert.AreEqual("IList<something>", (string)result.Type);
-            Assert.AreEqual("SomethingList", (string)result.Name);
+            Assert.Multiple(() =>
+            {
+                Assert.That((string)result.Type, Is.EqualTo("IList<something>"));
+                Assert.That((string)result.Name, Is.EqualTo("SomethingList"));
+            });
         }
 
         [Test]
         public void GenericWithSpacesButNoName()
         {
             var result = new TypeInspector("IList<something, int>");
-            Assert.AreEqual("IList<something, int>", (string)result.Type);
-            Assert.IsNull(result.Name);
+            Assert.Multiple(() =>
+            {
+                Assert.That((string)result.Type, Is.EqualTo("IList<something, int>"));
+                Assert.That(result.Name, Is.Null);
+            });
         }
     }
 }
diff --git a/src/Spark.Tests/Parser/ViewLoaderTester.cs b/src/Spark.Tests/Parser/ViewLoaderTester.cs
index f0445afd..6d45e861 100644
--- a/src/Spark.Tests/Parser/ViewLoaderTester.cs
+++ b/src/Spark.Tests/Parser/ViewLoaderTester.cs
@@ -47,7 +47,7 @@ public void Init()
             viewFolder.Stub(x => x.ListViews(Arg<string>.Is.Anything)).IgnoreArguments().Return(Array.Empty<string>());
 
             syntaxProvider = MockRepository.GenerateMock<ISparkSyntaxProvider>();
-            
+
             var settings = new SparkSettings();
 
             var partialProvider = new DefaultPartialProvider();
@@ -93,8 +93,11 @@ public void LoadSimpleFile()
             viewFolder.VerifyAllExpectations();
             syntaxProvider.VerifyAllExpectations();
 
-            Assert.AreEqual(1, chunks.Count());
-            Assert.AreEqual(1, loader.GetEverythingLoaded().Count());
+            Assert.Multiple(() =>
+            {
+                Assert.That(chunks.Count(), Is.EqualTo(1));
+                Assert.That(loader.GetEverythingLoaded().Count(), Is.EqualTo(1));
+            });
         }
 
         [Test]
@@ -112,7 +115,7 @@ public void LoadUseFile()
             viewFolder.VerifyAllExpectations();
             syntaxProvider.AssertWasCalled(call => call.GetChunks(Arg<VisitorContext>.Is.Anything, Arg<string>.Is.Anything), options => options.Repeat.Times(2));
 
-            Assert.AreEqual(2, loader.GetEverythingLoaded().Count());
+            Assert.That(loader.GetEverythingLoaded().Count(), Is.EqualTo(2));
         }
 
         [Test]
@@ -140,14 +143,20 @@ public void FindPartialFiles()
             viewFolder.VerifyAllExpectations();
             syntaxProvider.VerifyAllExpectations();
 
-            Assert.AreEqual(3, partials3.Count);
-            Assert.That(partials3.Contains("comment"));
-            Assert.That(partials3.Contains("header"));
-            Assert.That(partials3.Contains("footer"));
+            Assert.That(partials3, Has.Count.EqualTo(3));
+            Assert.Multiple(() =>
+            {
+                Assert.That(partials3.Contains("comment"));
+                Assert.That(partials3.Contains("header"));
+                Assert.That(partials3.Contains("footer"));
 
-            Assert.AreEqual(2, partials2.Count);
-            Assert.That(partials2.Contains("header"));
-            Assert.That(partials2.Contains("footer"));
+                Assert.That(partials2, Has.Count.EqualTo(2));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(partials2.Contains("header"));
+                Assert.That(partials2.Contains("footer"));
+            });
         }
 
         [Test]
@@ -211,9 +220,9 @@ public void BindingProviderIsCalledUsingTheCorrectBindingRequest()
             var settings = new SparkSettings();
 
             var partialProvider = new DefaultPartialProvider();
-            
+
             var viewLoader = new ViewLoader(settings, folder, partialProvider, new DefaultPartialReferenceProvider(partialProvider), null, syntaxProvider, bindingProvider);
-            
+
             viewLoader.Load(viewPath);
 
             bindingProvider.VerifyAllExpectations();
@@ -274,11 +283,10 @@ public void LoadingPartialInsideNamedSection()
                 null,
                 new DefaultSyntaxProvider(ParserSettings.DefaultBehavior),
                 null);
-
-            var chunks = viewLoader.Load(Path.Combine("home", "index.spark"));
+            _ = viewLoader.Load(Path.Combine("home", "index.spark"));
             var everything = viewLoader.GetEverythingLoaded();
-            
-            Assert.AreEqual(3, everything.Count());
+
+            Assert.That(everything.Count(), Is.EqualTo(3));
         }
 
         [Test]
@@ -311,11 +319,14 @@ public void PartialsInSameFolderAreDiscovered()
             var product = viewLoader.FindPartialFiles(Path.Combine("product", "two.spark"));
             var invoice = viewLoader.FindPartialFiles(Path.Combine("invoice", "five.spark"));
 
-            Assert.That(zero.Count(), Is.EqualTo(1));
-            Assert.That(zero, Has.Some.EqualTo("one"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(zero.Count(), Is.EqualTo(1));
+                Assert.That(zero, Has.Some.EqualTo("one"));
 
-            Assert.That(product.Count(), Is.EqualTo(2));
-            Assert.That(product, Has.Some.EqualTo("three"));
+                Assert.That(product.Count(), Is.EqualTo(2));
+                Assert.That(product, Has.Some.EqualTo("three"));
+            });
             Assert.That(product, Has.Some.EqualTo("four"));
 
             Assert.That(invoice.Count(), Is.EqualTo(0));
@@ -329,9 +340,12 @@ public void PartialsInSameFolderAreDiscovered()
 
             Assert.That(product.Count(), Is.EqualTo(2));
             Assert.That(product, Has.Some.EqualTo("three"));
-            Assert.That(product, Has.Some.EqualTo("four"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(product, Has.Some.EqualTo("four"));
 
-            Assert.That(invoice.Count(), Is.EqualTo(0));
+                Assert.That(invoice.Count(), Is.EqualTo(0));
+            });
         }
 
         [Test]
@@ -364,7 +378,7 @@ public void PartialsInCascadingBaseFoldersAndSharedFoldersAreDiscovered()
                 new DefaultSyntaxProvider(ParserSettings.DefaultBehavior),
                 null);
 
-            var partials = viewLoader.FindPartialFiles(Path.Combine("area1","controller2","view3.spark"));
+            var partials = viewLoader.FindPartialFiles(Path.Combine("area1", "controller2", "view3.spark"));
 
             Assert.That(partials, Has.Some.EqualTo("alpha"));
             Assert.That(partials, Has.Some.EqualTo("beta"));
@@ -397,11 +411,10 @@ public void LoadingEmptyFile()
                 null,
                 new DefaultSyntaxProvider(ParserSettings.DefaultBehavior),
                 null);
-
-            var chunks = viewLoader.Load(Path.Combine("home", "empty.spark"));
+            _ = viewLoader.Load(Path.Combine("home", "empty.spark"));
             var everything = viewLoader.GetEverythingLoaded();
 
-            Assert.AreEqual(1, everything.Count());
+            Assert.That(everything.Count(), Is.EqualTo(1));
         }
 
         [Test]
@@ -411,7 +424,7 @@ public void LoadingEmptyShadeFile()
             {
                 { Path.Combine("home", "empty.shade"), "" },
             };
-            
+
             var settings = new SparkSettings();
 
             var partialProvider = new DefaultPartialProvider();
@@ -424,11 +437,10 @@ public void LoadingEmptyShadeFile()
                 null,
                 new DefaultSyntaxProvider(ParserSettings.DefaultBehavior),
                 null);
-
-            var chunks = viewLoader.Load(Path.Combine("home", "empty.shade"));
+            _ = viewLoader.Load(Path.Combine("home", "empty.shade"));
             var everything = viewLoader.GetEverythingLoaded();
-            
-            Assert.AreEqual(1, everything.Count());
+
+            Assert.That(everything.Count(), Is.EqualTo(1));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Tests/Spark.Tests.csproj b/src/Spark.Tests/Spark.Tests.csproj
index 045b38d3..83adc495 100644
--- a/src/Spark.Tests/Spark.Tests.csproj
+++ b/src/Spark.Tests/Spark.Tests.csproj
@@ -15,9 +15,13 @@
     <Reference Include="System.Web" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-	<PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="NUnit" Version="4.2.2" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+	<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
 	<PackageReference Include="Shouldly" Version="4.2.1" />
 	<PackageReference Include="RhinoMocks" Version="3.6.1" />
   </ItemGroup>
diff --git a/src/Spark.Tests/Spool/SpoolPageTester.cs b/src/Spark.Tests/Spool/SpoolPageTester.cs
index 691e4c50..4bbe2270 100644
--- a/src/Spark.Tests/Spool/SpoolPageTester.cs
+++ b/src/Spark.Tests/Spool/SpoolPageTester.cs
@@ -25,9 +25,12 @@ public void Appending()
         {
             var page = new SpoolPage();
             page.Append("hello");
-            Assert.IsNull(page.Next);
-            Assert.AreEqual(1, page.Count);
-            Assert.AreEqual("hello", page.Buffer[0]);
+            Assert.Multiple(() =>
+            {
+                Assert.That(page.Next, Is.Null);
+                Assert.That(page.Count, Is.EqualTo(1));
+            });
+            Assert.That(page.Buffer[0], Is.EqualTo("hello"));
         }
 
         [Test]
@@ -36,10 +39,16 @@ public void AppendMultiple()
             var page = new SpoolPage();
             page.Append("hello");
             page.Append("world");
-            Assert.IsNull(page.Next);
-            Assert.AreEqual(2, page.Count);
-            Assert.AreEqual("hello", page.Buffer[0]);
-            Assert.AreEqual("world", page.Buffer[1]);
+            Assert.Multiple(() =>
+            {
+                Assert.That(page.Next, Is.Null);
+                Assert.That(page.Count, Is.EqualTo(2));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(page.Buffer[0], Is.EqualTo("hello"));
+                Assert.That(page.Buffer[1], Is.EqualTo("world"));
+            });
         }
 
         [Test]
@@ -51,10 +60,14 @@ public void AppendOverBoundary()
             {
                 last = last.Append(index.ToString());
             }
-            Assert.AreNotSame(page, last);
-            Assert.AreEqual(SpoolPage.BUFFER_SIZE, page.Count);
-            Assert.AreEqual(30, last.Count);
-            Assert.AreEqual(SpoolPage.BUFFER_SIZE.ToString(), last.Buffer[0]);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(last, Is.Not.SameAs(page));
+                Assert.That(page.Count, Is.EqualTo(SpoolPage.BUFFER_SIZE));
+            });
+            Assert.That(last.Count, Is.EqualTo(30));
+            Assert.That(last.Buffer[0], Is.EqualTo(SpoolPage.BUFFER_SIZE.ToString()));
         }
 
         [Test]
@@ -75,10 +88,13 @@ public void CallsReleaseOnNextOnlyIfIsNotReleasedAlready()
 
             first.Release();
 
-            Assert.AreEqual(3, second.Count);
-            Assert.AreEqual("1", second.Buffer[0]);
-            Assert.AreEqual("2", second.Buffer[1]);
-            Assert.AreEqual("3", second.Buffer[2]);
+            Assert.That(second.Count, Is.EqualTo(3));
+            Assert.Multiple(() =>
+            {
+                Assert.That(second.Buffer[0], Is.EqualTo("1"));
+                Assert.That(second.Buffer[1], Is.EqualTo("2"));
+                Assert.That(second.Buffer[2], Is.EqualTo("3"));
+            });
         }
 
     }
diff --git a/src/Spark.Tests/Spool/SpoolReaderTester.cs b/src/Spark.Tests/Spool/SpoolReaderTester.cs
index 5ebea81d..6200ac8e 100644
--- a/src/Spark.Tests/Spool/SpoolReaderTester.cs
+++ b/src/Spark.Tests/Spool/SpoolReaderTester.cs
@@ -18,8 +18,11 @@ public void StringReader_and_SpoolReader_should_return_minus_one_if_empty()
             var reader1 = new StringReader("");
             var reader2 = new SpoolReader(new SpoolWriter());
 
-            Assert.That(reader1.Peek(), Is.EqualTo(-1));
-            Assert.That(reader2.Peek(), Is.EqualTo(-1));
+            Assert.Multiple(() =>
+            {
+                Assert.That(reader1.Peek(), Is.EqualTo(-1));
+                Assert.That(reader2.Peek(), Is.EqualTo(-1));
+            });
         }
 
         [Test]
@@ -56,8 +59,11 @@ public void Peek_and_read_return_characters_and_advance_appropriately()
             writer.Write("c");
 
             var reader = new SpoolReader(writer);
-            Assert.That(reader.Peek(), Is.EqualTo((int)'a'));
-            Assert.That(reader.Read(), Is.EqualTo((int)'a'));
+            Assert.Multiple(() =>
+            {
+                Assert.That(reader.Peek(), Is.EqualTo((int)'a'));
+                Assert.That(reader.Read(), Is.EqualTo((int)'a'));
+            });
             Assert.That(reader.Peek(), Is.EqualTo((int)'b'));
             Assert.That(reader.Read(), Is.EqualTo((int)'b'));
             Assert.That(reader.Peek(), Is.EqualTo((int)'c'));
@@ -65,7 +71,7 @@ public void Peek_and_read_return_characters_and_advance_appropriately()
             Assert.That(reader.Peek(), Is.EqualTo(-1));
             Assert.That(reader.Read(), Is.EqualTo(-1));
         }
-        
+
         [Test]
         public void Empty_and_null_writes_are_acceptable()
         {
diff --git a/src/Spark.Tests/Spool/SpoolWriterTester.cs b/src/Spark.Tests/Spool/SpoolWriterTester.cs
index 8f2ee7a8..1f3b9457 100644
--- a/src/Spark.Tests/Spool/SpoolWriterTester.cs
+++ b/src/Spark.Tests/Spool/SpoolWriterTester.cs
@@ -52,14 +52,14 @@ public void Init()
             GC.WaitForPendingFinalizers();
             _cache.Clear();
         }
-        
+
         [Test]
         public void ToStringCombinesResults()
         {
             TextWriter writer = new SpoolWriter();
             writer.Write("hello");
             writer.Write("world");
-            Assert.AreEqual("helloworld", writer.ToString());
+            Assert.That(writer.ToString(), Is.EqualTo("helloworld"));
         }
 
         [Test]
@@ -70,7 +70,7 @@ public void MultiplePagesCombinedResult()
             {
                 writer.Write(index);
             }
-            Assert.AreEqual(_FiveThousandNumbers, writer.ToString());
+            Assert.That(writer.ToString(), Is.EqualTo(_FiveThousandNumbers));
         }
 
         [Test]
@@ -85,7 +85,7 @@ public void StringWriterToSpoolWriter()
             writer2.Write("before");
             writer1.WriteTo(writer2);
             writer2.Write("after");
-            Assert.AreEqual("before" + _FiveThousandNumbers + "after", writer2.ToString());
+            Assert.That(writer2.ToString(), Is.EqualTo("before" + _FiveThousandNumbers + "after"));
         }
 
         [Test]
@@ -100,7 +100,7 @@ public void SpoolWriterToStringWriter()
             writer2.Write("before");
             writer1.WriteTo(writer2);
             writer2.Write("after");
-            Assert.AreEqual("before" + _FiveThousandNumbers + "after", writer2.ToString());
+            Assert.That(writer2.ToString(), Is.EqualTo("before" + _FiveThousandNumbers + "after"));
         }
 
         [Test]
@@ -115,7 +115,7 @@ public void SpoolWriterToSpoolWriter()
             writer2.Write("before");
             writer1.WriteTo(writer2);
             writer2.Write("after");
-            Assert.AreEqual("before" + _FiveThousandNumbers + "after", writer2.ToString());
+            Assert.That(writer2.ToString(), Is.EqualTo("before" + _FiveThousandNumbers + "after"));
         }
 
         [Test]
@@ -134,8 +134,11 @@ public void AppendingOwnsBuffer()
 
             writer1.Write("world");
 
-            Assert.AreEqual("helloworld", writer1.ToString());
-            Assert.AreEqual("beforehelloafter", writer2.ToString());
+            Assert.Multiple(() =>
+            {
+                Assert.That(writer1.ToString(), Is.EqualTo("helloworld"));
+                Assert.That(writer2.ToString(), Is.EqualTo("beforehelloafter"));
+            });
 
             var _first = typeof(SpoolWriter).GetField("_first", BindingFlags.NonPublic | BindingFlags.Instance);
             var _readonly = typeof(SpoolPage).GetField("_readonly", BindingFlags.NonPublic | BindingFlags.Instance);
@@ -144,24 +147,24 @@ public void AppendingOwnsBuffer()
             var pages1 = (SpoolPage)_first.GetValue(writer1);
             var pages2 = (SpoolPage)_first.GetValue(writer2);
 
-            Assert.IsTrue((bool)_readonly.GetValue(pages1));
-            Assert.IsTrue((bool)_nonreusable.GetValue(pages1));
+            Assert.That((bool)_readonly.GetValue(pages1), Is.True);
+            Assert.That((bool)_nonreusable.GetValue(pages1), Is.True);
 
-            Assert.IsFalse((bool)_readonly.GetValue(pages1.Next));
-            Assert.IsFalse((bool)_nonreusable.GetValue(pages1.Next));
-            Assert.IsNull(pages1.Next.Next);
+            Assert.That((bool)_readonly.GetValue(pages1.Next), Is.False);
+            Assert.That((bool)_nonreusable.GetValue(pages1.Next), Is.False);
+            Assert.That(pages1.Next.Next, Is.Null);
 
 
-            Assert.IsTrue((bool)_readonly.GetValue(pages2));
-            Assert.IsFalse((bool)_nonreusable.GetValue(pages2));
+            Assert.That((bool)_readonly.GetValue(pages2), Is.True);
+            Assert.That((bool)_nonreusable.GetValue(pages2), Is.False);
 
-            Assert.IsTrue((bool)_readonly.GetValue(pages2.Next));
-            Assert.IsTrue((bool)_nonreusable.GetValue(pages2.Next));
+            Assert.That((bool)_readonly.GetValue(pages2.Next), Is.True);
+            Assert.That((bool)_nonreusable.GetValue(pages2.Next), Is.True);
 
-            Assert.IsFalse((bool)_readonly.GetValue(pages2.Next.Next));
-            Assert.IsFalse((bool)_nonreusable.GetValue(pages2.Next.Next));
+            Assert.That((bool)_readonly.GetValue(pages2.Next.Next), Is.False);
+            Assert.That((bool)_nonreusable.GetValue(pages2.Next.Next), Is.False);
 
-            Assert.IsNull(pages2.Next.Next.Next);
+            Assert.That(pages2.Next.Next.Next, Is.Null);
 
             var countBeforeCollect = _cache.Count;
             // ReSharper disable RedundantAssignment
@@ -172,9 +175,12 @@ public void AppendingOwnsBuffer()
             GC.WaitForPendingFinalizers();
             var countAfterCollect = _cache.Count;
 
-            Assert.AreEqual(0, countBefore);
-            Assert.AreEqual(0, countBeforeCollect);
-            Assert.AreEqual(3, countAfterCollect);
+            Assert.Multiple(() =>
+            {
+                Assert.That(countBefore, Is.EqualTo(0));
+                Assert.That(countBeforeCollect, Is.EqualTo(0));
+                Assert.That(countAfterCollect, Is.EqualTo(3));
+            });
         }
 
         [Test]
@@ -184,7 +190,7 @@ public void WritingCharacters()
             writer.Write('a');
             writer.Write(new[] { 'b', 'c', 'd' });
             writer.Write(new[] { 'x', 'e', 'f', 'g', 'x' }, 1, 3);
-            Assert.AreEqual("abcdefg", writer.ToString());
+            Assert.That(writer.ToString(), Is.EqualTo("abcdefg"));
         }
 
         [Test]
@@ -207,11 +213,14 @@ public void DisposingWriter()
 
             var countAfter = _cache.Count;
 
-            Assert.AreEqual(0, countBefore);
-            Assert.AreEqual(1, countBetween);
-            Assert.AreEqual(1, countAfter);
+            Assert.Multiple(() =>
+            {
+                Assert.That(countBefore, Is.EqualTo(0));
+                Assert.That(countBetween, Is.EqualTo(1));
+                Assert.That(countAfter, Is.EqualTo(1));
+            });
         }
-        
+
         [Test]
         public void EncodingShouldBeUtf8ByDefault()
         {
@@ -228,11 +237,11 @@ public void EncodingShouldBeUtf8ByDefault()
         public void ToStringWhenCodingIsDifferentFromUtf8()
         {
             TextWriter writer = new SpoolWriter();
-            
+
             // The accentuated char and unicode emoji shouldn't matter as the SpoolPage just keeps track of the bytes
             writer.Write("hèllo 🌍");
-            
-            Assert.AreEqual("hèllo 🌍", writer.ToString());
+
+            Assert.That(writer.ToString(), Is.EqualTo("hèllo 🌍"));
         }
     }
 }
diff --git a/src/Spark.Tests/Stubs/StubViewContext.cs b/src/Spark.Tests/Stubs/StubViewContext.cs
index 7075db01..2c1e7cc8 100644
--- a/src/Spark.Tests/Stubs/StubViewContext.cs
+++ b/src/Spark.Tests/Stubs/StubViewContext.cs
@@ -17,14 +17,14 @@
 
 namespace Spark.Tests.Stubs
 {
-	public class StubViewContext
-	{
-		public string ControllerName { get; set; }
-		public string ViewName { get; set; }
-		public string MasterName { get; set; }
+    public class StubViewContext
+    {
+        public string ControllerName { get; set; }
+        public string ViewName { get; set; }
+        public string MasterName { get; set; }
 
         public StubViewData Data { get; set; }
-        
+
         public StringBuilder Output { get; set; }
-	}
+    }
 }
\ No newline at end of file
diff --git a/src/Spark.Tests/Stubs/StubViewData.cs b/src/Spark.Tests/Stubs/StubViewData.cs
index e52718b3..925dbe3a 100644
--- a/src/Spark.Tests/Stubs/StubViewData.cs
+++ b/src/Spark.Tests/Stubs/StubViewData.cs
@@ -20,8 +20,7 @@ public class StubViewData : Dictionary<string, object>
     {
         public object Eval(string key)
         {
-            object value;
-            return TryGetValue(key, out value) ? value : null;
+            return TryGetValue(key, out object value) ? value : null;
         }
     }
 
diff --git a/src/Spark.Tests/ValueHolderTester.cs b/src/Spark.Tests/ValueHolderTester.cs
index 90e9b620..0159832c 100644
--- a/src/Spark.Tests/ValueHolderTester.cs
+++ b/src/Spark.Tests/ValueHolderTester.cs
@@ -20,10 +20,16 @@ public void AcquireMethodShouldBeCalledOnlyOnce()
                                                  return "hello";
                                              });
 
-            Assert.That(calls, Is.EqualTo(0));
-            Assert.That(holder.Value, Is.EqualTo("hello"));
-            Assert.That(holder.Value, Is.EqualTo("hello"));
-            Assert.That(calls, Is.EqualTo(1));
+            Assert.Multiple(() =>
+            {
+                Assert.That(calls, Is.EqualTo(0));
+                Assert.That(holder.Value, Is.EqualTo("hello"));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(holder.Value, Is.EqualTo("hello"));
+                Assert.That(calls, Is.EqualTo(1));
+            });
         }
 
         [Test]
@@ -36,10 +42,16 @@ public void KeyPassesThrough()
                                                           return new string(k.Reverse().ToArray());
                                                       });
 
-            Assert.That(calls, Is.EqualTo(0));
-            Assert.That(holder.Value, Is.EqualTo("olleh"));
-            Assert.That(holder.Value, Is.EqualTo("olleh"));
-            Assert.That(calls, Is.EqualTo(1));
+            Assert.Multiple(() =>
+            {
+                Assert.That(calls, Is.EqualTo(0));
+                Assert.That(holder.Value, Is.EqualTo("olleh"));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(holder.Value, Is.EqualTo("olleh"));
+                Assert.That(calls, Is.EqualTo(1));
+            });
         }
     }
 }
diff --git a/src/Spark.Tests/Visitors/BaseVisitorTester.cs b/src/Spark.Tests/Visitors/BaseVisitorTester.cs
index 9839f848..2e2708bd 100644
--- a/src/Spark.Tests/Visitors/BaseVisitorTester.cs
+++ b/src/Spark.Tests/Visitors/BaseVisitorTester.cs
@@ -24,16 +24,16 @@ namespace Spark.Tests.Visitors
 {
     public class BaseVisitorTester
     {
-        MarkupGrammar _grammar = new MarkupGrammar();
+        readonly MarkupGrammar _grammar = new MarkupGrammar();
         protected IEnumerable<Paint> _paint;
-        
+
 
         public IList<Node> ParseNodes(string content, params AbstractNodeVisitor[] visitors)
         {
             var result = _grammar.Nodes(new Position(new SourceContext(content)));
             _paint = result.Rest.GetPaint();
             var nodes = result.Value;
-            foreach(var visitor in visitors)
+            foreach (var visitor in visitors)
             {
                 visitor.Accept(nodes);
                 nodes = visitor.Nodes;
diff --git a/src/Spark.Tests/Visitors/ChunkBuilderVisitorTester.cs b/src/Spark.Tests/Visitors/ChunkBuilderVisitorTester.cs
index 0870c7b3..7c7a0543 100644
--- a/src/Spark.Tests/Visitors/ChunkBuilderVisitorTester.cs
+++ b/src/Spark.Tests/Visitors/ChunkBuilderVisitorTester.cs
@@ -38,8 +38,11 @@ public void MakeLiteralChunk()
                                    new TextNode("world".ToArray()),
                                    new EndElementNode("span")
                                });
-            Assert.AreEqual(1, visitor.Chunks.Count);
-            Assert.AreEqual("<span>hello&nbsp;world</span>", ((SendLiteralChunk)visitor.Chunks[0]).Text);
+            Assert.Multiple(() =>
+            {
+                Assert.That(visitor.Chunks, Has.Count.EqualTo(1));
+                Assert.That(((SendLiteralChunk)visitor.Chunks[0]).Text, Is.EqualTo("<span>hello&nbsp;world</span>"));
+            });
         }
 
         [Test]
@@ -52,8 +55,11 @@ public void SelfClosingElementWithAttributes()
                                                  }, true);
             var visitor = new ChunkBuilderVisitor(new VisitorContext());
             visitor.Accept(elt);
-            Assert.AreEqual(1, visitor.Chunks.Count);
-            Assert.AreEqual("<img href=\"urn:picture\" alt=\"A Picture&amp;\"/>", ((SendLiteralChunk)visitor.Chunks[0]).Text);
+            Assert.Multiple(() =>
+            {
+                Assert.That(visitor.Chunks, Has.Count.EqualTo(1));
+                Assert.That(((SendLiteralChunk)visitor.Chunks[0]).Text, Is.EqualTo("<img href=\"urn:picture\" alt=\"A Picture&amp;\"/>"));
+            });
         }
 
         [TestCase("area")]
@@ -77,18 +83,24 @@ public void VoidElementsSelfClose(string tagName)
             var elt = new ElementNode(tagName, new AttributeNode[] { }, true);
             var visitor = new ChunkBuilderVisitor(new VisitorContext());
             visitor.Accept(elt);
-            Assert.AreEqual(1, visitor.Chunks.Count());
-            Assert.AreEqual(string.Format("<{0}/>", tagName), ((SendLiteralChunk)visitor.Chunks[0]).Text);
+            Assert.Multiple(() =>
+            {
+                Assert.That(visitor.Chunks.Count(), Is.EqualTo(1));
+                Assert.That(((SendLiteralChunk)visitor.Chunks[0]).Text, Is.EqualTo(string.Format("<{0}/>", tagName)));
+            });
         }
 
         [Test]
         public void NonVoidElementDoesNotSelfClose()
         {
-            var elt = new ElementNode("span", new AttributeNode[]{ }, true);
+            var elt = new ElementNode("span", new AttributeNode[] { }, true);
             var visitor = new ChunkBuilderVisitor(new VisitorContext());
             visitor.Accept(elt);
-            Assert.AreEqual(1, visitor.Chunks.Count());
-            Assert.AreEqual("<span></span>", ((SendLiteralChunk)visitor.Chunks[0]).Text);
+            Assert.Multiple(() =>
+            {
+                Assert.That(visitor.Chunks.Count(), Is.EqualTo(1));
+                Assert.That(((SendLiteralChunk)visitor.Chunks[0]).Text, Is.EqualTo("<span></span>"));
+            });
         }
 
         [Test]
@@ -100,8 +112,11 @@ public void WritingDocTypes()
 
             var visitor = new ChunkBuilderVisitor(new VisitorContext());
             visitor.Accept(new Node[] { justName, systemName, publicName });
-            Assert.AreEqual(1, visitor.Chunks.Count);
-            Assert.AreEqual("<!DOCTYPE html><!DOCTYPE html2 SYSTEM \"my-'system'-id\"><!DOCTYPE html3 PUBLIC \"my-public-id\" 'my-\"other\"system-id'>", ((SendLiteralChunk)visitor.Chunks[0]).Text);
+            Assert.Multiple(() =>
+            {
+                Assert.That(visitor.Chunks, Has.Count.EqualTo(1));
+                Assert.That(((SendLiteralChunk)visitor.Chunks[0]).Text, Is.EqualTo("<!DOCTYPE html><!DOCTYPE html2 SYSTEM \"my-'system'-id\"><!DOCTYPE html3 PUBLIC \"my-public-id\" 'my-\"other\"system-id'>"));
+            });
         }
 
         [Test]
@@ -113,11 +128,11 @@ public void RenderPartialContainsChunks()
 
             var visitor = new ChunkBuilderVisitor(new VisitorContext());
             visitor.Accept(nodes);
-            Assert.AreEqual(1, visitor.Chunks.Count);
+            Assert.That(visitor.Chunks, Has.Count.EqualTo(1));
             var renderPartial = (RenderPartialChunk)((ScopeChunk)visitor.Chunks[0]).Body[0];
-            Assert.AreEqual(1, renderPartial.Body.Count);
+            Assert.That(renderPartial.Body, Has.Count.EqualTo(1));
             var literal = (SendLiteralChunk)renderPartial.Body[0];
-            Assert.AreEqual("hello", literal.Text);
+            Assert.That(literal.Text, Is.EqualTo("hello"));
         }
 
         [Test]
@@ -130,15 +145,21 @@ public void RenderPartialContainsSegments()
 
             var visitor = new ChunkBuilderVisitor(new VisitorContext());
             visitor.Accept(nodes);
-            Assert.AreEqual(1, visitor.Chunks.Count);
+            Assert.That(visitor.Chunks, Has.Count.EqualTo(1));
             var renderPartial = (RenderPartialChunk)((ScopeChunk)visitor.Chunks[0]).Body[0];
-            Assert.AreEqual(0, renderPartial.Body.Count);
-            Assert.AreEqual(2, renderPartial.Sections.Count);
-            Assert.That(renderPartial.Sections.ContainsKey("one"));
-            Assert.That(renderPartial.Sections.ContainsKey("two"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(renderPartial.Body.Count, Is.EqualTo(0));
+                Assert.That(renderPartial.Sections, Has.Count.EqualTo(2));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(renderPartial.Sections.ContainsKey("one"));
+                Assert.That(renderPartial.Sections.ContainsKey("two"));
+            });
             var scope = (ScopeChunk)renderPartial.Sections["one"][0];
             var literal = (SendLiteralChunk)scope.Body[0];
-            Assert.AreEqual("alpha", literal.Text);
+            Assert.That(literal.Text, Is.EqualTo("alpha"));
         }
 
         [Test]
@@ -146,24 +167,30 @@ public void RenderPartialContainsSectionsAsSegmentsIfAliasedInConfig()
         {
             var nodes = ParseNodes(
                 "<foo><section:two>beta</section:two><section:one>alpha</section:one></foo>",
-                new PrefixExpandingVisitor(new VisitorContext {ParseSectionTagAsSegment = true}),
+                new PrefixExpandingVisitor(new VisitorContext { ParseSectionTagAsSegment = true }),
                 new SpecialNodeVisitor(new VisitorContext
-                                           {
-                                               PartialFileNames = new[] { "foo" },
-                                               ParseSectionTagAsSegment = true
-                                           }));
+                {
+                    PartialFileNames = new[] { "foo" },
+                    ParseSectionTagAsSegment = true
+                }));
 
-            var visitor = new ChunkBuilderVisitor(new VisitorContext {ParseSectionTagAsSegment = true});
+            var visitor = new ChunkBuilderVisitor(new VisitorContext { ParseSectionTagAsSegment = true });
             visitor.Accept(nodes);
-            Assert.AreEqual(1, visitor.Chunks.Count);
+            Assert.That(visitor.Chunks, Has.Count.EqualTo(1));
             var renderPartial = (RenderPartialChunk)((ScopeChunk)visitor.Chunks[0]).Body[0];
-            Assert.AreEqual(0, renderPartial.Body.Count);
-            Assert.AreEqual(2, renderPartial.Sections.Count);
-            Assert.That(renderPartial.Sections.ContainsKey("one"));
-            Assert.That(renderPartial.Sections.ContainsKey("two"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(renderPartial.Body.Count, Is.EqualTo(0));
+                Assert.That(renderPartial.Sections, Has.Count.EqualTo(2));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(renderPartial.Sections.ContainsKey("one"));
+                Assert.That(renderPartial.Sections.ContainsKey("two"));
+            });
             var scope = (ScopeChunk)renderPartial.Sections["one"][0];
             var literal = (SendLiteralChunk)scope.Body[0];
-            Assert.AreEqual("alpha", literal.Text);
+            Assert.That(literal.Text, Is.EqualTo("alpha"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Tests/Visitors/ConditionalAttributeVisitorTester.cs b/src/Spark.Tests/Visitors/ConditionalAttributeVisitorTester.cs
index d09ca3c4..8a7c09c3 100644
--- a/src/Spark.Tests/Visitors/ConditionalAttributeVisitorTester.cs
+++ b/src/Spark.Tests/Visitors/ConditionalAttributeVisitorTester.cs
@@ -31,12 +31,12 @@ public void DetectIfAttribute()
             var visitor = new ConditionalAttributeVisitor(new VisitorContext());
             visitor.Accept(nodes);
 
-            Assert.AreEqual(1, visitor.Nodes.Count);
-            Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[0]);
+            Assert.That(visitor.Nodes, Has.Count.EqualTo(1));
+            Assert.That(visitor.Nodes[0], Is.AssignableFrom(typeof(SpecialNode)));
 
             var ifNode = visitor.Nodes[0] as SpecialNode;
-            Assert.IsNotNull(ifNode);
-            Assert.AreEqual("if", ifNode.Element.Name);
+            Assert.That(ifNode, Is.Not.Null);
+            Assert.That(ifNode.Element.Name, Is.EqualTo("if"));
         }
 
         [Test]
@@ -48,12 +48,12 @@ public void DetectUnlessAttribute()
             var visitor = new ConditionalAttributeVisitor(new VisitorContext());
             visitor.Accept(nodes);
 
-            Assert.AreEqual(1, visitor.Nodes.Count);
-            Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[0]);
+            Assert.That(visitor.Nodes, Has.Count.EqualTo(1));
+            Assert.That(visitor.Nodes[0], Is.AssignableFrom(typeof(SpecialNode)));
 
             var unlessNode = visitor.Nodes[0] as SpecialNode;
-            Assert.IsNotNull(unlessNode);
-            Assert.AreEqual("unless", unlessNode.Element.Name);
+            Assert.That(unlessNode, Is.Not.Null);
+            Assert.That(unlessNode.Element.Name, Is.EqualTo("unless"));
         }
 
         [Test]
@@ -68,19 +68,19 @@ public void ChainConditionalAttribute()
             var visitor = new ConditionalAttributeVisitor(new VisitorContext());
             visitor.Accept(visitor0.Nodes);
 
-            Assert.AreEqual(3, visitor.Nodes.Count);
-            Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[0]);
-            Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[1]);
-            Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[2]);
+            Assert.That(visitor.Nodes, Has.Count.EqualTo(3));
+            Assert.That(visitor.Nodes[0], Is.AssignableFrom(typeof(SpecialNode)));
+            Assert.That(visitor.Nodes[1], Is.AssignableFrom(typeof(SpecialNode)));
+            Assert.That(visitor.Nodes[2], Is.AssignableFrom(typeof(SpecialNode)));
 
             var ifNode = (SpecialNode)visitor.Nodes[0];
-            Assert.AreEqual("if", ifNode.Element.Name);
+            Assert.That(ifNode.Element.Name, Is.EqualTo("if"));
 
             var elseifNode = (SpecialNode)visitor.Nodes[1];
-            Assert.AreEqual("elseif", elseifNode.Element.Name);
+            Assert.That(elseifNode.Element.Name, Is.EqualTo("elseif"));
 
             var elseNode = (SpecialNode)visitor.Nodes[2];
-            Assert.AreEqual("else", elseNode.Element.Name);
+            Assert.That(elseNode.Element.Name, Is.EqualTo("else"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Tests/Visitors/NamespaceVisitorTester.cs b/src/Spark.Tests/Visitors/NamespaceVisitorTester.cs
index 228932c1..51575f81 100644
--- a/src/Spark.Tests/Visitors/NamespaceVisitorTester.cs
+++ b/src/Spark.Tests/Visitors/NamespaceVisitorTester.cs
@@ -32,8 +32,11 @@ public void AssignNamespaceToElement()
             var nodes = ParseNodes("<foo xmlns:x='http://sparkviewengine.com/x'><x:bar/></foo>");
             var visitor = new NamespaceVisitor(new VisitorContext());
             visitor.Accept(nodes);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[0]).Namespace);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[1]).Namespace);
+            Assert.Multiple(() =>
+            {
+                Assert.That(((ElementNode)visitor.Nodes[0]).Namespace, Is.EqualTo(""));
+                Assert.That(((ElementNode)visitor.Nodes[1]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+            });
         }
 
         [Test]
@@ -42,8 +45,11 @@ public void AssignNamespaceWithDefaultPrefix()
             var nodes = ParseNodes("<foo><quux:bar/></foo>");
             var visitor = new NamespaceVisitor(new VisitorContext { Prefix = "quux" });
             visitor.Accept(nodes);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[0]).Namespace);
-            Assert.AreEqual("http://sparkviewengine.com/", ((ElementNode)visitor.Nodes[1]).Namespace);
+            Assert.Multiple(() =>
+            {
+                Assert.That(((ElementNode)visitor.Nodes[0]).Namespace, Is.EqualTo(""));
+                Assert.That(((ElementNode)visitor.Nodes[1]).Namespace, Is.EqualTo("http://sparkviewengine.com/"));
+            });
         }
 
         [Test]
@@ -52,10 +58,13 @@ public void AssignNamespaceToAttributes()
             var nodes = ParseNodes("<foo xmlns:x='http://sparkviewengine.com/x'><bar x:if='false'/></foo>");
             var visitor = new NamespaceVisitor(new VisitorContext());
             visitor.Accept(nodes);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[0]).Namespace);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[1]).Namespace);
+            Assert.Multiple(() =>
+            {
+                Assert.That(((ElementNode)visitor.Nodes[0]).Namespace, Is.EqualTo(""));
+                Assert.That(((ElementNode)visitor.Nodes[1]).Namespace, Is.EqualTo(""));
 
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[1]).Attributes[0].Namespace);
+                Assert.That(((ElementNode)visitor.Nodes[1]).Attributes[0].Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+            });
         }
 
         [Test]
@@ -64,11 +73,14 @@ public void ElementCanUseXmlnsOnSelf()
             var nodes = ParseNodes("<x:foo y:bar='hello' xmlns:x='http://sparkviewengine.com/x' xmlns:y='http://sparkviewengine.com/y'><quux/></foo>");
             var visitor = new NamespaceVisitor(new VisitorContext());
             visitor.Accept(nodes);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[0]).Namespace);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[1]).Namespace);
+            Assert.Multiple(() =>
+            {
+                Assert.That(((ElementNode)visitor.Nodes[0]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+                Assert.That(((ElementNode)visitor.Nodes[1]).Namespace, Is.EqualTo(""));
 
-            Assert.AreEqual("y:bar", ((ElementNode)visitor.Nodes[0]).Attributes[0].Name);
-            Assert.AreEqual("http://sparkviewengine.com/y", ((ElementNode)visitor.Nodes[0]).Attributes[0].Namespace);
+                Assert.That(((ElementNode)visitor.Nodes[0]).Attributes[0].Name, Is.EqualTo("y:bar"));
+                Assert.That(((ElementNode)visitor.Nodes[0]).Attributes[0].Namespace, Is.EqualTo("http://sparkviewengine.com/y"));
+            });
 
         }
 
@@ -78,24 +90,27 @@ public void ScopeOfXmlnsIsLimited()
             var nodes = ParseNodes("<x:pre/><x:foo xmlns:x='http://sparkviewengine.com/x'/><x:post/>");
             var visitor = new NamespaceVisitor(new VisitorContext());
             visitor.Accept(nodes);
-            Assert.AreEqual("x:pre", ((ElementNode)visitor.Nodes[0]).Name);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[0]).Namespace);
-            Assert.AreEqual("x:foo", ((ElementNode)visitor.Nodes[1]).Name);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[1]).Namespace);
-            Assert.AreEqual("x:post", ((ElementNode)visitor.Nodes[2]).Name);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[2]).Namespace);
+            Assert.Multiple(() =>
+            {
+                Assert.That(((ElementNode)visitor.Nodes[0]).Name, Is.EqualTo("x:pre"));
+                Assert.That(((ElementNode)visitor.Nodes[0]).Namespace, Is.EqualTo(""));
+                Assert.That(((ElementNode)visitor.Nodes[1]).Name, Is.EqualTo("x:foo"));
+                Assert.That(((ElementNode)visitor.Nodes[1]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+                Assert.That(((ElementNode)visitor.Nodes[2]).Name, Is.EqualTo("x:post"));
+                Assert.That(((ElementNode)visitor.Nodes[2]).Namespace, Is.EqualTo(""));
+            });
 
             nodes = ParseNodes("<x:pre/><x:foo xmlns:x='http://sparkviewengine.com/x'><x:bar/></x:foo><x:post/>");
             visitor = new NamespaceVisitor(new VisitorContext());
             visitor.Accept(nodes);
-            Assert.AreEqual("x:pre", ((ElementNode)visitor.Nodes[0]).Name);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[0]).Namespace);
-            Assert.AreEqual("x:foo", ((ElementNode)visitor.Nodes[1]).Name);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[1]).Namespace);
-            Assert.AreEqual("x:bar", ((ElementNode)visitor.Nodes[2]).Name);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[2]).Namespace);
-            Assert.AreEqual("x:post", ((ElementNode)visitor.Nodes[4]).Name);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[4]).Namespace);
+            Assert.That(((ElementNode)visitor.Nodes[0]).Name, Is.EqualTo("x:pre"));
+            Assert.That(((ElementNode)visitor.Nodes[0]).Namespace, Is.EqualTo(""));
+            Assert.That(((ElementNode)visitor.Nodes[1]).Name, Is.EqualTo("x:foo"));
+            Assert.That(((ElementNode)visitor.Nodes[1]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+            Assert.That(((ElementNode)visitor.Nodes[2]).Name, Is.EqualTo("x:bar"));
+            Assert.That(((ElementNode)visitor.Nodes[2]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+            Assert.That(((ElementNode)visitor.Nodes[4]).Name, Is.EqualTo("x:post"));
+            Assert.That(((ElementNode)visitor.Nodes[4]).Namespace, Is.EqualTo(""));
         }
 
         [Test]
@@ -104,20 +119,23 @@ public void NestedElementsDontWreckScope()
             var nodes = ParseNodes("<x:pre/><x:foo xmlns:x='http://sparkviewengine.com/x'><x:foo><x:foo/></x:foo></x:foo><x:post/>");
             var visitor = new NamespaceVisitor(new VisitorContext());
             visitor.Accept(nodes);
-            Assert.AreEqual("x:pre", ((ElementNode)visitor.Nodes[0]).Name);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[0]).Namespace);
-            Assert.AreEqual("x:foo", ((ElementNode)visitor.Nodes[1]).Name);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[1]).Namespace);
-            Assert.AreEqual("x:foo", ((ElementNode)visitor.Nodes[2]).Name);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[2]).Namespace);
-            Assert.AreEqual("x:foo", ((ElementNode)visitor.Nodes[3]).Name);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((ElementNode)visitor.Nodes[3]).Namespace);
-            Assert.AreEqual("x:foo", ((EndElementNode)visitor.Nodes[4]).Name);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((EndElementNode)visitor.Nodes[4]).Namespace);
-            Assert.AreEqual("x:foo", ((EndElementNode)visitor.Nodes[5]).Name);
-            Assert.AreEqual("http://sparkviewengine.com/x", ((EndElementNode)visitor.Nodes[5]).Namespace);
-            Assert.AreEqual("x:post", ((ElementNode)visitor.Nodes[6]).Name);
-            Assert.AreEqual("", ((ElementNode)visitor.Nodes[6]).Namespace);
+            Assert.Multiple(() =>
+            {
+                Assert.That(((ElementNode)visitor.Nodes[0]).Name, Is.EqualTo("x:pre"));
+                Assert.That(((ElementNode)visitor.Nodes[0]).Namespace, Is.EqualTo(""));
+                Assert.That(((ElementNode)visitor.Nodes[1]).Name, Is.EqualTo("x:foo"));
+                Assert.That(((ElementNode)visitor.Nodes[1]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+                Assert.That(((ElementNode)visitor.Nodes[2]).Name, Is.EqualTo("x:foo"));
+                Assert.That(((ElementNode)visitor.Nodes[2]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+                Assert.That(((ElementNode)visitor.Nodes[3]).Name, Is.EqualTo("x:foo"));
+                Assert.That(((ElementNode)visitor.Nodes[3]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+                Assert.That(((EndElementNode)visitor.Nodes[4]).Name, Is.EqualTo("x:foo"));
+                Assert.That(((EndElementNode)visitor.Nodes[4]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+                Assert.That(((EndElementNode)visitor.Nodes[5]).Name, Is.EqualTo("x:foo"));
+                Assert.That(((EndElementNode)visitor.Nodes[5]).Namespace, Is.EqualTo("http://sparkviewengine.com/x"));
+                Assert.That(((ElementNode)visitor.Nodes[6]).Name, Is.EqualTo("x:post"));
+                Assert.That(((ElementNode)visitor.Nodes[6]).Namespace, Is.EqualTo(""));
+            });
 
         }
     }
diff --git a/src/Spark.Tests/Visitors/SpecialNodeVisitorTester.cs b/src/Spark.Tests/Visitors/SpecialNodeVisitorTester.cs
index 3a8752a8..655e356e 100644
--- a/src/Spark.Tests/Visitors/SpecialNodeVisitorTester.cs
+++ b/src/Spark.Tests/Visitors/SpecialNodeVisitorTester.cs
@@ -30,26 +30,29 @@ public class SpecialNodeVisitorTester : BaseVisitorTester
         public void WellMatchedNodesWrapContent()
         {
             var nodes = ParseNodes("<div><content name='foo'><br></etc></content></div>");
-            Assert.AreEqual(6, nodes.Count);
+            Assert.That(nodes, Has.Count.EqualTo(6));
 
             var visitor = new SpecialNodeVisitor(new VisitorContext());
             visitor.Accept(nodes);
 
-            Assert.AreEqual(3, visitor.Nodes.Count);
-            Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[1]);
+            Assert.That(visitor.Nodes, Has.Count.EqualTo(3));
+            Assert.That(visitor.Nodes[1], Is.AssignableFrom(typeof(SpecialNode)));
 
             var specialNode = (SpecialNode)visitor.Nodes[1];
-            Assert.AreEqual("content", specialNode.Element.Name);
-            Assert.AreEqual(2, specialNode.Body.Count);
-            Assert.AreEqual("br", ((ElementNode)specialNode.Body[0]).Name);
-            Assert.AreEqual("etc", ((EndElementNode)specialNode.Body[1]).Name);
+            Assert.Multiple(() =>
+            {
+                Assert.That(specialNode.Element.Name, Is.EqualTo("content"));
+                Assert.That(specialNode.Body, Has.Count.EqualTo(2));
+                Assert.That(((ElementNode)specialNode.Body[0]).Name, Is.EqualTo("br"));
+                Assert.That(((EndElementNode)specialNode.Body[1]).Name, Is.EqualTo("etc"));
+            });
         }
 
         [Test]
         public void UnclosedNodeThrowsCompilerException()
         {
             var nodes = ParseNodes("<div><content name='foo'><br></etc></kontent></div>");
-            Assert.AreEqual(6, nodes.Count);
+            Assert.That(nodes, Has.Count.EqualTo(6));
 
             var visitor = new SpecialNodeVisitor(new VisitorContext { Paint = _paint });
             Assert.That(() => visitor.Accept(nodes), Throws.TypeOf<CompilerException>());
@@ -59,7 +62,7 @@ public void UnclosedNodeThrowsCompilerException()
         public void MismatchedSpecialNodeThrowsCompilerException()
         {
             var nodes = ParseNodes("<div><content name='foo'><br></etc></for></div>");
-            Assert.AreEqual(6, nodes.Count);
+            Assert.That(nodes, Has.Count.EqualTo(6));
 
             var visitor = new SpecialNodeVisitor(new VisitorContext { Paint = _paint });
             Assert.That(() => visitor.Accept(nodes), Throws.TypeOf<CompilerException>());
@@ -69,7 +72,7 @@ public void MismatchedSpecialNodeThrowsCompilerException()
         public void ExtraEndSpecialNodeThrowCompilerException()
         {
             var nodes = ParseNodes("<div><content name='foo'/><br></etc></content></div>");
-            Assert.AreEqual(6, nodes.Count);
+            Assert.That(nodes, Has.Count.EqualTo(6));
 
             var visitor = new SpecialNodeVisitor(new VisitorContext { Paint = _paint });
             Assert.That(() => visitor.Accept(nodes), Throws.TypeOf<CompilerException>());
diff --git a/src/Spark.Web.Mvc.Pdf.Tests/PdfViewResultTests.cs b/src/Spark.Web.Mvc.Pdf.Tests/PdfViewResultTests.cs
index 1bd653f2..4ef31757 100644
--- a/src/Spark.Web.Mvc.Pdf.Tests/PdfViewResultTests.cs
+++ b/src/Spark.Web.Mvc.Pdf.Tests/PdfViewResultTests.cs
@@ -29,14 +29,13 @@ public void PdfResultShouldFindPartialViewAndRenderIt()
             var stream = new MemoryStream();
             var controllerContext = GetControllerContext(stream);
 
-            IView view;
-            var viewEngine = MockViewEngine(controllerContext, out view);            
+            var viewEngine = MockViewEngine(controllerContext, out IView view);
 
             var result = new PdfViewResult
-                         {
-                             ViewName = "quux",
-                             ViewEngineCollection = new ViewEngineCollection(new[] { viewEngine })
-                         };
+            {
+                ViewName = "quux",
+                ViewEngineCollection = new ViewEngineCollection(new[] { viewEngine })
+            };
 
             result.ExecuteResult(controllerContext);
 
@@ -48,7 +47,7 @@ private static IViewEngine MockViewEngine(ControllerContext controllerContext, o
         {
             var viewEngine = MockRepository.GenerateMock<IViewEngine>();
             view = MockRepository.GenerateMock<IView>();
-            
+
             viewEngine
                 .Expect(x => x.FindView(controllerContext, "quux", "", true))
                 .Return(new ViewEngineResult(view, viewEngine));
@@ -83,9 +82,9 @@ public void PdfResultShouldWriteToOutputStream()
             var controllerContext = GetControllerContext(stream);
 
             var result = new PdfViewResult
-                         {
-                             ViewEngineCollection = new ViewEngineCollection(new[] { factory })
-                         };
+            {
+                ViewEngineCollection = new ViewEngineCollection(new[] { factory })
+            };
 
             result.ExecuteResult(controllerContext);
 
@@ -97,9 +96,7 @@ public void ContentTypeShouldBeApplicationPdf()
         {
             var stream = new MemoryStream();
             var controllerContext = GetControllerContext(stream);
-
-            IView view;
-            var viewEngine = MockViewEngine(controllerContext, out view);
+            var viewEngine = MockViewEngine(controllerContext, out _);
 
 
             var result = new PdfViewResult
diff --git a/src/Spark.Web.Mvc.Pdf.Tests/Spark.Web.Mvc.Pdf.Tests.csproj b/src/Spark.Web.Mvc.Pdf.Tests/Spark.Web.Mvc.Pdf.Tests.csproj
index 33f50209..22094c2a 100644
--- a/src/Spark.Web.Mvc.Pdf.Tests/Spark.Web.Mvc.Pdf.Tests.csproj
+++ b/src/Spark.Web.Mvc.Pdf.Tests/Spark.Web.Mvc.Pdf.Tests.csproj
@@ -12,9 +12,13 @@
   </ItemGroup>
   <ItemGroup>
 	<PackageReference Include="Microsoft.AspNet.Mvc" Version="5.3.0" />
-	<PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-	<PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+	<PackageReference Include="NUnit" Version="4.2.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+	<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
 	<PackageReference Include="RhinoMocks" Version="3.6.1" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Spark.Web.Mvc.Ruby.Tests/HtmlHelperExtensionsTester.cs b/src/Spark.Web.Mvc.Ruby.Tests/HtmlHelperExtensionsTester.cs
index 971badaa..1abbb8ea 100644
--- a/src/Spark.Web.Mvc.Ruby.Tests/HtmlHelperExtensionsTester.cs
+++ b/src/Spark.Web.Mvc.Ruby.Tests/HtmlHelperExtensionsTester.cs
@@ -49,16 +49,16 @@ public void BuildingScriptHeader()
 
             var header = languageFactory.BuildScriptHeader(languageFactory.GetType().Assembly);
 
-            Assert.That(header.Contains("ActionLink"));
-            Assert.That(header.Contains("Password"));
-            Assert.That(header.Contains("RenderPartial"));
+            Assert.That(header, Does.Contain("ActionLink"));
+            Assert.That(header, Does.Contain("Password"));
+            Assert.That(header, Does.Contain("RenderPartial"));
         }
 
         private static ViewContext CompileView(string viewContents)
         {
             var services = new ServiceCollection()
                 .AddSpark(new SparkSettings());
-            
+
             var viewFolder = new InMemoryViewFolder { { $"stub{Path.DirectorySeparatorChar}index.spark", viewContents } };
 
             services.AddSingleton<IViewFolder>(viewFolder);
@@ -91,7 +91,7 @@ public void RenderSimpleView()
             var output = new StringWriter();
             viewContext.View.Render(viewContext, output);
 
-            Assert.AreEqual("<p>Hello world</p>", output.ToString());
+            Assert.That(output.ToString(), Is.EqualTo("<p>Hello world</p>"));
         }
 
         [Test, Ignore("MVC 3.0 bringing some complication in relation to IronRuby - need to investigate")]
@@ -104,9 +104,12 @@ public void UseExtensionMethod()
             var output = new StringWriter();
             viewContext.View.Render(viewContext, output);
 
-            Assert.That(output.ToString().StartsWith("<p><input"));
-            Assert.That(output.ToString().Contains("name=\"hello\""));
-            Assert.That(output.ToString().Contains("type=\"text\""));
+            Assert.Multiple(() =>
+            {
+                Assert.That(output.ToString(), Does.StartWith("<p><input"));
+                Assert.That(output.ToString(), Does.Contain("name=\"hello\""));
+            });
+            Assert.That(output.ToString(), Does.Contain("type=\"text\""));
         }
     }
 }
diff --git a/src/Spark.Web.Mvc.Ruby.Tests/Spark.Web.Mvc.Ruby.Tests.csproj b/src/Spark.Web.Mvc.Ruby.Tests/Spark.Web.Mvc.Ruby.Tests.csproj
index ec9c043a..1b2338d9 100644
--- a/src/Spark.Web.Mvc.Ruby.Tests/Spark.Web.Mvc.Ruby.Tests.csproj
+++ b/src/Spark.Web.Mvc.Ruby.Tests/Spark.Web.Mvc.Ruby.Tests.csproj
@@ -15,9 +15,13 @@
     <Reference Include="System.Web" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="NUnit" Version="4.2.2" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
     <ProjectReference Include="..\Spark.Web.Mvc.Ruby\Spark.Web.Mvc.Ruby.csproj" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Spark.Web.Mvc.Tests/Compiler/CSharpViewCompilerTester.cs b/src/Spark.Web.Mvc.Tests/Compiler/CSharpViewCompilerTester.cs
index bd38c81a..9987fa9e 100644
--- a/src/Spark.Web.Mvc.Tests/Compiler/CSharpViewCompilerTester.cs
+++ b/src/Spark.Web.Mvc.Tests/Compiler/CSharpViewCompilerTester.cs
@@ -50,7 +50,7 @@ public void MakeAndCompile()
             var instance = compiler.CreateInstance();
             string contents = instance.RenderView();
 
-            Assert.That(contents.Contains("hello world"));
+            Assert.That(contents, Does.Contain("hello world"));
         }
 
 
@@ -62,12 +62,12 @@ public void UnsafeLiteralCharacters()
             var compiler = new CSharpViewCompiler(this.batchCompiler, settings);
             DoCompileView(compiler, new[] { new SendLiteralChunk { Text = text } });
 
-            Assert.That(compiler.SourceCode.Contains("Write(\"hello\\t\\r\\n\\\"world\")"));
+            Assert.That(compiler.SourceCode, Does.Contain("Write(\"hello\\t\\r\\n\\\"world\")"));
 
             var instance = compiler.CreateInstance();
             string contents = instance.RenderView();
 
-            Assert.AreEqual(text, contents);
+            Assert.That(contents, Is.EqualTo(text));
         }
 
         [Test]
@@ -79,7 +79,7 @@ public void SimpleOutput()
             var instance = compiler.CreateInstance();
             string contents = instance.RenderView();
 
-            Assert.AreEqual("7", contents);
+            Assert.That(contents, Is.EqualTo("7"));
         }
 
         [Test]
@@ -89,13 +89,13 @@ public void LocalVariableDecl()
             var compiler = new CSharpViewCompiler(this.batchCompiler, settings);
             DoCompileView(compiler, new Chunk[]
                                     {
-                                        new LocalVariableChunk { Name = "i", Value = "5" }, 
+                                        new LocalVariableChunk { Name = "i", Value = "5" },
                                         new SendExpressionChunk { Code = "i" }
                                     });
             var instance = compiler.CreateInstance();
             string contents = instance.RenderView();
 
-            Assert.AreEqual("5", contents);
+            Assert.That(contents, Is.EqualTo("5"));
         }
 
         [Test]
@@ -111,7 +111,7 @@ public void ForEachLoop()
                                         {
                                             Code = "var item in data",
                                             Body = new Chunk[]
-                                                   { 
+                                                   {
                                                        new SendLiteralChunk {Text = "<li>"},
                                                        new SendExpressionChunk {Code = "item"},
                                                        new SendLiteralChunk {Text = "</li>"}
@@ -122,7 +122,7 @@ public void ForEachLoop()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<ul><li>3</li><li>4</li><li>5</li></ul>", contents);
+            Assert.That(contents, Is.EqualTo("<ul><li>3</li><li>4</li><li>5</li></ul>"));
         }
 
         [Test]
@@ -142,7 +142,7 @@ public void GlobalVariables()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("hello world:8", contents);
+            Assert.That(contents, Is.EqualTo("hello world:8"));
         }
 
         [Test]
@@ -157,7 +157,7 @@ public void TargetNamespace()
             DoCompileView(compiler, new Chunk[] { new SendLiteralChunk { Text = "Hello" } });
             var instance = compiler.CreateInstance();
 
-            Assert.AreEqual("Testing.Target.Namespace", instance.GetType().Namespace);
+            Assert.That(instance.GetType().Namespace, Is.EqualTo("Testing.Target.Namespace"));
         }
 
 
@@ -199,7 +199,7 @@ public void IfTrueCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p>wastrue</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>wastrue</p>"));
         }
 
         [Test]
@@ -223,7 +223,7 @@ public void IfFalseCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p></p>", contents);
+            Assert.That(contents, Is.EqualTo("<p></p>"));
         }
 
         [Test]
@@ -249,7 +249,7 @@ public void IfElseFalseCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p>wasfalse</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>wasfalse</p>"));
         }
 
         [Test]
@@ -273,7 +273,7 @@ public void UnlessTrueCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p></p>", contents);
+            Assert.That(contents, Is.EqualTo("<p></p>"));
         }
 
         [Test]
@@ -297,7 +297,7 @@ public void UnlessFalseCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p>wastrue</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>wastrue</p>"));
         }
 
         [Test]
@@ -309,7 +309,7 @@ public void LenientSilentNullDoesNotCauseWarningCS0168()
             }.AddAssembly(typeof(Spark.Tests.Models.Comment).Assembly);
 
             var compiler = new CSharpViewCompiler(this.batchCompiler, settings);
-            
+
             var chunks = new Chunk[]
             {
                 new ViewDataChunk { Name = "comment", Type = "Spark.Tests.Models.Comment" },
@@ -318,7 +318,7 @@ public void LenientSilentNullDoesNotCauseWarningCS0168()
 
             compiler.CompileView(new[] { chunks }, new[] { chunks });
 
-            Assert.That(compiler.SourceCode.Contains("catch(System.NullReferenceException)"));
+            Assert.That(compiler.SourceCode, Does.Contain("catch(System.NullReferenceException)"));
         }
 
         [Test]
@@ -338,7 +338,7 @@ public void LenientOutputNullDoesNotCauseWarningCS0168()
 
             compiler.CompileView(new[] { chunks }, new[] { chunks });
 
-            Assert.That(compiler.SourceCode.Contains("catch(System.NullReferenceException)"));
+            Assert.That(compiler.SourceCode, Does.Contain("catch(System.NullReferenceException)"));
         }
 
         [Test]
@@ -349,18 +349,21 @@ public void StrictNullUsesException()
                 NullBehaviour = NullBehaviour.Strict
             };
             var compiler = new CSharpViewCompiler(this.batchCompiler, settings);
-            
+
             var chunks = new Chunk[]
             {
                 new ViewDataChunk { Name = "comment", Type = "Spark.Tests.Models.Comment" },
                 new SendExpressionChunk { Code = "comment.Text", SilentNulls = false }
             };
-            
+
             compiler.CompileView(new[] { chunks }, new[] { chunks });
-            
-            Assert.That(compiler.SourceCode.Contains("catch(System.NullReferenceException ex)"));
-            Assert.That(compiler.SourceCode.Contains("ArgumentNullException("));
-            Assert.That(compiler.SourceCode.Contains(", ex);"));
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(compiler.SourceCode, Does.Contain("catch(System.NullReferenceException ex)"));
+                Assert.That(compiler.SourceCode, Does.Contain("ArgumentNullException("));
+                Assert.That(compiler.SourceCode, Does.Contain(", ex);"));
+            });
         }
 
         [Test]
@@ -379,7 +382,7 @@ public void PageBaseTypeOverridesBaseClass()
                                     });
 
             var instance = compiler.CreateInstance();
-            
+
             Assert.That(instance, Is.InstanceOf(typeof(StubSparkView2)));
         }
 
@@ -401,9 +404,9 @@ public void PageBaseTypeWorksWithOptionalModel()
                     new ViewDataModelChunk { TModel = "Spark.Tests.Models.Comment" },
                     new SendLiteralChunk { Text = "Hello world" }
                 });
-            
+
             var instance = compiler.CreateInstance();
-            
+
             Assert.That(instance, Is.InstanceOf(typeof(StubSparkView2)));
             Assert.That(instance, Is.InstanceOf(typeof(StubSparkView2<Comment>)));
         }
diff --git a/src/Spark.Web.Mvc.Tests/Compiler/VisualBasicViewCompilerTester.cs b/src/Spark.Web.Mvc.Tests/Compiler/VisualBasicViewCompilerTester.cs
index e111632d..e5fdb9e7 100644
--- a/src/Spark.Web.Mvc.Tests/Compiler/VisualBasicViewCompilerTester.cs
+++ b/src/Spark.Web.Mvc.Tests/Compiler/VisualBasicViewCompilerTester.cs
@@ -51,7 +51,7 @@ public void MakeAndCompile()
             var instance = compiler.CreateInstance();
             string contents = instance.RenderView();
 
-            Assert.That(contents.Contains("hello world"));
+            Assert.That(contents, Does.Contain("hello world"));
         }
 
         [Test]
@@ -62,14 +62,14 @@ public void StronglyTypedBase()
 
             DoCompileView(compiler, new Chunk[]
             {
-                new SendLiteralChunk { Text = "hello world" }, 
+                new SendLiteralChunk { Text = "hello world" },
                 new ViewDataModelChunk { TModel="Global.System.String"}
             });
 
             var instance = compiler.CreateInstance();
             string contents = instance.RenderView();
 
-            Assert.That(contents.Contains("hello world"));
+            Assert.That(contents, Does.Contain("hello world"));
         }
 
         [Test]
@@ -79,7 +79,7 @@ public void UnsafeLiteralCharacters()
             var compiler = CreateCompiler();
             DoCompileView(compiler, new[] { new SendLiteralChunk { Text = text } });
 
-            Assert.That(compiler.SourceCode.Contains("Write(\"hello"));
+            Assert.That(compiler.SourceCode, Does.Contain("Write(\"hello"));
 
             var instance = compiler.CreateInstance();
             string contents = instance.RenderView();
@@ -108,7 +108,7 @@ public void SimpleOutput()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("7", contents);
+            Assert.That(contents, Is.EqualTo("7"));
         }
 
         [Test]
@@ -144,7 +144,7 @@ public void RethrowNullBehavior()
             };
 
             var compiler = CreateCompiler(settings);
-            
+
             DoCompileView(compiler, new[] { new SendExpressionChunk { Code = "CType(Nothing, String).Length" } });
             var instance = compiler.CreateInstance();
 
@@ -159,13 +159,13 @@ public void LocalVariableDecl()
             var compiler = new VisualBasicViewCompiler(this.batchCompiler, settings);
             DoCompileView(compiler, new Chunk[]
                                     {
-                                        new LocalVariableChunk { Name = "i", Value = "5" }, 
+                                        new LocalVariableChunk { Name = "i", Value = "5" },
                                         new SendExpressionChunk { Code = "i" }
                                     });
             var instance = compiler.CreateInstance();
             string contents = instance.RenderView();
 
-            Assert.AreEqual("5", contents);
+            Assert.That(contents, Is.EqualTo("5"));
         }
 
         [Test]
@@ -173,7 +173,7 @@ public void ForEachLoop()
         {
             var settings = new SparkSettings<SparkView>();
             var compiler = new VisualBasicViewCompiler(this.batchCompiler, settings);
-			DoCompileView(compiler, new Chunk[]
+            DoCompileView(compiler, new Chunk[]
                                     {
                                         new LocalVariableChunk {Name = "data", Value = "new Integer(){3,4,5}"},
                                         new SendLiteralChunk {Text = "<ul>"},
@@ -181,7 +181,7 @@ public void ForEachLoop()
                                         {
                                             Code = "item As Integer in data",
                                             Body = new Chunk[]
-                                                   { 
+                                                   {
                                                        new SendLiteralChunk {Text = "<li>"},
                                                        new SendExpressionChunk {Code = "item"},
                                                        new SendLiteralChunk {Text = "</li>"}
@@ -192,7 +192,7 @@ public void ForEachLoop()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<ul><li>3</li><li>4</li><li>5</li></ul>", contents);
+            Assert.That(contents, Is.EqualTo("<ul><li>3</li><li>4</li><li>5</li></ul>"));
         }
 
         [Test]
@@ -208,7 +208,7 @@ public void ForEachAutoVariables()
                                         {
                                             Code = "item As Integer in data",
                                             Body = new Chunk[]
-                                                   { 
+                                                   {
                                                        new SendLiteralChunk {Text = "<li>"},
                                                        new SendExpressionChunk {Code = "item"},
                                                        new SendExpressionChunk {Code = "itemIsFirst"},
@@ -223,7 +223,7 @@ public void ForEachAutoVariables()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<ul><li>3TrueFalse03</li><li>4FalseFalse13</li><li>5FalseTrue23</li></ul>", contents);
+            Assert.That(contents, Is.EqualTo("<ul><li>3TrueFalse03</li><li>4FalseFalse13</li><li>5FalseTrue23</li></ul>"));
         }
 
         [Test]
@@ -243,7 +243,7 @@ public void GlobalVariables()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("hello world:8", contents);
+            Assert.That(contents, Is.EqualTo("hello world:8"));
         }
 
         [Test]
@@ -255,11 +255,11 @@ public void TargetNamespace()
             {
                 Descriptor = new SparkViewDescriptor { TargetNamespace = "Testing.Target.Namespace" }
             };
-            
+
             DoCompileView(compiler, new Chunk[] { new SendLiteralChunk { Text = "Hello" } });
             var instance = compiler.CreateInstance();
 
-            Assert.AreEqual("Testing.Target.Namespace", instance.GetType().Namespace);
+            Assert.That(instance.GetType().Namespace, Is.EqualTo("Testing.Target.Namespace"));
         }
 
         [Test]
@@ -294,7 +294,7 @@ public void IfTrueCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p>wastrue</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>wastrue</p>"));
         }
 
         [Test]
@@ -315,7 +315,7 @@ public void IfFalseCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p></p>", contents);
+            Assert.That(contents, Is.EqualTo("<p></p>"));
         }
 
         [Test]
@@ -338,7 +338,7 @@ public void IfElseFalseCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p>wasfalse</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>wasfalse</p>"));
         }
 
         [Test]
@@ -359,7 +359,7 @@ public void UnlessTrueCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p></p>", contents);
+            Assert.That(contents, Is.EqualTo("<p></p>"));
         }
 
         [Test]
@@ -380,7 +380,7 @@ public void UnlessFalseCondition()
             var instance = compiler.CreateInstance();
             var contents = instance.RenderView();
 
-            Assert.AreEqual("<p>wastrue</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>wastrue</p>"));
         }
 
         [Test]
@@ -398,9 +398,12 @@ public void StrictNullUsesException()
                          };
             compiler.CompileView(new[] { chunks }, new[] { chunks });
 
-            Assert.That(compiler.SourceCode.Contains("Catch ex As Global.System.NullReferenceException"));
-            Assert.That(compiler.SourceCode.Contains("ArgumentNullException("));
-            Assert.That(compiler.SourceCode.Contains(", ex)"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(compiler.SourceCode, Does.Contain("Catch ex As Global.System.NullReferenceException"));
+                Assert.That(compiler.SourceCode, Does.Contain("ArgumentNullException("));
+                Assert.That(compiler.SourceCode, Does.Contain(", ex)"));
+            });
         }
 
         [Test]
diff --git a/src/Spark.Web.Mvc.Tests/Controllers/FailureController.cs b/src/Spark.Web.Mvc.Tests/Controllers/FailureController.cs
index b4814e11..3124458b 100644
--- a/src/Spark.Web.Mvc.Tests/Controllers/FailureController.cs
+++ b/src/Spark.Web.Mvc.Tests/Controllers/FailureController.cs
@@ -2,11 +2,11 @@
 
 namespace Spark.Web.Mvc.Tests.Controllers
 {
-	public class FailureController : Controller
-	{
-		public ActionResult Index()
-		{
-			return null;
-		}
-	}
+    public class FailureController : Controller
+    {
+        public ActionResult Index()
+        {
+            return null;
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Spark.Web.Mvc.Tests/DescriptorBuildingTester.cs b/src/Spark.Web.Mvc.Tests/DescriptorBuildingTester.cs
index 916042b7..9e372616 100644
--- a/src/Spark.Web.Mvc.Tests/DescriptorBuildingTester.cs
+++ b/src/Spark.Web.Mvc.Tests/DescriptorBuildingTester.cs
@@ -39,15 +39,12 @@ public class DescriptorBuildingTester
         private RouteData _routeData;
         private ControllerContext _controllerContext;
 
-        public static IServiceProvider SetupServiceProvider(ISparkSettings settings, Action<IServiceCollection> serviceOverrides = null)
+        private static IServiceProvider SetupServiceProvider(ISparkSettings settings, Action<IServiceCollection> serviceOverrides = null)
         {
             IServiceCollection services = new ServiceCollection()
                 .AddSpark(settings);
 
-            if (serviceOverrides != null)
-            {
-                serviceOverrides.Invoke(services);
-            }
+            serviceOverrides?.Invoke(services);
 
             return services.BuildServiceProvider();
         }
@@ -68,7 +65,7 @@ public void Init()
                 });
 
             this._precompiler = sp.GetService<SparkWebPrecompiler>();
-            
+
             var httpContext = MockRepository.GenerateStub<HttpContextBase>();
             _routeData = new RouteData();
             var controller = MockRepository.GenerateStub<ControllerBase>();
@@ -80,14 +77,14 @@ private static void AssertDescriptorTemplates(
             ICollection<string> searchedLocations,
             params string[] templates)
         {
-            Assert.AreEqual(templates.Length, descriptor.Templates.Count, "Descriptor template count must match");
+            Assert.That(descriptor.Templates.Count, Is.EqualTo(templates.Length), "Descriptor template count must match");
 
             for (var index = 0; index != templates.Length; ++index)
             {
-                Assert.AreEqual(templates[index], descriptor.Templates[index]);
+                Assert.That(descriptor.Templates[index], Is.EqualTo(templates[index]));
             }
 
-            Assert.AreEqual(0, searchedLocations.Count, "searchedLocations must be empty");
+            Assert.That(searchedLocations.Count, Is.EqualTo(0), "searchedLocations must be empty");
         }
 
         [Test]
@@ -341,7 +338,8 @@ public void AreaFolderMayContainControllerFolderWithShade()
         }
 
         [Test]
-        public void AreaRouteValueAlsoRecognizedForBackCompatWithEarlierAssumptions() {
+        public void AreaRouteValueAlsoRecognizedForBackCompatWithEarlierAssumptions()
+        {
             _routeData.Values.Add("area", "Admin");
             _routeData.Values.Add("controller", "Home");
             _viewFolder.Add(@"Home\Index.spark", "");
@@ -359,7 +357,8 @@ public void AreaRouteValueAlsoRecognizedForBackCompatWithEarlierAssumptions() {
         }
 
         [Test]
-        public void AreaRouteValueAlsoRecognizedForBackCompatWithEarlierAssumptionsWithShade() {
+        public void AreaRouteValueAlsoRecognizedForBackCompatWithEarlierAssumptionsWithShade()
+        {
             _routeData.Values.Add("area", "Admin");
             _routeData.Values.Add("controller", "Home");
             _viewFolder.Add(@"Home\Index.shade", "");
@@ -588,11 +587,8 @@ public void ParamsExtraEqualityMustBeIdentical()
 
         private static IDictionary<string, object> Dict(IEnumerable<string> values)
         {
-            return values == null
-                       ? null
-                       : values
-                             .Select((v, k) => new {k, v})
-                             .ToDictionary(kv => kv.k.ToString(), kv => (object) kv.v);
+            return values?.Select((v, k) => new { k, v })
+                             .ToDictionary(kv => kv.k.ToString(), kv => (object)kv.v);
         }
 
         [Test]
@@ -716,12 +712,15 @@ public void SimplifiedUseMasterGrammarDetectsElementCorrectly()
             var none = builder.ParseUseMaster(new Position(new SourceContext("  x <use etc=''/> <using master=\"def\"/> y ")));
             var g = builder.ParseUseMaster(new Position(new SourceContext("-<use master=\"g\"/>-<use master=\"h\"/>-")));
 
-            Assert.That(a.Value, Is.EqualTo("a"));
-            Assert.That(b.Value, Is.EqualTo("b"));
-            Assert.That(c.Value, Is.EqualTo("c"));
-            Assert.That(def.Value, Is.EqualTo("def"));
-            Assert.That(none, Is.Null);
-            Assert.That(g.Value, Is.EqualTo("g"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Value, Is.EqualTo("a"));
+                Assert.That(b.Value, Is.EqualTo("b"));
+                Assert.That(c.Value, Is.EqualTo("c"));
+                Assert.That(def.Value, Is.EqualTo("def"));
+                Assert.That(none, Is.Null);
+                Assert.That(g.Value, Is.EqualTo("g"));
+            });
         }
 
         [Test]
@@ -741,12 +740,15 @@ public void SimplifiedUseMasterGrammarWithPrefixDetectsElementCorrectly()
             var none = builder.ParseUseMaster(new Position(new SourceContext("  x <s:use etc=''/> <using master=\"def\"/> y ")));
             var g = builder.ParseUseMaster(new Position(new SourceContext("-<s:use master=\"g\"/>-<s:use master=\"h\"/>-")));
 
-            Assert.That(a.Value, Is.EqualTo("a"));
-            Assert.That(b.Value, Is.EqualTo("b"));
-            Assert.That(c.Value, Is.EqualTo("c"));
-            Assert.That(def.Value, Is.EqualTo("def"));
-            Assert.That(none, Is.Null);
-            Assert.That(g.Value, Is.EqualTo("g"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Value, Is.EqualTo("a"));
+                Assert.That(b.Value, Is.EqualTo("b"));
+                Assert.That(c.Value, Is.EqualTo("c"));
+                Assert.That(def.Value, Is.EqualTo("def"));
+                Assert.That(none, Is.Null);
+                Assert.That(g.Value, Is.EqualTo("g"));
+            });
         }
     }
 }
diff --git a/src/Spark.Web.Mvc.Tests/DescriptorFilterTester.cs b/src/Spark.Web.Mvc.Tests/DescriptorFilterTester.cs
index c6407f00..a88bedef 100644
--- a/src/Spark.Web.Mvc.Tests/DescriptorFilterTester.cs
+++ b/src/Spark.Web.Mvc.Tests/DescriptorFilterTester.cs
@@ -39,7 +39,8 @@ public void AreaFilterUsesRouteDataTokensByDefault()
 
 
         [Test]
-        public void AreaFilterUsesRouteValuesForBackCompat() {
+        public void AreaFilterUsesRouteValuesForBackCompat()
+        {
             var filter = new AreaDescriptorFilter();
 
             _context.RouteData.Values.Add("area", "foo");
diff --git a/src/Spark.Web.Mvc.Tests/LanguageKitFolderTester.cs b/src/Spark.Web.Mvc.Tests/LanguageKitFolderTester.cs
index 7a6cbe99..96cc139c 100644
--- a/src/Spark.Web.Mvc.Tests/LanguageKitFolderTester.cs
+++ b/src/Spark.Web.Mvc.Tests/LanguageKitFolderTester.cs
@@ -25,14 +25,17 @@ public void Init()
         public void ViewContentPassesThroughNormally()
         {
             Init();
-            Assert.That(_adapter.HasView(string.Format("Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
-            Assert.That(_adapter.HasView(string.Format("Home{0}Index2.spark", Path.DirectorySeparatorChar)), Is.False);
+            Assert.Multiple(() =>
+            {
+                Assert.That(_adapter.HasView(string.Format("Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
+                Assert.That(_adapter.HasView(string.Format("Home{0}Index2.spark", Path.DirectorySeparatorChar)), Is.False);
+            });
 
             var contents = ReadContents(_adapter, string.Format("Home{0}Index.spark", Path.DirectorySeparatorChar));
             Assert.That(contents, Is.EqualTo("alpha"));
 
             var items = _adapter.ListViews("Home");
-            Assert.That(items.Count, Is.EqualTo(1));
+            Assert.That(items, Has.Count.EqualTo(1));
             Assert.That(items[0], Is.EqualTo(string.Format("Home{0}Index.spark", Path.DirectorySeparatorChar)));
         }
 
@@ -52,13 +55,19 @@ public void ParseLanguagePathTakesOffFirstTwoBits()
 
             path = _adapter.ParseLanguagePath(string.Format("language{0}en{0}foo{0}bar.spark", Path.DirectorySeparatorChar));
             Assert.That(path, Is.Not.Null);
-            Assert.That(path.Language, Is.EqualTo("en"));
-            Assert.That(path.Path, Is.EqualTo(string.Format("foo{0}bar.spark", Path.DirectorySeparatorChar)));
+            Assert.Multiple(() =>
+            {
+                Assert.That(path.Language, Is.EqualTo("en"));
+                Assert.That(path.Path, Is.EqualTo(string.Format("foo{0}bar.spark", Path.DirectorySeparatorChar)));
+            });
 
             path = _adapter.ParseLanguagePath(string.Format("Language{0}en-us{0}foo{0}bar.spark", Path.DirectorySeparatorChar));
             Assert.That(path, Is.Not.Null);
-            Assert.That(path.Language, Is.EqualTo("en-us"));
-            Assert.That(path.Path, Is.EqualTo(string.Format("foo{0}bar.spark", Path.DirectorySeparatorChar)));
+            Assert.Multiple(() =>
+            {
+                Assert.That(path.Language, Is.EqualTo("en-us"));
+                Assert.That(path.Path, Is.EqualTo(string.Format("foo{0}bar.spark", Path.DirectorySeparatorChar)));
+            });
 
             path = _adapter.ParseLanguagePath(string.Format("notLanguage{0}en-us{0}foo{0}bar.spark", Path.DirectorySeparatorChar));
             Assert.That(path, Is.Null);
@@ -86,7 +95,7 @@ public void ShortOrUnusualPathsWorkAsExpected()
 
             path = _adapter.ParseLanguagePath("language");
             Assert.That(path, Is.Null);
-            
+
             path = _adapter.ParseLanguagePath("lang");
             Assert.That(path, Is.Null);
         }
@@ -94,14 +103,17 @@ public void ShortOrUnusualPathsWorkAsExpected()
         [Test]
         public void HasViewForLanguageFolderPathsWillHitNativeFiles()
         {
-            Assert.That(_adapter.HasView(string.Format("language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
-            Assert.That(_adapter.HasView(string.Format("language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
-            Assert.That(_adapter.HasView(string.Format("Language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
-            Assert.That(_adapter.HasView(string.Format("Language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
-            Assert.That(_adapter.HasView(string.Format("language{0}en{0}Home{0}NoSuchFile.spark", Path.DirectorySeparatorChar)), Is.False);
-            Assert.That(_adapter.HasView(string.Format("language{0}en-us{0}Home{0}NoSuchFile.spark", Path.DirectorySeparatorChar)), Is.False);
-            Assert.That(_adapter.HasView(string.Format("Language{0}en{0}Home{0}NoSuchFile.spark", Path.DirectorySeparatorChar)), Is.False);
-            Assert.That(_adapter.HasView(string.Format("Language{0}en-us{0}Home{0}NoSuchFile.spark", Path.DirectorySeparatorChar)), Is.False);
+            Assert.Multiple(() =>
+            {
+                Assert.That(_adapter.HasView(string.Format("language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
+                Assert.That(_adapter.HasView(string.Format("language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
+                Assert.That(_adapter.HasView(string.Format("Language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
+                Assert.That(_adapter.HasView(string.Format("Language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.True);
+                Assert.That(_adapter.HasView(string.Format("language{0}en{0}Home{0}NoSuchFile.spark", Path.DirectorySeparatorChar)), Is.False);
+                Assert.That(_adapter.HasView(string.Format("language{0}en-us{0}Home{0}NoSuchFile.spark", Path.DirectorySeparatorChar)), Is.False);
+                Assert.That(_adapter.HasView(string.Format("Language{0}en{0}Home{0}NoSuchFile.spark", Path.DirectorySeparatorChar)), Is.False);
+                Assert.That(_adapter.HasView(string.Format("Language{0}en-us{0}Home{0}NoSuchFile.spark", Path.DirectorySeparatorChar)), Is.False);
+            });
         }
 
         [Test]
@@ -109,10 +121,13 @@ public void LanguageFolderPathsWillHitNativeFilesByName()
         {
             Init();
 
-            Assert.That(ReadContents(_adapter, string.Format("language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
-            Assert.That(ReadContents(_adapter, string.Format("language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
-            Assert.That(ReadContents(_adapter, string.Format("Language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
-            Assert.That(ReadContents(_adapter, string.Format("Language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(ReadContents(_adapter, string.Format("language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
+                Assert.That(ReadContents(_adapter, string.Format("language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
+                Assert.That(ReadContents(_adapter, string.Format("Language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
+                Assert.That(ReadContents(_adapter, string.Format("Language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
+            });
         }
 
         [Test]
@@ -124,11 +139,14 @@ public void FilesWithExtendedNamesAreHitFirst()
             _folder.Add(string.Format("Home{0}Index.en.spark", Path.DirectorySeparatorChar), "gamma");
             _folder.Add(string.Format("Home{0}Index.en-us.spark", Path.DirectorySeparatorChar), "delta");
 
-            Assert.That(ReadContents(_adapter, string.Format("language{0}fr{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("beta"));
-            Assert.That(ReadContents(_adapter, string.Format("language{0}es{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
-            Assert.That(ReadContents(_adapter, string.Format("language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("gamma"));
-            Assert.That(ReadContents(_adapter, string.Format("language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("delta"));
-            Assert.That(ReadContents(_adapter, string.Format("language{0}en-uk{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("gamma"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(ReadContents(_adapter, string.Format("language{0}fr{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("beta"));
+                Assert.That(ReadContents(_adapter, string.Format("language{0}es{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("alpha"));
+                Assert.That(ReadContents(_adapter, string.Format("language{0}en{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("gamma"));
+                Assert.That(ReadContents(_adapter, string.Format("language{0}en-us{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("delta"));
+                Assert.That(ReadContents(_adapter, string.Format("language{0}en-uk{0}Home{0}Index.spark", Path.DirectorySeparatorChar)), Is.EqualTo("gamma"));
+            });
         }
 
         [Test]
@@ -138,7 +156,7 @@ public void ListViewsPassesThrough()
             AddShared();
 
             var items = _adapter.ListViews(string.Format("Home{0}Shared", Path.DirectorySeparatorChar));
-            Assert.That(items.Count, Is.EqualTo(5));
+            Assert.That(items, Has.Count.EqualTo(5));
             Assert.That(items, Has.Member(string.Format("Home{0}Shared{0}_foo.spark", Path.DirectorySeparatorChar)));
             Assert.That(items, Has.Member(string.Format("Home{0}Shared{0}_foo.en.spark", Path.DirectorySeparatorChar)));
             Assert.That(items, Has.Member(string.Format("Home{0}Shared{0}_foo.en-uk.spark", Path.DirectorySeparatorChar)));
diff --git a/src/Spark.Web.Mvc.Tests/Spark.Web.Mvc.Tests.csproj b/src/Spark.Web.Mvc.Tests/Spark.Web.Mvc.Tests.csproj
index 2b91d1c8..de0b3baf 100644
--- a/src/Spark.Web.Mvc.Tests/Spark.Web.Mvc.Tests.csproj
+++ b/src/Spark.Web.Mvc.Tests/Spark.Web.Mvc.Tests.csproj
@@ -12,9 +12,13 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNet.Mvc" Version="5.3.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
 	<PackageReference Include="RhinoMocks" Version="3.6.1" />
-	<PackageReference Include="NUnit" Version="3.14.0" />
+	<PackageReference Include="NUnit" Version="4.2.2" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Spark.Web.Mvc\Spark.Web.Mvc.csproj" />
diff --git a/src/Spark.Web.Mvc.Tests/SparkBatchCompilerTester.cs b/src/Spark.Web.Mvc.Tests/SparkBatchCompilerTester.cs
index 6981f5e1..515a89b4 100644
--- a/src/Spark.Web.Mvc.Tests/SparkBatchCompilerTester.cs
+++ b/src/Spark.Web.Mvc.Tests/SparkBatchCompilerTester.cs
@@ -31,16 +31,13 @@ public class SparkPrecompilerTester
     {
         #region Setup/Teardown
 
-        public static IServiceProvider SetupServiceProvider(Action<ServiceCollection> serviceOverrides = null)
+        private static IServiceProvider SetupServiceProvider(Action<ServiceCollection> serviceOverrides = null)
         {
             var services = new ServiceCollection();
 
             services.AddSpark(new SparkSettings().SetBaseClassTypeName(typeof(SparkView).FullName));
 
-            if (serviceOverrides != null)
-            {
-                serviceOverrides.Invoke(services);
-            }
+            serviceOverrides?.Invoke(services);
 
             services.AddSingleton<SparkPrecompiler>();
 
@@ -75,8 +72,8 @@ public void CompileBatchDescriptor()
 
             var assembly = this._precompiler.Precompile(batch);
 
-            Assert.IsNotNull(assembly);
-            Assert.AreEqual(3, assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)));
+            Assert.That(assembly, Is.Not.Null);
+            Assert.That(assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)), Is.EqualTo(3));
         }
 
         [Test]
@@ -139,11 +136,14 @@ public void DefaultMatchingRules()
 
             var descriptors = this._precompiler.CreateDescriptors(batch);
 
-            Assert.AreEqual(2, descriptors.Count);
-            Assert.AreEqual(1, descriptors[0].Templates.Count);
-            Assert.AreEqual(1, descriptors[1].Templates.Count);
-            Assert.That(descriptors.Any(d => d.Templates.Contains(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar))));
-            Assert.That(descriptors.Any(d => d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar))));
+            Assert.That(descriptors.Count, Is.EqualTo(2));
+            Assert.That(descriptors[0].Templates.Count, Is.EqualTo(1));
+            Assert.That(descriptors[1].Templates.Count, Is.EqualTo(1));
+            Assert.Multiple(() =>
+            {
+                Assert.That(descriptors.Any(d => d.Templates.Contains(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar))));
+                Assert.That(descriptors.Any(d => d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar))));
+            });
         }
 
         [Test]
@@ -155,11 +155,14 @@ public void ExcludeRules()
 
             var descriptors = this._precompiler.CreateDescriptors(batch);
 
-            Assert.AreEqual(2, descriptors.Count);
-            Assert.AreEqual(1, descriptors[0].Templates.Count);
-            Assert.AreEqual(1, descriptors[1].Templates.Count);
-            Assert.That(descriptors.Any(d => d.Templates.Contains(string.Format("Stub{0}_Widget.spark", Path.DirectorySeparatorChar))));
-            Assert.That(descriptors.Any(d => d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar))));
+            Assert.That(descriptors.Count, Is.EqualTo(2));
+            Assert.That(descriptors[0].Templates.Count, Is.EqualTo(1));
+            Assert.That(descriptors[1].Templates.Count, Is.EqualTo(1));
+            Assert.Multiple(() =>
+            {
+                Assert.That(descriptors.Any(d => d.Templates.Contains(string.Format("Stub{0}_Widget.spark", Path.DirectorySeparatorChar))));
+                Assert.That(descriptors.Any(d => d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar))));
+            });
         }
 
         [Test]
@@ -176,8 +179,8 @@ public void MultipleLayoutFiles()
 
             var assembly = this._precompiler.Precompile(batch);
 
-            Assert.IsNotNull(assembly);
-            Assert.AreEqual(4, assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)));
+            Assert.That(assembly, Is.Not.Null);
+            Assert.That(assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)), Is.EqualTo(4));
         }
 
         [Test]
@@ -190,21 +193,24 @@ public void WildcardIncludeRules()
                 .For<StubController>().Layout("ajax").Include("_*");
 
             var descriptors = this._precompiler.CreateDescriptors(batch);
-            Assert.AreEqual(3, descriptors.Count);
-            Assert.That(
-                descriptors.Any(
-                    d => d.Templates.Contains(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar)) && d.Templates.Contains(string.Format("Shared{0}layout.spark", Path.DirectorySeparatorChar))));
-            Assert.That(
-                descriptors.Any(
-                    d => d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar)) && d.Templates.Contains(string.Format("Shared{0}layout.spark", Path.DirectorySeparatorChar))));
-            Assert.That(
-                descriptors.Any(
-                    d => d.Templates.Contains(string.Format("Stub{0}_Widget.spark", Path.DirectorySeparatorChar)) && d.Templates.Contains(string.Format("Shared{0}ajax.spark", Path.DirectorySeparatorChar))));
+            Assert.That(descriptors.Count, Is.EqualTo(3));
+            Assert.Multiple(() =>
+            {
+                Assert.That(
+                            descriptors.Any(
+                                d => d.Templates.Contains(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar)) && d.Templates.Contains(string.Format("Shared{0}layout.spark", Path.DirectorySeparatorChar))));
+                Assert.That(
+                    descriptors.Any(
+                        d => d.Templates.Contains(string.Format("Stub{0}List.spark", Path.DirectorySeparatorChar)) && d.Templates.Contains(string.Format("Shared{0}layout.spark", Path.DirectorySeparatorChar))));
+                Assert.That(
+                    descriptors.Any(
+                        d => d.Templates.Contains(string.Format("Stub{0}_Widget.spark", Path.DirectorySeparatorChar)) && d.Templates.Contains(string.Format("Shared{0}ajax.spark", Path.DirectorySeparatorChar))));
+            });
 
             var assembly = this._precompiler.Precompile(batch);
 
-            Assert.IsNotNull(assembly);
-            Assert.AreEqual(3, assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)));
+            Assert.That(assembly, Is.Not.Null);
+            Assert.That(assembly.GetTypes().Count(x => x.BaseType == typeof(SparkView)), Is.EqualTo(3));
         }
 
         [Test]
@@ -230,10 +236,10 @@ public void FileWithoutSparkExtensionAreIgnored()
 
             var descriptors = this._precompiler.CreateDescriptors(batch);
 
-            Assert.AreEqual(1, descriptors.Count);
-            Assert.AreEqual(2, descriptors[0].Templates.Count);
-            Assert.AreEqual(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar), descriptors[0].Templates[0]);
-            Assert.AreEqual(string.Format("Layouts{0}Stub.spark", Path.DirectorySeparatorChar), descriptors[0].Templates[1]);
+            Assert.That(descriptors.Count, Is.EqualTo(1));
+            Assert.That(descriptors[0].Templates.Count, Is.EqualTo(2));
+            Assert.That(descriptors[0].Templates[0], Is.EqualTo(string.Format("Stub{0}Index.spark", Path.DirectorySeparatorChar)));
+            Assert.That(descriptors[0].Templates[1], Is.EqualTo(string.Format("Layouts{0}Stub.spark", Path.DirectorySeparatorChar)));
         }
     }
 
@@ -259,7 +265,7 @@ public static string GetCodeBaseDirectory(this Assembly assembly)
             var codeBaseUriString = assembly.CodeBase;
             var uriBuilder = new UriBuilder(codeBaseUriString);
             var codeBasePath = Uri.UnescapeDataString(uriBuilder.Path);
-            
+
             return Path.GetDirectoryName(codeBasePath);
         }
     }
diff --git a/src/Spark.Web.Mvc.Tests/SparkViewFactoryTester.cs b/src/Spark.Web.Mvc.Tests/SparkViewFactoryTester.cs
index efdc880d..f05c7ee9 100644
--- a/src/Spark.Web.Mvc.Tests/SparkViewFactoryTester.cs
+++ b/src/Spark.Web.Mvc.Tests/SparkViewFactoryTester.cs
@@ -38,16 +38,13 @@ public class SparkViewFactoryTester
     {
         #region Setup/Teardown
 
-        public static IServiceProvider SetupServiceProvider(ISparkSettings settings, Action<ServiceCollection> serviceOverrides = null)
+        private static IServiceProvider SetupServiceProvider(ISparkSettings settings, Action<ServiceCollection> serviceOverrides = null)
         {
             var services = new ServiceCollection();
 
             services.AddSpark(settings);
 
-            if (serviceOverrides != null)
-            {
-                serviceOverrides.Invoke(services);
-            }
+            serviceOverrides?.Invoke(services);
 
             return services.BuildServiceProvider();
         }
@@ -58,9 +55,9 @@ public void Init()
             // reset routes
             RouteTable.Routes.Clear();
             RouteTable.Routes.Add(new Route("{controller}/{action}/{id}", new MvcRouteHandler())
-                                      {
-                                          Defaults = new RouteValueDictionary(new { action = "Index", id = "" })
-                                      });
+            {
+                Defaults = new RouteValueDictionary(new { action = "Index", id = "" })
+            });
 
             httpContext = MockHttpContextBase.Generate("/", new StringWriter());
             //_requestBase = MockRepository.GenerateStub<HttpRequestBase>();
@@ -178,7 +175,7 @@ private static void ContainsInOrder(string content, params string[] values)
             {
                 var nextIndex = content.IndexOf(value, index);
 
-                Assert.GreaterOrEqual(nextIndex, 0, $"Looking for {value}");
+                Assert.That(nextIndex, Is.GreaterThanOrEqualTo(0), () => $"Looking for {value}");
                 index = nextIndex + value.Length;
             }
         }
@@ -191,10 +188,13 @@ public void CaptureNamedContent()
             //mocks.VerifyAll();
             var content = output.ToString();
 
-            Assert.That(content.Contains("<p>main content</p>"));
-            Assert.That(content.Contains("<p>this is the header</p>"));
-            Assert.That(content.Contains("<p>footer part one</p>"));
-            Assert.That(content.Contains("<p>footer part two</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>main content</p>"));
+                Assert.That(content, Does.Contain("<p>this is the header</p>"));
+                Assert.That(content, Does.Contain("<p>footer part one</p>"));
+                Assert.That(content, Does.Contain("<p>footer part two</p>"));
+            });
         }
 
         [Test]
@@ -208,9 +208,12 @@ public void DeclaringViewDataAccessor()
             //mocks.VerifyAll();
             var content = output.ToString();
 
-            Assert.That(content.Contains("<h1>Hello world</h1>"));
-            Assert.That(content.Contains("<p>foo</p>"));
-            Assert.That(content.Contains("<p>bar</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<h1>Hello world</h1>"));
+                Assert.That(content, Does.Contain("<p>foo</p>"));
+                Assert.That(content, Does.Contain("<p>bar</p>"));
+            });
         }
 
 
@@ -223,9 +226,12 @@ public void ForEachTest()
 
             var content = output.ToString();
 
-            Assert.That(content.Contains(@"<li class=""odd"">1: foo</li>"));
-            Assert.That(content.Contains(@"<li class=""even"">2: bar</li>"));
-            Assert.That(content.Contains(@"<li class=""odd"">3: baaz</li>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain(@"<li class=""odd"">1: foo</li>"));
+                Assert.That(content, Does.Contain(@"<li class=""even"">2: bar</li>"));
+                Assert.That(content, Does.Contain(@"<li class=""odd"">3: baaz</li>"));
+            });
         }
 
         [Test]
@@ -237,8 +243,11 @@ public void GlobalSetTest()
 
             var content = output.ToString();
 
-            Assert.That(content.Contains("<p>default: Global set test</p>"));
-            Assert.That(content.Contains("<p>7==7</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>default: Global set test</p>"));
+                Assert.That(content, Does.Contain("<p>7==7</p>"));
+            });
         }
 
         [Test]
@@ -252,7 +261,7 @@ public void HtmlHelperWorksOnItsOwn()
 
             //mocks.VerifyAll();
 
-            Assert.AreEqual("<a href=\"/Home/world\">hello</a>", link);
+            Assert.That(link, Is.EqualTo("<a href=\"/Home/world\">hello</a>"));
         }
 
         [Test]
@@ -280,9 +289,9 @@ public void MasterApplicationIfPresent()
 
             //mocks.VerifyAll();
 
-            Assert.AreEqual(2, descriptor.Templates.Count);
-            Assert.AreEqual($"Foo{Path.DirectorySeparatorChar}Baaz.spark", descriptor.Templates[0]);
-            Assert.AreEqual($"Shared{Path.DirectorySeparatorChar}Application.spark", descriptor.Templates[1]);
+            Assert.That(descriptor.Templates.Count, Is.EqualTo(2));
+            Assert.That(descriptor.Templates[0], Is.EqualTo($"Foo{Path.DirectorySeparatorChar}Baaz.spark"));
+            Assert.That(descriptor.Templates[1], Is.EqualTo($"Shared{Path.DirectorySeparatorChar}Application.spark"));
         }
 
         [Test]
@@ -307,8 +316,8 @@ public void MasterEmptyByDefault()
 
             var descriptor = factory.CreateDescriptor(controllerContext, "Baaz", null, true, null);
 
-            Assert.AreEqual(1, descriptor.Templates.Count);
-            Assert.AreEqual($"Foo{Path.DirectorySeparatorChar}Baaz.spark", descriptor.Templates[0]);
+            Assert.That(descriptor.Templates.Count, Is.EqualTo(1));
+            Assert.That(descriptor.Templates[0], Is.EqualTo($"Foo{Path.DirectorySeparatorChar}Baaz.spark"));
         }
 
         [Test]
@@ -328,15 +337,15 @@ public void MasterForControllerIfPresent()
                 });
 
             factory = sp.GetService<SparkViewFactory>();
-            
+
             routeData.Values["controller"] = "Foo";
             routeData.Values["action"] = "NotBaaz";
 
             var descriptor = factory.CreateDescriptor(controllerContext, "Baaz", null, true, null);
 
-            Assert.AreEqual(2, descriptor.Templates.Count);
-            Assert.AreEqual($"Foo{Path.DirectorySeparatorChar}Baaz.spark", descriptor.Templates[0]);
-            Assert.AreEqual($"Shared{Path.DirectorySeparatorChar}Foo.spark", descriptor.Templates[1]);
+            Assert.That(descriptor.Templates.Count, Is.EqualTo(2));
+            Assert.That(descriptor.Templates[0], Is.EqualTo($"Foo{Path.DirectorySeparatorChar}Baaz.spark"));
+            Assert.That(descriptor.Templates[1], Is.EqualTo($"Shared{Path.DirectorySeparatorChar}Foo.spark"));
         }
 
         [Test]
@@ -347,10 +356,13 @@ public void MasterTest()
             //mocks.VerifyAll();
             var content = output.ToString();
 
-            Assert.That(content.Contains("<title>Standalone Index View</title>"));
-            Assert.That(content.Contains("<h1>Standalone Index View</h1>"));
-            Assert.That(content.Contains("<p>no header by default</p>"));
-            Assert.That(content.Contains("<p>no footer by default</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<title>Standalone Index View</title>"));
+                Assert.That(content, Does.Contain("<h1>Standalone Index View</h1>"));
+                Assert.That(content, Does.Contain("<p>no header by default</p>"));
+                Assert.That(content, Does.Contain("<p>no footer by default</p>"));
+            });
         }
 
         [Test]
@@ -361,7 +373,7 @@ public void NullViewDataIsSafe()
 
             var content = output.ToString();
 
-            Assert.That(content.Contains("<p>nothing</p>"));
+            Assert.That(content, Does.Contain("<p>nothing</p>"));
         }
 
         [Test]
@@ -382,9 +394,9 @@ public void RenderPartialOrderCorrect()
         public void RenderPlainView()
         {
             var viewContext = MakeViewContext("index");
-            
+
             var viewEngineResult = factory.FindView(controllerContext, "index", null);
-            
+
             viewEngineResult.View.Render(viewContext, output);
 
             //mocks.VerifyAll();
@@ -414,7 +426,7 @@ public void TargetNamespaceFromController()
             var descriptor = factory.CreateDescriptor(controllerContext, "Baaz", null, true, null);
             //mocks.VerifyAll();
 
-            Assert.AreEqual("Spark.Web.Mvc.Tests.Controllers", descriptor.TargetNamespace);
+            Assert.That(descriptor.TargetNamespace, Is.EqualTo("Spark.Web.Mvc.Tests.Controllers"));
         }
 
         [Test]
@@ -425,8 +437,11 @@ public void UsingHtmlHelper()
             //mocks.VerifyAll();
             var content = output.ToString();
 
-            Assert.That(content.Contains("<p><a href=\"/Home/Sort\">Click me</a></p>"));
-            Assert.That(content.Contains("<p>foo&gt;bar</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p><a href=\"/Home/Sort\">Click me</a></p>"));
+                Assert.That(content, Does.Contain("<p>foo&gt;bar</p>"));
+            });
         }
 
         [Test]
@@ -437,9 +452,12 @@ public void UsingNamespace()
             //mocks.VerifyAll();
             var content = output.ToString();
 
-            Assert.That(content.Contains("<p>Foo</p>"));
-            Assert.That(content.Contains("<p>Bar</p>"));
-            Assert.That(content.Contains("<p>Hello</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>Foo</p>"));
+                Assert.That(content, Does.Contain("<p>Bar</p>"));
+                Assert.That(content, Does.Contain("<p>Hello</p>"));
+            });
         }
 
         [Test]
@@ -450,11 +468,14 @@ public void UsingPartialFile()
             //mocks.VerifyAll();
             var content = output.ToString();
 
-            Assert.That(content.Contains("<li>Partial where x=\"zero\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"one\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"two\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"three\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"four\"</li>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<li>Partial where x=\"zero\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"one\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"two\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"three\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"four\"</li>"));
+            });
         }
 
         [Test]
@@ -465,8 +486,11 @@ public void UsingPartialFileImplicit()
             //mocks.VerifyAll();
             var content = output.ToString();
 
-            Assert.That(content.Contains("<li class=\"odd\">one</li>"));
-            Assert.That(content.Contains("<li class=\"even\">two</li>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<li class=\"odd\">one</li>"));
+                Assert.That(content, Does.Contain("<li class=\"even\">two</li>"));
+            });
         }
 
         [Test]
@@ -477,7 +501,7 @@ public void ViewDataWithModel()
 
             var content = output.ToString();
 
-            Assert.That(content.Contains("<p>Hello</p>"));
+            Assert.That(content, Does.Contain("<p>Hello</p>"));
         }
 
         [Test]
@@ -487,13 +511,16 @@ public void ViewSourceLoaderCanBeChanged()
 
             var existing = factory.Engine.ViewFolder;
 
-            Assert.AreNotSame(existing, replacement);
-            Assert.AreSame(existing, factory.Engine.ViewFolder);
+            Assert.Multiple(() =>
+            {
+                Assert.That(replacement, Is.Not.SameAs(existing));
+                Assert.That(factory.Engine.ViewFolder, Is.SameAs(existing));
+            });
 
             factory.Engine.ViewFolder = replacement;
 
-            Assert.AreSame(replacement, factory.Engine.ViewFolder);
-            Assert.AreNotSame(existing, factory.Engine.ViewFolder);
+            Assert.That(factory.Engine.ViewFolder, Is.SameAs(replacement));
+            Assert.That(factory.Engine.ViewFolder, Is.Not.SameAs(existing));
         }
 
         [Test]
@@ -510,14 +537,17 @@ public void CreatingViewEngineWithSimpleContainer()
             var cacheService = sp.GetService<ICacheService>();
             var viewActivatorFactory = sp.GetService<IViewActivatorFactory>();
 
-            Assert.AreSame(settings, viewFactory.Settings);
-            Assert.AreSame(settings, viewEngine.Settings);
-            Assert.AreSame(viewEngine, viewFactory.Engine);
-            Assert.AreSame(viewFolder, viewEngine.ViewFolder);
-            Assert.AreSame(viewFolder, viewFactory.Engine.ViewFolder);
-            Assert.AreSame(descriptorBuilder, viewFactory.DescriptorBuilder);
-            Assert.AreSame(cacheService, viewFactory.CacheService);
-            Assert.AreSame(viewActivatorFactory, viewFactory.ViewActivatorFactory);
+            Assert.Multiple(() =>
+            {
+                Assert.That(viewFactory.Settings, Is.SameAs(settings));
+                Assert.That(viewEngine.Settings, Is.SameAs(settings));
+                Assert.That(viewFactory.Engine, Is.SameAs(viewEngine));
+                Assert.That(viewEngine.ViewFolder, Is.SameAs(viewFolder));
+            });
+            Assert.That(viewFactory.Engine.ViewFolder, Is.SameAs(viewFolder));
+            Assert.That(viewFactory.DescriptorBuilder, Is.SameAs(descriptorBuilder));
+            Assert.That(viewFactory.CacheService, Is.SameAs(cacheService));
+            Assert.That(viewFactory.ViewActivatorFactory, Is.SameAs(viewActivatorFactory));
         }
 
         [Test]
@@ -528,7 +558,7 @@ public void EvalWithViewDataModel()
 
             var content = output.ToString();
 
-            Assert.That(content.Contains("<p>Hello</p>"));
+            Assert.That(content, Does.Contain("<p>Hello</p>"));
         }
 
         [Test]
@@ -539,7 +569,7 @@ public void EvalWithAnonModel()
 
             var content = output.ToString();
 
-            Assert.That(content.Contains("<p>42 Hello</p>"));
+            Assert.That(content, Does.Contain("<p>42 Hello</p>"));
         }
 
         public class ScopedCulture : IDisposable
@@ -567,8 +597,11 @@ public void EvalWithFormatString()
 
                 var content = output.ToString();
 
-                Assert.That(content.Contains("<p>134,567.89</p>"));
-                Assert.That(content.Contains("<p>1971/10/14</p>"));
+                Assert.Multiple(() =>
+                {
+                    Assert.That(content, Does.Contain("<p>134,567.89</p>"));
+                    Assert.That(content, Does.Contain("<p>1971/10/14</p>"));
+                });
             }
         }
 
@@ -593,32 +626,35 @@ public void RenderPartialSharesState()
                             "</ul>",
                             "alphabetagammadelta");
 
-            Assert.IsFalse(content.Contains("foo2"));
-            Assert.IsFalse(content.Contains("bar4"));
-            Assert.IsFalse(content.Contains("quux7"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content.Contains("foo2"), Is.False);
+                Assert.That(content.Contains("bar4"), Is.False);
+                Assert.That(content.Contains("quux7"), Is.False);
+            });
         }
 
         [Test]
         public void CanLocateViewInArea()
         {
             controllerContext.RouteData.Values.Add("area", "admin");
-            
+
             var result = factory.FindView(controllerContext, "index", null);
 
             var viewContext = new ViewContext(controllerContext, result.View, new ViewDataDictionary(), new TempDataDictionary(), output);
             viewContext.View.Render(viewContext, output);
             //mocks.VerifyAll();
 
-            Assert.AreEqual("<p>default view admin area</p>", output.ToString().Trim());
+            Assert.That(output.ToString().Trim(), Is.EqualTo("<p>default view admin area</p>"));
         }
 
         [Test]
         public void CanLocateViewInAreaWithLayout()
         {
             controllerContext.RouteData.Values.Add("area", "admin");
-            
+
             var result = factory.FindView(controllerContext, "index", "layout");
-            
+
             var viewContext = new ViewContext(controllerContext, result.View, new ViewDataDictionary(), new TempDataDictionary(), output);
             viewContext.View.Render(viewContext, output);
             //mocks.VerifyAll();
@@ -634,9 +670,9 @@ public void CanLocateViewInAreaWithLayout()
         public void CanLocateViewInAreaWithLayoutInArea()
         {
             controllerContext.RouteData.Values.Add("area", "admin");
-            
+
             var result = factory.FindView(controllerContext, "index", "speciallayout");
-            
+
             var viewContext = new ViewContext(controllerContext, result.View, new ViewDataDictionary(), new TempDataDictionary(), output);
             viewContext.View.Render(viewContext, output);
             //mocks.VerifyAll();
@@ -652,14 +688,14 @@ public void CanLocateViewInAreaWithLayoutInArea()
         public void CanLocatePartialViewInArea()
         {
             controllerContext.RouteData.Values.Add("area", "admin");
-            
+
             var result = factory.FindPartialView(controllerContext, "index");
-            
+
             var viewContext = new ViewContext(controllerContext, result.View, new ViewDataDictionary(), new TempDataDictionary(), output);
             viewContext.View.Render(viewContext, output);
             //mocks.VerifyAll();
 
-            Assert.AreEqual("<p>default view admin area</p>", output.ToString().Trim());
+            Assert.That(output.ToString().Trim(), Is.EqualTo("<p>default view admin area</p>"));
         }
 
         [Test, Ignore("Pending task #28")]
@@ -720,14 +756,14 @@ public void ViewContextWriterWillFollowOutputScope()
                 "</form",
                 "[3]");
         }
-        
+
         [Test]
         public void AutoencodeIgnoresHtmlHelpers()
         {
-             FindViewAndRender("AutoencodeIgnoresHtmlHelpers");
+            FindViewAndRender("AutoencodeIgnoresHtmlHelpers");
 
             var content = output.ToString();
-            
+
             ContainsInOrder(content,
                             "[1:&lt;p&gt;foo&lt;/p&gt;]",
                             "[2:<p>foo</p>]",
@@ -741,7 +777,7 @@ public void AutoencodeIgnoresMacros()
             FindViewAndRender("AutoencodeIgnoresMacros");
 
             var content = output.ToString();
-            
+
             ContainsInOrder(
                 content,
                 "[1:<p>foo</p>]",
diff --git a/src/Spark.Web.Mvc.Tests/SparkViewTester.cs b/src/Spark.Web.Mvc.Tests/SparkViewTester.cs
index d82f1c75..663c93f8 100644
--- a/src/Spark.Web.Mvc.Tests/SparkViewTester.cs
+++ b/src/Spark.Web.Mvc.Tests/SparkViewTester.cs
@@ -67,25 +67,25 @@ public void SiteRootActsAsSafePrefix()
             var viewContext = new ViewContext(new ControllerContext(httpContext, new RouteData(), controller), view, new ViewDataDictionary(), new TempDataDictionary(), new StringWriter());
 
             view = new StubSparkView { ViewContext = viewContext };
-            Assert.AreEqual("", view.SiteRoot);
+            Assert.That(view.SiteRoot, Is.EqualTo(""));
 
             view = new StubSparkView { ViewContext = viewContext };
-            Assert.AreEqual("/TestApp", view.SiteRoot);
+            Assert.That(view.SiteRoot, Is.EqualTo("/TestApp"));
 
             view = new StubSparkView { ViewContext = viewContext };
-            Assert.AreEqual("/TestApp", view.SiteRoot);
+            Assert.That(view.SiteRoot, Is.EqualTo("/TestApp"));
 
             view = new StubSparkView { ViewContext = viewContext };
-            Assert.AreEqual("", view.SiteRoot);
+            Assert.That(view.SiteRoot, Is.EqualTo(""));
 
             view = new StubSparkView { ViewContext = viewContext };
-            Assert.AreEqual("", view.SiteRoot);
+            Assert.That(view.SiteRoot, Is.EqualTo(""));
 
             view = new StubSparkView { ViewContext = viewContext };
-            Assert.AreEqual("/TestApp", view.SiteRoot);
+            Assert.That(view.SiteRoot, Is.EqualTo("/TestApp"));
 
             view = new StubSparkView { ViewContext = viewContext };
-            Assert.AreEqual("/TestApp", view.SiteRoot);
+            Assert.That(view.SiteRoot, Is.EqualTo("/TestApp"));
 
             mocks.VerifyAll();
         }
@@ -104,14 +104,16 @@ public override void Render()
         public void CanAccessModelViaModel()
         {
             var view = new ModelViewTest { ViewData = { Model = "asd" } };
-            Assert.AreEqual("asd", view.Model);
+
+            Assert.That(view.Model, Is.EqualTo("asd"));
         }
 
         [Test, Ignore("Doesn't work for automated build")]
         public void CanAccessViewBagViaView()
         {
             var view = new ModelViewTest { ViewBag = { SomeProperty = "dgf" } };
-            Assert.AreEqual("dgf", view.ViewBag.SomeProperty);
+
+            Assert.That(view.ViewBag.SomeProperty, Is.EqualTo("dgf"));
         }
     }
 }
diff --git a/src/Spark.Web.Mvc.Tests/VisualBasicViewTester.cs b/src/Spark.Web.Mvc.Tests/VisualBasicViewTester.cs
index e9f45635..4a934c6f 100644
--- a/src/Spark.Web.Mvc.Tests/VisualBasicViewTester.cs
+++ b/src/Spark.Web.Mvc.Tests/VisualBasicViewTester.cs
@@ -281,7 +281,7 @@ public void ContentNameAndUseContentChunk()
 [<use content='foo'/>]
 ");
             var contents = Render("index");
-            Assert.That(contents.Trim(), Is.EqualTo("[bar]"));            
+            Assert.That(contents.Trim(), Is.EqualTo("[bar]"));
         }
 
         [Test]
@@ -291,7 +291,7 @@ public void RenderPartialChunk()
             _viewFolder.Add(Path.Combine("shared", "_foo.spark"), @"bar");
 
             var contents = Render("index");
-            Assert.That(contents.Trim(), Is.EqualTo("[bar]"));    
+            Assert.That(contents.Trim(), Is.EqualTo("[bar]"));
         }
 
         [Test]
diff --git a/src/Spark.Web.Mvc/Spark.Web.Mvc.csproj b/src/Spark.Web.Mvc/Spark.Web.Mvc.csproj
index c83d9dee..5ecf6d3c 100644
--- a/src/Spark.Web.Mvc/Spark.Web.Mvc.csproj
+++ b/src/Spark.Web.Mvc/Spark.Web.Mvc.csproj
@@ -55,6 +55,6 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNet.Mvc" Version="5.3.0" />
     <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.0" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/Spark.Web.Tests/BatchCompilationTester.cs b/src/Spark.Web.Tests/BatchCompilationTester.cs
index 61d58e57..04939e98 100644
--- a/src/Spark.Web.Tests/BatchCompilationTester.cs
+++ b/src/Spark.Web.Tests/BatchCompilationTester.cs
@@ -67,21 +67,21 @@ public void CompileMultipleDescriptors()
                     .GetTypes()
                     .Where(x => x.BaseType == typeof(Tests.Stubs.StubSparkView));
 
-            Assert.AreEqual(2, types.Count());
+            Assert.That(types.Count(), Is.EqualTo(2));
 
             var entry0 = engine.GetEntry(descriptors[0]);
             var view0 = entry0.CreateInstance();
             var result0 = view0.RenderView();
 
-            Assert.AreEqual("<p>Hello world</p>", result0);
+            Assert.That(result0, Is.EqualTo("<p>Hello world</p>"));
 
             var entry1 = engine.GetEntry(descriptors[1]);
             var view1 = entry1.CreateInstance();
             var result1 = view1.RenderView();
 
-            Assert.AreEqual("<ol><li>one</li><li>two</li></ol>", result1);
+            Assert.That(result1, Is.EqualTo("<ol><li>one</li><li>two</li></ol>"));
 
-            Assert.AreSame(view0.GetType().Assembly, view1.GetType().Assembly);
+            Assert.That(view1.GetType().Assembly, Is.SameAs(view0.GetType().Assembly));
         }
 
         [Test]
@@ -89,7 +89,7 @@ public void DescriptorsAreEqual()
         {
             var descriptor = new SparkViewDescriptor()
                 .SetTargetNamespace("Foo")
-                .AddTemplate(Path.Combine("Home","Index.spark"));
+                .AddTemplate(Path.Combine("Home", "Index.spark"));
 
             var assembly = engine.BatchCompilation(new[] { descriptor });
 
@@ -98,8 +98,8 @@ public void DescriptorsAreEqual()
                     .GetTypes()
                     .Where(x => x.BaseType == typeof(Tests.Stubs.StubSparkView))
                     .ToArray();
-            
-            Assert.AreEqual(1, types.Count());
+
+            Assert.That(types.Count(), Is.EqualTo(1));
 
             var attribs = types[0].GetCustomAttributes(typeof(SparkViewAttribute), false);
             var sparkViewAttrib = (SparkViewAttribute)attribs[0];
@@ -107,13 +107,13 @@ public void DescriptorsAreEqual()
             var key0 = descriptor;
             var key1 = sparkViewAttrib.BuildDescriptor();
 
-            Assert.AreEqual(key0, key1);
+            Assert.That(key1, Is.EqualTo(key0));
         }
 
         [Test]
         public void DescriptorsWithNoTargetNamespace()
         {
-            var descriptor = new SparkViewDescriptor().AddTemplate(Path.Combine("Home","Index.spark"));
+            var descriptor = new SparkViewDescriptor().AddTemplate(Path.Combine("Home", "Index.spark"));
 
             var assembly = engine.BatchCompilation(new[] { descriptor });
 
@@ -123,7 +123,7 @@ public void DescriptorsWithNoTargetNamespace()
                     .Where(x => x.BaseType == typeof(Tests.Stubs.StubSparkView))
                     .ToArray();
 
-            Assert.AreEqual(1, types.Count());
+            Assert.That(types.Count(), Is.EqualTo(1));
 
             var attribs = types[0].GetCustomAttributes(typeof(SparkViewAttribute), false);
             var sparkViewAttrib = (SparkViewAttribute)attribs[0];
@@ -131,7 +131,7 @@ public void DescriptorsWithNoTargetNamespace()
             var key0 = descriptor;
             var key1 = sparkViewAttrib.BuildDescriptor();
 
-            Assert.AreEqual(key0, key1);
+            Assert.That(key1, Is.EqualTo(key0));
         }
 
         [Test]
@@ -139,7 +139,7 @@ public void LoadCompiledViews()
         {
             var descriptors = engine.LoadBatchCompilation(GetType().Assembly);
 
-            Assert.AreEqual(2, descriptors.Count);
+            Assert.That(descriptors.Count, Is.EqualTo(2));
 
             var view1 = engine.CreateInstance(
                 new SparkViewDescriptor()
@@ -147,7 +147,7 @@ public void LoadCompiledViews()
                     .AddTemplate(Path.Combine("Foo", "Bar.spark"))
                     .AddTemplate(Path.Combine("Shared", "Quux.spark")));
 
-            Assert.AreEqual(typeof(View1), view1.GetType());
+            Assert.That(view1.GetType(), Is.EqualTo(typeof(View1)));
 
             var view2 = engine.CreateInstance(
                 new SparkViewDescriptor()
@@ -155,7 +155,7 @@ public void LoadCompiledViews()
                     .AddTemplate(Path.Combine("Hello", "World.spark"))
                     .AddTemplate(Path.Combine("Shared", "Default.spark")));
 
-            Assert.AreEqual(typeof(View2), view2.GetType());
+            Assert.That(view2.GetType(), Is.EqualTo(typeof(View2)));
         }
 
         [Test]
@@ -170,7 +170,7 @@ public void AvoidNotSupportedExceptionForDynamicAssemblies()
             var type = moduleBuilder.DefineType("DynamicType", TypeAttributes.Public).CreateType();
             assemblyBuilder.Save("DynamicAssembly.dll");
 
-            Assert.IsTrue(type.Assembly.IsDynamic());
+            Assert.That(type.Assembly.IsDynamic(), Is.True);
         }
     }
 }
diff --git a/src/Spark.Web.Tests/Bindings/BindingExecutionTester.cs b/src/Spark.Web.Tests/Bindings/BindingExecutionTester.cs
index 11df38c6..a0214acf 100644
--- a/src/Spark.Web.Tests/Bindings/BindingExecutionTester.cs
+++ b/src/Spark.Web.Tests/Bindings/BindingExecutionTester.cs
@@ -131,7 +131,8 @@ public void BindingRefersToAttributeWithMixedCodeAndTextWithAttributeNotSupplied
         }
 
         [Test]
-        public void BindingRefersToAttributeWithUnescapedCode() {
+        public void BindingRefersToAttributeWithUnescapedCode()
+        {
             this._viewFolder.Add("bindings.xml", @"<bindings><element name='hello'>World(@foo)</element></bindings>");
             this._viewFolder.Add(Path.Combine("home", "index.spark"), @"<p><hello foo=""'one '+(3+4)+' two '+SiteRoot+' three'""/></p><macro name='World' beta='string'>success ${beta}!</macro>");
 
@@ -235,9 +236,10 @@ public void ChildReferenceWillSpoolAndProvideContentAsString()
             var contents = this.Render("index");
             Assert.That(contents, Is.EqualTo(@"<p>3world5</p>"));
         }
-        
+
         [Test, Ignore("The child::* is always treated as text. So this test does not represent the current capabilities.")]
-        public void ChildReferenceWillSpoolAndProvideContentAsCode() {
+        public void ChildReferenceWillSpoolAndProvideContentAsCode()
+        {
             this._viewFolder.Add("bindings.xml", @"<bindings>
 <element name='hello'>'@a' + child::* + '@b'</element>
 </bindings>");
@@ -261,14 +263,14 @@ public void ChildReferenceWillNotMatchSelfClosingElements()
 
             Assert.That(contents, Is.EqualTo(@"<p>1world2345no text6</p>"));
         }
-        
+
         [Test]
         public void CurleyBracesExpandAsDictionaryInitialization()
         {
             this._viewFolder.Add("bindings.xml", @"<bindings>
 <element name='hello'>new System.Collections.Generic.Dictionary&lt;string,object&gt;{{'@*'}}.Count</element>
 </bindings>");
-            
+
             this._viewFolder.Add(Path.Combine("home", "index.spark"), @"<p><hello a='foo' b='bar'/><hello/><hello></hello><hello x1='' x2='' x3='' x4='' x5=''/></p>");
 
             var contents = this.Render("index");
@@ -280,7 +282,7 @@ public void CurleyBracesExpandAsDictionaryInitialization()
         public void ExpressionNextToBindingShouldMaintainWhiteSpace()
         {
             this._viewFolder.Add("bindings.xml", @"<bindings><element name='Text'>child::*</element></bindings>");
-            this._viewFolder.Add(Path.Combine("home","index.spark"), @"<p>${'1234'}  <Text>Smith St</Text></p>");
+            this._viewFolder.Add(Path.Combine("home", "index.spark"), @"<p>${'1234'}  <Text>Smith St</Text></p>");
 
             var contents = this.Render("index");
             Assert.That(contents, Is.EqualTo(@"<p>1234  Smith St</p>"));
@@ -290,7 +292,7 @@ public void ExpressionNextToBindingShouldMaintainWhiteSpace()
         public void ExpressionNextToBindingShouldMaintainWhiteSpaceWithLoops()
         {
             this._viewFolder.Add("bindings.xml", @"<bindings><element name='Text'>child::*</element></bindings>");
-            this._viewFolder.Add(Path.Combine("home","index.spark"), @"<var names=""new [] {'alpha', 'beta', 'gamma'}""/>
+            this._viewFolder.Add(Path.Combine("home", "index.spark"), @"<var names=""new [] {'alpha', 'beta', 'gamma'}""/>
 <ul>
 <for each=""var name in names"">
     <li>${name} <Text>is</Text> okay too I suppose. </li>
@@ -310,7 +312,7 @@ public void ExpressionNextToBindingShouldMaintainWhiteSpaceWithLoops()
         public void ExpressionNextToBindingShouldMaintainWhiteSpaceWithLoopsInternal()
         {
             this._viewFolder.Add("bindings.xml", @"<bindings><element name='Text'>child::*</element></bindings>");
-            this._viewFolder.Add(Path.Combine("home","index.spark"), @"<var names=""new [] {'alpha', 'beta', 'gamma'}""/>
+            this._viewFolder.Add(Path.Combine("home", "index.spark"), @"<var names=""new [] {'alpha', 'beta', 'gamma'}""/>
 <ul>
     <li each=""var name in names"">${name} <Text>is</Text> okay too I suppose. </li>
 </ul>");
diff --git a/src/Spark.Web.Tests/Caching/CacheElementTester.cs b/src/Spark.Web.Tests/Caching/CacheElementTester.cs
index d51b261e..639cf9d9 100644
--- a/src/Spark.Web.Tests/Caching/CacheElementTester.cs
+++ b/src/Spark.Web.Tests/Caching/CacheElementTester.cs
@@ -49,8 +49,8 @@ public void Init()
                 .AddSingleton<ICacheService, StubCacheService>()
                 .BuildServiceProvider();
 
-            this._viewFolder = (InMemoryViewFolder) sp.GetService<IViewFolder>();
-            this._cacheService = (StubCacheService) sp.GetService<ICacheService>();
+            this._viewFolder = (InMemoryViewFolder)sp.GetService<IViewFolder>();
+            this._cacheService = (StubCacheService)sp.GetService<ICacheService>();
 
             this._factory = new StubViewFactory
             {
@@ -85,14 +85,17 @@ public void TemplateRunsNormallyThroughCacheMiss()
 </div>");
             var calls = 0;
             var contents = this.Render("index", new StubViewData<Func<string>>
-                                           {
-                                               Model = () => (++calls).ToString()
-                                           });
-            Assert.That(contents, Is.EqualTo(@"
+            {
+                Model = () => (++calls).ToString()
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>1</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(1));
+                Assert.That(calls, Is.EqualTo(1));
+            });
         }
 
         [Test]
@@ -107,23 +110,29 @@ public void TemplateDoesNotRunThroughCacheHit()
 </div>");
             int calls = 0;
             var data = new StubViewData<Func<string>>
-                       {
-                           Model = () => (++calls).ToString()
-                       };
+            {
+                Model = () => (++calls).ToString()
+            };
 
             var contents = this.Render("index", data);
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>1</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(1));
+                Assert.That(calls, Is.EqualTo(1));
+            });
 
             contents = this.Render("index", data);
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>1</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(1));
+                Assert.That(calls, Is.EqualTo(1));
+            });
 
         }
 
@@ -147,18 +156,24 @@ public void CacheInMacroShouldActAsSameSite()
             };
 
             var contents = this.Render("index", data);
-            Assert.That(contents, Tests.Contains.InOrder(
-                "<p>1</p>",
-                "<p>1</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Tests.Contains.InOrder(
+                            "<p>1</p>",
+                            "<p>1</p>"));
 
-            Assert.That(calls, Is.EqualTo(1));
+                Assert.That(calls, Is.EqualTo(1));
+            });
 
             contents = this.Render("index", data);
-            Assert.That(contents, Tests.Contains.InOrder(
-                "<p>1</p>",
-                "<p>1</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Tests.Contains.InOrder(
+                            "<p>1</p>",
+                            "<p>1</p>"));
 
-            Assert.That(calls, Is.EqualTo(1));
+                Assert.That(calls, Is.EqualTo(1));
+            });
         }
 
         [Test]
@@ -182,21 +197,27 @@ public void MultipleCachesShouldActAsDifferentSite()
             };
 
             var contents = this.Render("index", data);
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>1</p>
 <p>2</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(2));
+                Assert.That(calls, Is.EqualTo(2));
+            });
 
 
             contents = this.Render("index", data);
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>1</p>
 <p>2</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(2));
+                Assert.That(calls, Is.EqualTo(2));
+            });
         }
 
         [Test]
@@ -236,8 +257,10 @@ public void NamedContentShouldIndividuallySpoolAndCache()
             };
 
             var contents = this.Render("index", data);
-            Assert.That(calls, Is.EqualTo(8));
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(calls, Is.EqualTo(8));
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 cache
 <p>2[2]c</p>
@@ -250,11 +273,14 @@ public void NamedContentShouldIndividuallySpoolAndCache()
 <p>b6[6]</p>
 <p>8[8]</p>
 </div>"));
+            });
 
 
             contents = this.Render("index", data);
-            Assert.That(calls, Is.EqualTo(12));
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(calls, Is.EqualTo(12));
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 cache
 <p>2[2]c</p>
@@ -267,6 +293,7 @@ public void NamedContentShouldIndividuallySpoolAndCache()
 <p>b10[6]</p>
 <p>12[8]</p>
 </div>"));
+            });
         }
 
 
@@ -304,8 +331,10 @@ public void OutputWhileNamedContentActiveShouldAppearOnceAtCorrectTarget()
             };
 
             var contents = this.Render("index", data);
-            Assert.That(calls, Is.EqualTo(6));
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(calls, Is.EqualTo(6));
+                Assert.That(contents, Is.EqualTo(@"
 <ul>
 <li>2[2]</li>
 <li>5[5]</li>
@@ -315,11 +344,14 @@ public void OutputWhileNamedContentActiveShouldAppearOnceAtCorrectTarget()
 <li>4[4]c</li>
 <li>6[6]</li>
 </ul>"));
+            });
 
 
             contents = this.Render("index", data);
-            Assert.That(calls, Is.EqualTo(10));
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(calls, Is.EqualTo(10));
+                Assert.That(contents, Is.EqualTo(@"
 <ul>
 <li>8[2]</li>
 <li>9[5]</li>
@@ -329,6 +361,7 @@ public void OutputWhileNamedContentActiveShouldAppearOnceAtCorrectTarget()
 <li>4[4]c</li>
 <li>10[6]</li>
 </ul>"));
+            });
         }
 
 
@@ -356,22 +389,28 @@ public void OnceFlagsSetWhenCacheRecordedShouldBeSetWhenCacheReplayed()
             };
 
             var contents = this.Render("index", data);
-            Assert.That(calls, Is.EqualTo(3));
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(calls, Is.EqualTo(3));
+                Assert.That(contents, Is.EqualTo(@"
 <ul>
 <li>1[1]</li>
 <li>2[2]</li>
 <li>3[4]</li>
 </ul>"));
+            });
 
             contents = this.Render("index", data);
-            Assert.That(calls, Is.EqualTo(5));
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(calls, Is.EqualTo(5));
+                Assert.That(contents, Is.EqualTo(@"
 <ul>
 <li>4[1]</li>
 <li>2[2]</li>
 <li>5[4]</li>
 </ul>"));
+            });
         }
 
         [Test]
@@ -484,25 +523,28 @@ public void CommaCreatesMultiPartKey()
 
             var calls = 0;
             var data = new StubViewData<Func<string>>
-                       {
-                           Model = () => (++calls).ToString()
-                       };
+            {
+                Model = () => (++calls).ToString()
+            };
 
             var contents = this.Render("index", data);
-            Assert.That(contents, Tests.Contains.InOrder(
-                "<p>1:1</p>",
-                "<p>2:2</p>",
-                "<p>3:3</p>",
-                "<p>1:4</p>",
-                "<p>2:5</p>",
-                "<p>3:6</p>"));
-
-            Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "1\u001f0"), Is.EqualTo(1));
-            Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "2\u001f1"), Is.EqualTo(1));
-            Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "3\u001f2"), Is.EqualTo(1));
-            Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "1\u001f3"), Is.EqualTo(1));
-            Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "2\u001f4"), Is.EqualTo(1));
-            Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "3\u001f5"), Is.EqualTo(1));
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Tests.Contains.InOrder(
+                            "<p>1:1</p>",
+                            "<p>2:2</p>",
+                            "<p>3:3</p>",
+                            "<p>1:4</p>",
+                            "<p>2:5</p>",
+                            "<p>3:6</p>"));
+
+                Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "1\u001f0"), Is.EqualTo(1));
+                Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "2\u001f1"), Is.EqualTo(1));
+                Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "3\u001f2"), Is.EqualTo(1));
+                Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "1\u001f3"), Is.EqualTo(1));
+                Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "2\u001f4"), Is.EqualTo(1));
+                Assert.That(this._cacheService.AllKeys.Count(x => x.Substring(32) == "3\u001f5"), Is.EqualTo(1));
+            });
         }
 
 
@@ -525,34 +567,46 @@ public void SignalWillExpireOutputCachingEntry()
             data["datasignal"] = signal;
 
             var contents = this.Render("index", data);
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>1</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(1));
+                Assert.That(calls, Is.EqualTo(1));
+            });
 
             contents = this.Render("index", data);
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>1</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(1));
+                Assert.That(calls, Is.EqualTo(1));
+            });
 
             signal.FireChanged();
 
             contents = this.Render("index", data);
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>2</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(2));
+                Assert.That(calls, Is.EqualTo(2));
+            });
 
             contents = this.Render("index", data);
-            Assert.That(contents, Is.EqualTo(@"
+            Assert.Multiple(() =>
+            {
+                Assert.That(contents, Is.EqualTo(@"
 <div>
 <p>2</p>
 </div>"));
-            Assert.That(calls, Is.EqualTo(2));
+                Assert.That(calls, Is.EqualTo(2));
+            });
         }
     }
 }
diff --git a/src/Spark.Web.Tests/Caching/CacheOriginatorTester.cs b/src/Spark.Web.Tests/Caching/CacheOriginatorTester.cs
index 75cd4c2f..d95123cc 100644
--- a/src/Spark.Web.Tests/Caching/CacheOriginatorTester.cs
+++ b/src/Spark.Web.Tests/Caching/CacheOriginatorTester.cs
@@ -17,7 +17,7 @@ public class CacheOriginatorTester
         [SetUp]
         public void Init()
         {
-            this._subject = new SparkViewContext {Output = new SpoolWriter()};
+            this._subject = new SparkViewContext { Output = new SpoolWriter() };
             this._originator = new CacheOriginator(this._subject);
 
             this._subject2 = new SparkViewContext { Output = new SpoolWriter() };
@@ -37,11 +37,11 @@ public void ApplyMementoShouldAddTextToStream()
         {
             this._originator.BeginMemento();
             this._subject.Output.Write("Hello");
-            this._subject.Output.Write("World");            
+            this._subject.Output.Write("World");
             var memento = this._originator.EndMemento();
 
             this._originator2.DoMemento(memento);
-            Assert.That(this._subject2.Output.ToString(), Is.EqualTo("HelloWorld"));            
+            Assert.That(this._subject2.Output.ToString(), Is.EqualTo("HelloWorld"));
         }
 
         [Test]
@@ -57,8 +57,11 @@ public void AdditionalWritesBeforeAndAfterAreMoot()
             this._originator2.DoMemento(memento);
             this._subject2.Output.Write("Epsilon");
 
-            Assert.That(this._subject.Output.ToString(), Is.EqualTo("AlphaBetaGamma"));
-            Assert.That(this._subject2.Output.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(this._subject.Output.ToString(), Is.EqualTo("AlphaBetaGamma"));
+                Assert.That(this._subject2.Output.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
+            });
         }
 
         [Test]
@@ -74,8 +77,11 @@ public void DisposingSpoolWritersShouldNotDamageCaches()
             this._originator2.DoMemento(memento);
             this._subject2.Output.Write("Epsilon");
 
-            Assert.That(this._subject.Output.ToString(), Is.EqualTo("AlphaBetaGamma"));
-            Assert.That(this._subject2.Output.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(this._subject.Output.ToString(), Is.EqualTo("AlphaBetaGamma"));
+                Assert.That(this._subject2.Output.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
+            });
 
             this._subject.Output.Dispose();
             Assert.That(this._subject2.Output.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
@@ -83,8 +89,8 @@ public void DisposingSpoolWritersShouldNotDamageCaches()
 
             var subject3 = new SparkViewContext { Output = new SpoolWriter() };
 
-            subject3.Output.Write("Zeta"); 
-            new CacheOriginator(subject3).DoMemento(memento);            
+            subject3.Output.Write("Zeta");
+            new CacheOriginator(subject3).DoMemento(memento);
             subject3.Output.Write("Eta");
             Assert.That(subject3.Output.ToString(), Is.EqualTo("ZetaBetaEta"));
         }
@@ -100,8 +106,11 @@ public void AddedNamedContentAddedWhenApplied()
 
             this._originator2.DoMemento(memento);
 
-            Assert.That(this._subject2.Output.ToString(), Is.EqualTo("alpha"));
-            Assert.That(this._subject2.Content["foo"].ToString(), Is.EqualTo("beta"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(this._subject2.Output.ToString(), Is.EqualTo("alpha"));
+                Assert.That(this._subject2.Content["foo"].ToString(), Is.EqualTo("beta"));
+            });
         }
 
         [Test]
@@ -120,8 +129,11 @@ public void WrittenNamedContentWrittenWhenApplied()
 
             this._originator2.DoMemento(memento);
 
-            Assert.That(this._subject2.Output.ToString(), Is.EqualTo("alpha"));
-            Assert.That(this._subject2.Content["foo"].ToString(), Is.EqualTo("worldbeta"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(this._subject2.Output.ToString(), Is.EqualTo("alpha"));
+                Assert.That(this._subject2.Content["foo"].ToString(), Is.EqualTo("worldbeta"));
+            });
         }
 
         [Test]
@@ -137,15 +149,18 @@ public void OnceCollectionExtendedWhenApplied()
             this._originator2.DoMemento(memento);
             this._subject2.OnceTable.Add("ahop", "yuul");
 
-            Assert.That(this._subject.OnceTable.Count(), Is.EqualTo(3));
-            Assert.That(this._subject.OnceTable["hana"], Is.EqualTo("duul"));
-            Assert.That(this._subject.OnceTable["set"], Is.EqualTo("net"));
-            Assert.That(this._subject.OnceTable["daset"], Is.EqualTo("yaset"));
-
-            Assert.That(this._subject2.OnceTable.Count(), Is.EqualTo(3));
-            Assert.That(this._subject2.OnceTable["ilgot"], Is.EqualTo("yadul"));
-            Assert.That(this._subject2.OnceTable["set"], Is.EqualTo("net"));
-            Assert.That(this._subject2.OnceTable["ahop"], Is.EqualTo("yuul"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(this._subject.OnceTable.Count(), Is.EqualTo(3));
+                Assert.That(this._subject.OnceTable["hana"], Is.EqualTo("duul"));
+                Assert.That(this._subject.OnceTable["set"], Is.EqualTo("net"));
+                Assert.That(this._subject.OnceTable["daset"], Is.EqualTo("yaset"));
+
+                Assert.That(this._subject2.OnceTable.Count(), Is.EqualTo(3));
+                Assert.That(this._subject2.OnceTable["ilgot"], Is.EqualTo("yadul"));
+                Assert.That(this._subject2.OnceTable["set"], Is.EqualTo("net"));
+                Assert.That(this._subject2.OnceTable["ahop"], Is.EqualTo("yuul"));
+            });
         }
 
         [Test]
@@ -155,7 +170,7 @@ public void OutputWhileNamedContentActiveShouldAppearOnceAtCorrectTarget()
             this._subject.Content.Add("bar", new SpoolWriter());
             this._subject.Output = this._subject.Content["foo"];
             this._subject.Output.Write("hello");
-            
+
             this._originator.BeginMemento();
             this._subject.Content["foo"].Write(" ");
             this._subject.Content["bar"].Write("yadda");
@@ -163,16 +178,22 @@ public void OutputWhileNamedContentActiveShouldAppearOnceAtCorrectTarget()
             this._subject.Content["foo"].Write("!");
             var memento = this._originator.EndMemento();
 
-            Assert.That(this._subject.Output.ToString(), Is.EqualTo("hello world!"));
-            Assert.That(this._subject.Content["foo"].ToString(), Is.EqualTo("hello world!"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(this._subject.Output.ToString(), Is.EqualTo("hello world!"));
+                Assert.That(this._subject.Content["foo"].ToString(), Is.EqualTo("hello world!"));
+            });
 
             this._subject2.Content.Add("foo", new SpoolWriter());
             this._subject2.Output = this._subject2.Content["foo"];
             this._subject2.Output.Write("hello");
             this._originator2.DoMemento(memento);
 
-            Assert.That(this._subject2.Output.ToString(), Is.EqualTo("hello world!"));
-            Assert.That(this._subject2.Content["foo"].ToString(), Is.EqualTo("hello world!"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(this._subject2.Output.ToString(), Is.EqualTo("hello world!"));
+                Assert.That(this._subject2.Content["foo"].ToString(), Is.EqualTo("hello world!"));
+            });
         }
     }
 }
diff --git a/src/Spark.Web.Tests/Caching/CacheSignalTester.cs b/src/Spark.Web.Tests/Caching/CacheSignalTester.cs
index 7af5ec11..45a54202 100644
--- a/src/Spark.Web.Tests/Caching/CacheSignalTester.cs
+++ b/src/Spark.Web.Tests/Caching/CacheSignalTester.cs
@@ -72,7 +72,7 @@ protected override void Enable()
             protected override void Disable()
             {
                 Assert.That(this.Enabled, Is.True);
-                this.Enabled = false;                
+                this.Enabled = false;
             }
 
             public bool Enabled { get; set; }
diff --git a/src/Spark.Web.Tests/Caching/CacheUtilitiesTester.cs b/src/Spark.Web.Tests/Caching/CacheUtilitiesTester.cs
index 867e6387..f3386622 100644
--- a/src/Spark.Web.Tests/Caching/CacheUtilitiesTester.cs
+++ b/src/Spark.Web.Tests/Caching/CacheUtilitiesTester.cs
@@ -20,7 +20,7 @@ public void KeyConcatinationShouldSimplyStringConcatWithZeroOrOneParts()
 
             using (new CurrentCultureScope(""))
             {
-                var id1b = CacheUtilities.ToIdentifier("foo", new object[] {45.2});
+                var id1b = CacheUtilities.ToIdentifier("foo", new object[] { 45.2 });
                 Assert.That(id1b, Is.EqualTo("foo45.2"));
             }
         }
@@ -33,7 +33,7 @@ public void KeyMultipleKeysHaveUnitSeperatorDelimitingParts()
 
             using (new CurrentCultureScope(""))
             {
-                var id3 = CacheUtilities.ToIdentifier("foo", new object[] {45.2, null, this});
+                var id3 = CacheUtilities.ToIdentifier("foo", new object[] { 45.2, null, this });
                 Assert.That(id3, Is.EqualTo("foo45.2\u001f\u001fSpark.Caching.CacheUtilitiesTester"));
             }
         }
diff --git a/src/Spark.Web.Tests/Caching/TextWriterOriginatorTester.cs b/src/Spark.Web.Tests/Caching/TextWriterOriginatorTester.cs
index c96049cd..3d76ad61 100644
--- a/src/Spark.Web.Tests/Caching/TextWriterOriginatorTester.cs
+++ b/src/Spark.Web.Tests/Caching/TextWriterOriginatorTester.cs
@@ -24,8 +24,11 @@ public void StringWriterOriginatorBuildsMementoWithChanges()
             TextWriterOriginator.Create(writer2).DoMemento(memento);
             writer2.Write("Epsilon");
 
-            Assert.That(writer.ToString(), Is.EqualTo("AlphaBetaGamma"));
-            Assert.That(writer2.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(writer.ToString(), Is.EqualTo("AlphaBetaGamma"));
+                Assert.That(writer2.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
+            });
         }
 
         [Test]
@@ -48,8 +51,11 @@ public void SpoolWriterOriginatorBuildsMementoWithChanges()
             TextWriterOriginator.Create(writer2).DoMemento(memento);
             writer2.Write("Epsilon");
 
-            Assert.That(writer.ToString(), Is.EqualTo("AlphaBetaGamma"));
-            Assert.That(writer2.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(writer.ToString(), Is.EqualTo("AlphaBetaGamma"));
+                Assert.That(writer2.ToString(), Is.EqualTo("DeltaBetaEpsilon"));
+            });
         }
     }
 }
diff --git a/src/Spark.Web.Tests/ClientsideCompilerTester.cs b/src/Spark.Web.Tests/ClientsideCompilerTester.cs
index c5ad7641..5e66939e 100644
--- a/src/Spark.Web.Tests/ClientsideCompilerTester.cs
+++ b/src/Spark.Web.Tests/ClientsideCompilerTester.cs
@@ -45,13 +45,13 @@ public void GenerateSimpleTemplate()
 
             var descriptor = new SparkViewDescriptor()
                 .SetLanguage(LanguageType.Javascript)
-                .AddTemplate(Path.Combine("Clientside","simple.spark"));
+                .AddTemplate(Path.Combine("Clientside", "simple.spark"));
 
 
             var entry = engine.CreateEntry(descriptor);
 
-            Assert.IsNotNull(entry.SourceCode);
-            Assert.IsNotEmpty(entry.SourceCode);
+            Assert.That(entry.SourceCode, Is.Not.Null);
+            Assert.That(entry.SourceCode, Is.Not.Empty);
         }
 
         [Test]
@@ -67,12 +67,12 @@ public void AnonymousTypeBecomesHashLikeObject()
 
             var descriptor = new SparkViewDescriptor()
                 .SetLanguage(LanguageType.Javascript)
-                .AddTemplate(Path.Combine("Clientside","AnonymousTypeBecomesHashLikeObject.spark"));
+                .AddTemplate(Path.Combine("Clientside", "AnonymousTypeBecomesHashLikeObject.spark"));
 
             var entry = engine.CreateEntry(descriptor);
 
-            Assert.IsNotNull(entry.SourceCode);
-            Assert.IsNotEmpty(entry.SourceCode);
+            Assert.That(entry.SourceCode, Is.Not.Null);
+            Assert.That(entry.SourceCode, Is.Not.Empty);
 
             Assert.That(entry.SourceCode, Does.Contain("x = {foo:\"bar\",quux:5}"));
             Assert.That(entry.SourceCode, Does.Contain("HelloWorld({id:23,data:x})"));
diff --git a/src/Spark.Web.Tests/Compiler/SourceMappingTester.cs b/src/Spark.Web.Tests/Compiler/SourceMappingTester.cs
index ff439361..12a10d89 100644
--- a/src/Spark.Web.Tests/Compiler/SourceMappingTester.cs
+++ b/src/Spark.Web.Tests/Compiler/SourceMappingTester.cs
@@ -73,15 +73,15 @@ public void SimpleExpressionsEntirelyMapped()
             var contents = RenderView(new SparkViewDescriptor()
                                           .AddTemplate(Path.Combine("Home", "Index.spark")));
 
-            Assert.AreEqual("<p>Hello world</p>", contents);
-            Assert.AreEqual(1, _entry.SourceMappings.Count);
-            Assert.AreEqual("\"world\"", _entry.SourceMappings[0].Source.Value);
-            Assert.AreEqual(Path.Combine("Home", "Index.spark"), _entry.SourceMappings[0].Source.Begin.SourceContext.FileName);
-            Assert.AreEqual(11, _entry.SourceMappings[0].Source.Begin.Offset);
+            Assert.That(contents, Is.EqualTo("<p>Hello world</p>"));
+            Assert.That(_entry.SourceMappings.Count, Is.EqualTo(1));
+            Assert.That(_entry.SourceMappings[0].Source.Value, Is.EqualTo("\"world\""));
+            Assert.That(_entry.SourceMappings[0].Source.Begin.SourceContext.FileName, Is.EqualTo(Path.Combine("Home", "Index.spark")));
+            Assert.That(_entry.SourceMappings[0].Source.Begin.Offset, Is.EqualTo(11));
 
             var resultOffset = _entry.SourceMappings[0].OutputBegin;
             var resultLength = _entry.SourceMappings[0].OutputEnd - _entry.SourceMappings[0].OutputBegin;
-            Assert.AreEqual("\"world\"", _entry.SourceCode.Substring(resultOffset, resultLength));
+            Assert.That(_entry.SourceCode.Substring(resultOffset, resultLength), Is.EqualTo("\"world\""));
         }
 
         [Test]
@@ -92,15 +92,15 @@ public void EmbeddedCodeMapped()
             var contents = RenderView(new SparkViewDescriptor()
                                           .AddTemplate(Path.Combine("Home", "Index.spark")));
 
-            Assert.AreEqual("<p>5</p>", contents);
-            Assert.AreEqual(2, _entry.SourceMappings.Count);
-            Assert.AreEqual("var x = 5;", _entry.SourceMappings[0].Source.Value);
-            Assert.AreEqual(Path.Combine("Home", "Index.spark"), _entry.SourceMappings[0].Source.Begin.SourceContext.FileName);
-            Assert.AreEqual(5, _entry.SourceMappings[0].Source.Begin.Offset);
+            Assert.That(contents, Is.EqualTo("<p>5</p>"));
+            Assert.That(_entry.SourceMappings.Count, Is.EqualTo(2));
+            Assert.That(_entry.SourceMappings[0].Source.Value, Is.EqualTo("var x = 5;"));
+            Assert.That(_entry.SourceMappings[0].Source.Begin.SourceContext.FileName, Is.EqualTo(Path.Combine("Home", "Index.spark")));
+            Assert.That(_entry.SourceMappings[0].Source.Begin.Offset, Is.EqualTo(5));
 
             var resultOffset = _entry.SourceMappings[0].OutputBegin;
             var resultLength = _entry.SourceMappings[0].OutputEnd - _entry.SourceMappings[0].OutputBegin;
-            Assert.AreEqual("var x = 5;", _entry.SourceCode.Substring(resultOffset, resultLength));
+            Assert.That(_entry.SourceCode.Substring(resultOffset, resultLength), Is.EqualTo("var x = 5;"));
         }
 
 
@@ -112,15 +112,15 @@ public void ExpressionInAttributeMapped()
             var contents = RenderView(new SparkViewDescriptor()
                                           .AddTemplate(Path.Combine("Home", "Index.spark")));
 
-            Assert.AreEqual("<p class='Hello'>World</p>", contents);
-            Assert.AreEqual(1, _entry.SourceMappings.Count);
-            Assert.AreEqual("\"Hello\"", _entry.SourceMappings[0].Source.Value);
-            Assert.AreEqual(Path.Combine("Home", "Index.spark"), _entry.SourceMappings[0].Source.Begin.SourceContext.FileName);
-            Assert.AreEqual(12, _entry.SourceMappings[0].Source.Begin.Offset);
+            Assert.That(contents, Is.EqualTo("<p class='Hello'>World</p>"));
+            Assert.That(_entry.SourceMappings.Count, Is.EqualTo(1));
+            Assert.That(_entry.SourceMappings[0].Source.Value, Is.EqualTo("\"Hello\""));
+            Assert.That(_entry.SourceMappings[0].Source.Begin.SourceContext.FileName, Is.EqualTo(Path.Combine("Home", "Index.spark")));
+            Assert.That(_entry.SourceMappings[0].Source.Begin.Offset, Is.EqualTo(12));
 
             var resultOffset = _entry.SourceMappings[0].OutputBegin;
             var resultLength = _entry.SourceMappings[0].OutputEnd - _entry.SourceMappings[0].OutputBegin;
-            Assert.AreEqual("\"Hello\"", _entry.SourceCode.Substring(resultOffset, resultLength));
+            Assert.That(_entry.SourceCode.Substring(resultOffset, resultLength), Is.EqualTo("\"Hello\""));
         }
 
         [Test]
@@ -131,27 +131,28 @@ public void SingleQuotesAreAvoided()
             var contents = RenderView(new SparkViewDescriptor()
                                           .AddTemplate(Path.Combine("Home", "Index.spark")));
 
-            Assert.AreEqual("<p class=\"Hello5\">World</p>", contents);
-            Assert.AreEqual(2, _entry.SourceMappings.Count);
-            Assert.AreEqual("Hello", _entry.SourceMappings[0].Source.Value);
-            Assert.AreEqual(Path.Combine("Home", "Index.spark"), _entry.SourceMappings[0].Source.Begin.SourceContext.FileName);
-            Assert.AreEqual(13, _entry.SourceMappings[0].Source.Begin.Offset);
-            
-            Assert.AreEqual(" + 5", _entry.SourceMappings[1].Source.Value);
-            Assert.AreEqual(Path.Combine("Home", "Index.spark"), _entry.SourceMappings[1].Source.Begin.SourceContext.FileName);
-            Assert.AreEqual(19, _entry.SourceMappings[1].Source.Begin.Offset);
+            Assert.That(contents, Is.EqualTo("<p class=\"Hello5\">World</p>"));
+            Assert.That(_entry.SourceMappings.Count, Is.EqualTo(2));
+            Assert.That(_entry.SourceMappings[0].Source.Value, Is.EqualTo("Hello"));
+            Assert.That(_entry.SourceMappings[0].Source.Begin.SourceContext.FileName, Is.EqualTo(Path.Combine("Home", "Index.spark")));
+            Assert.That(_entry.SourceMappings[0].Source.Begin.Offset, Is.EqualTo(13));
+
+            Assert.That(_entry.SourceMappings[1].Source.Value, Is.EqualTo(" + 5"));
+            Assert.That(_entry.SourceMappings[1].Source.Begin.SourceContext.FileName, Is.EqualTo(Path.Combine("Home", "Index.spark")));
+            Assert.That(_entry.SourceMappings[1].Source.Begin.Offset, Is.EqualTo(19));
 
             var resultOffset = _entry.SourceMappings[0].OutputBegin;
             var resultLength = _entry.SourceMappings[0].OutputEnd - _entry.SourceMappings[0].OutputBegin;
-            Assert.AreEqual("Hello", _entry.SourceCode.Substring(resultOffset, resultLength));
+            Assert.That(_entry.SourceCode.Substring(resultOffset, resultLength), Is.EqualTo("Hello"));
 
             resultOffset = _entry.SourceMappings[1].OutputBegin;
             resultLength = _entry.SourceMappings[1].OutputEnd - _entry.SourceMappings[1].OutputBegin;
-            Assert.AreEqual(" + 5", _entry.SourceCode.Substring(resultOffset, resultLength));
+            Assert.That(_entry.SourceCode.Substring(resultOffset, resultLength), Is.EqualTo(" + 5"));
         }
 
         [Test]
-        public void WarningsShouldNotCauseCompilationToFail() {
+        public void WarningsShouldNotCauseCompilationToFail()
+        {
             _viewFolder.Add(Path.Combine("Home", "Index.spark"), @"
 <p>
 ## warning I am a warning
diff --git a/src/Spark.Web.Tests/Configuration/SparkSectionHandlerTester.cs b/src/Spark.Web.Tests/Configuration/SparkSectionHandlerTester.cs
index 22a4814a..4b14cefd 100644
--- a/src/Spark.Web.Tests/Configuration/SparkSectionHandlerTester.cs
+++ b/src/Spark.Web.Tests/Configuration/SparkSectionHandlerTester.cs
@@ -32,11 +32,11 @@ public class SparkSectionHandlerTester
         public void CanLoadFromAppConfig()
         {
             var config = (SparkSectionHandler)ConfigurationManager.GetSection("spark");
-            Assert.IsTrue(config.Compilation.Debug);
-            Assert.AreEqual(NullBehaviour.Strict, config.Compilation.NullBehaviour);
-            Assert.AreEqual(1, config.Compilation.Assemblies.Count);
-            Assert.AreEqual(typeof(StubSparkView).FullName, config.Pages.BaseClassTypeName);
-            Assert.AreEqual(1, config.Pages.Namespaces.Count);
+            Assert.That(config.Compilation.Debug, Is.True);
+            Assert.That(config.Compilation.NullBehaviour, Is.EqualTo(NullBehaviour.Strict));
+            Assert.That(config.Compilation.Assemblies.Count, Is.EqualTo(1));
+            Assert.That(config.Pages.BaseClassTypeName, Is.EqualTo(typeof(StubSparkView).FullName));
+            Assert.That(config.Pages.Namespaces.Count, Is.EqualTo(1));
         }
 
         [Test]
@@ -50,9 +50,9 @@ public void CreateSectionHandlerFluentInterface()
                 .AddAssembly(typeof(TestAttribute).Assembly)
                 .AddAssembly("Spark.Tests");
 
-            Assert.IsTrue(config.Compilation.Debug);
-            Assert.AreEqual(3, config.Pages.Namespaces.Count);
-            Assert.AreEqual(2, config.Compilation.Assemblies.Count);
+            Assert.That(config.Compilation.Debug, Is.True);
+            Assert.That(config.Pages.Namespaces.Count, Is.EqualTo(3));
+            Assert.That(config.Compilation.Assemblies.Count, Is.EqualTo(2));
         }
 
         [Test]
@@ -67,10 +67,10 @@ public void CreateSettingsFluentInterface()
                 .AddAssembly(typeof(TestAttribute).Assembly)
                 .AddAssembly("Spark.Tests");
 
-            Assert.IsTrue(settings.Debug);
-            Assert.AreEqual(NullBehaviour.Lenient, settings.NullBehaviour);
-            Assert.AreEqual(3, settings.UseNamespaces.Count());
-            Assert.AreEqual(2, settings.UseAssemblies.Count());
+            Assert.That(settings.Debug, Is.True);
+            Assert.That(settings.NullBehaviour, Is.EqualTo(NullBehaviour.Lenient));
+            Assert.That(settings.UseNamespaces.Count(), Is.EqualTo(3));
+            Assert.That(settings.UseAssemblies.Count(), Is.EqualTo(2));
         }
 
         [Test]
@@ -98,7 +98,7 @@ public void UseAssemblyAndNamespaceFromSettings()
 
             var contents = engine.CreateInstance(descriptor).RenderView();
 
-            Assert.AreEqual("<div>Alive</div>", contents);
+            Assert.That(contents, Is.EqualTo("<div>Alive</div>"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Web.Tests/DefaultResourcePathManagerTester.cs b/src/Spark.Web.Tests/DefaultResourcePathManagerTester.cs
index 619265bb..12fece50 100644
--- a/src/Spark.Web.Tests/DefaultResourcePathManagerTester.cs
+++ b/src/Spark.Web.Tests/DefaultResourcePathManagerTester.cs
@@ -25,7 +25,7 @@ public void NormalUrlPathsAreUnchanged()
         {
             var manager = new DefaultResourcePathManager(new SparkSettings());
             var path = manager.GetResourcePath("", "/content/js/jquery.1.2.6.js");
-            Assert.AreEqual("/content/js/jquery.1.2.6.js", path);
+            Assert.That(path, Is.EqualTo("/content/js/jquery.1.2.6.js"));
         }
 
         [Test]
@@ -33,7 +33,7 @@ public void SiteRootPrependedByDefault()
         {
             var manager = new DefaultResourcePathManager(new SparkSettings());
             var path = manager.GetResourcePath("/my/webapp", "/content/js/jquery.1.2.6.js");
-            Assert.AreEqual("/my/webapp/content/js/jquery.1.2.6.js", path);
+            Assert.That(path, Is.EqualTo("/my/webapp/content/js/jquery.1.2.6.js"));
         }
 
         [Test]
@@ -42,18 +42,18 @@ public void SiteRootPrependedByDefaultEnsureSlashBetweenSiteRootAndPath()
             var manager = new DefaultResourcePathManager(new SparkSettings());
 
             var path = manager.GetResourcePath("/my/webapp", "content/js/jquery.1.2.6.js");
-            Assert.AreEqual("/my/webapp/content/js/jquery.1.2.6.js", path);
+            Assert.That(path, Is.EqualTo("/my/webapp/content/js/jquery.1.2.6.js"));
 
             path = manager.GetResourcePath("/my/webapp/", "/content/js/jquery.1.2.6.js");
-            Assert.AreEqual("/my/webapp/content/js/jquery.1.2.6.js", path);
+            Assert.That(path, Is.EqualTo("/my/webapp/content/js/jquery.1.2.6.js"));
         }
-        
+
         [Test]
         public void TildePrefixedPathMorphAsSiteRootPrependedByDefault()
         {
             var manager = new DefaultResourcePathManager(new SparkSettings());
             var path = manager.GetResourcePath("/my/webapp", "~/content/js/jquery.1.2.6.js");
-            Assert.AreEqual("/my/webapp/content/js/jquery.1.2.6.js", path);   
+            Assert.That(path, Is.EqualTo("/my/webapp/content/js/jquery.1.2.6.js"));
         }
 
         [Test]
@@ -65,15 +65,15 @@ public void WhenResourceMappingWithNoStopAttributeThenNextMatchOrDefaultMatchWil
             var manager = new DefaultResourcePathManager(settings);
 
             var path = manager.GetResourcePath("/my/webapp", "/js/jquery.1.2.6.js");
-            Assert.AreEqual("/my/webapp/content/js/jquery.1.2.6.js", path);
+            Assert.That(path, Is.EqualTo("/my/webapp/content/js/jquery.1.2.6.js"));
 
             settings.AddResourceMapping("/ftpmirror", "/ftp/mymyrror.com", false);
             settings.AddResourceMapping("/ftp/", "ftp://");
 
             var path2 = manager.GetResourcePath("/my/webapp", "/ftpmirror/1.zip");
-            Assert.AreEqual("ftp://mymyrror.com/1.zip", path2);
+            Assert.That(path2, Is.EqualTo("ftp://mymyrror.com/1.zip"));
         }
-        
+
         [Test]
         public void ReplacingJustSomePrefixes()
         {
@@ -83,10 +83,10 @@ public void ReplacingJustSomePrefixes()
             var manager = new DefaultResourcePathManager(settings);
 
             var path = manager.GetResourcePath("/my/webapp", "/content/js/jquery.1.2.6.js");
-            Assert.AreEqual("http://my.cdn.com/myaccount/content/js/jquery.1.2.6.js", path);
+            Assert.That(path, Is.EqualTo("http://my.cdn.com/myaccount/content/js/jquery.1.2.6.js"));
 
             var path2 = manager.GetResourcePath("/my/webapp", "/content/css/yadda.css");
-            Assert.AreEqual("/my/webapp/content/css/yadda.css", path2);
+            Assert.That(path2, Is.EqualTo("/my/webapp/content/css/yadda.css"));
         }
 
         [Test]
@@ -98,10 +98,13 @@ public void AllTypesOfPathSlashesShouldCombineWithSingleForwardSlash()
             var path3 = manager.PathConcat("foo", "/bar");
             var path4 = manager.PathConcat("foo/", "/bar");
 
-            Assert.That(path1, Is.EqualTo("foo/bar"));
-            Assert.That(path2, Is.EqualTo("foo/bar"));
-            Assert.That(path3, Is.EqualTo("foo/bar"));
-            Assert.That(path4, Is.EqualTo("foo/bar"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(path1, Is.EqualTo("foo/bar"));
+                Assert.That(path2, Is.EqualTo("foo/bar"));
+                Assert.That(path3, Is.EqualTo("foo/bar"));
+                Assert.That(path4, Is.EqualTo("foo/bar"));
+            });
         }
 
         [Test]
@@ -113,10 +116,10 @@ public void ReplacingJustSomePrefixesThatHaveTildeNoStop()
             var manager = new DefaultResourcePathManager(settings);
 
             var path = manager.GetResourcePath("/my/webapp", "~/content/js/jquery.1.2.6.js");
-            Assert.AreEqual("http://my.cdn.com/myaccount/content/js/jquery.1.2.6.js", path);
+            Assert.That(path, Is.EqualTo("http://my.cdn.com/myaccount/content/js/jquery.1.2.6.js"));
 
             var path2 = manager.GetResourcePath("/my/webapp", "~/content/css/yadda.css");
-            Assert.AreEqual("/my/webapp/content/css/yadda.css", path2);
+            Assert.That(path2, Is.EqualTo("/my/webapp/content/css/yadda.css"));
         }
     }
 }
diff --git a/src/Spark.Web.Tests/Extensions/ServiceCollectionExtensions.cs b/src/Spark.Web.Tests/Extensions/ServiceCollectionExtensions.cs
index b5f996e1..e60b4905 100644
--- a/src/Spark.Web.Tests/Extensions/ServiceCollectionExtensions.cs
+++ b/src/Spark.Web.Tests/Extensions/ServiceCollectionExtensions.cs
@@ -49,7 +49,7 @@ public static IServiceCollection AddSpark(this IServiceCollection services, ISpa
                 .AddSingleton<ISparkSettings>(settings)
                 .AddSingleton<IParserSettings>(settings)
                 .AddSingleton<ISparkViewEngine, SparkViewEngine>()
-                
+
                 .AddSingleton<ISparkSyntaxProvider, DefaultSyntaxProvider>()
                 .AddSingleton<IViewActivatorFactory, DefaultViewActivator>()
                 .AddSingleton<IResourcePathManager, DefaultResourcePathManager>()
@@ -62,7 +62,7 @@ public static IServiceCollection AddSpark(this IServiceCollection services, ISpa
 
             services
                 .AddSingleton<ISparkExtensionFactory>(c => null);
-                
+
             return services;
         }
     }
diff --git a/src/Spark.Web.Tests/FileSystem/CombinedViewFolderTester.cs b/src/Spark.Web.Tests/FileSystem/CombinedViewFolderTester.cs
index e8cf9e24..e59ffe01 100644
--- a/src/Spark.Web.Tests/FileSystem/CombinedViewFolderTester.cs
+++ b/src/Spark.Web.Tests/FileSystem/CombinedViewFolderTester.cs
@@ -29,9 +29,12 @@ public void HasTemplate()
             var second = new InMemoryViewFolder { { "two.txt", "two" } };
             var viewFolder = new CombinedViewFolder(first, second);
 
-            Assert.IsTrue(viewFolder.HasView("one.txt"));
-            Assert.IsTrue(viewFolder.HasView("two.txt"));
-            Assert.IsFalse(viewFolder.HasView("three.txt"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(viewFolder.HasView("one.txt"), Is.True);
+                Assert.That(viewFolder.HasView("two.txt"), Is.True);
+                Assert.That(viewFolder.HasView("three.txt"), Is.False);
+            });
         }
 
         [Test]
@@ -44,13 +47,13 @@ public void OpenFileStream()
             using (var reader = new StreamReader(viewFolder.GetViewSource("one.txt").OpenViewStream()))
             {
                 var content = reader.ReadToEnd();
-                Assert.AreEqual("one", content);
+                Assert.That(content, Is.EqualTo("one"));
             }
 
             using (var reader = new StreamReader(viewFolder.GetViewSource("two.txt").OpenViewStream()))
             {
                 var content = reader.ReadToEnd();
-                Assert.AreEqual("two", content);
+                Assert.That(content, Is.EqualTo("two"));
             }
         }
 
@@ -75,31 +78,31 @@ public void OpenFromFirstViewFolder()
             using (var reader = new StreamReader(viewFolder.GetViewSource("one.txt").OpenViewStream()))
             {
                 var content = reader.ReadToEnd();
-                Assert.AreEqual("one", content);
+                Assert.That(content, Is.EqualTo("one"));
             }
         }
 
         [Test]
         public void ListFilesWithDedupe()
         {
-            var first = new InMemoryViewFolder 
-			{ 
-				{ Path.Combine("home", "three.txt"), "three" }, 
-				{ Path.Combine("home", "one.txt"), "one" } 
-			};
-            var second = new InMemoryViewFolder 
-			{ 
-				{ Path.Combine("home", "two.txt"), "two" }, 
-				{ Path.Combine("home", "three.txt"), "three" } 
-			};
-			
+            var first = new InMemoryViewFolder
+            {
+                { Path.Combine("home", "three.txt"), "three" },
+                { Path.Combine("home", "one.txt"), "one" }
+            };
+            var second = new InMemoryViewFolder
+            {
+                { Path.Combine("home", "two.txt"), "two" },
+                { Path.Combine("home", "three.txt"), "three" }
+            };
+
             var viewFolder = new CombinedViewFolder(first, second);
             var views = viewFolder.ListViews("home");
-			
-            Assert.AreEqual(3, views.Count);
-            Assert.Contains(Path.Combine("home", "one.txt"), views.ToArray());
-            Assert.Contains(Path.Combine("home", "two.txt"), views.ToArray());
-            Assert.Contains(Path.Combine("home", "three.txt"), views.ToArray());
-        }		
+
+            Assert.That(views.Count, Is.EqualTo(3));
+            Assert.That(views.ToArray(), Does.Contain(Path.Combine("home", "one.txt")));
+            Assert.That(views.ToArray(), Does.Contain(Path.Combine("home", "two.txt")));
+            Assert.That(views.ToArray(), Does.Contain(Path.Combine("home", "three.txt")));
+        }
     }
 }
diff --git a/src/Spark.Web.Tests/FileSystem/EmbeddedViewFolderTester.cs b/src/Spark.Web.Tests/FileSystem/EmbeddedViewFolderTester.cs
index 049069b0..94c504c1 100644
--- a/src/Spark.Web.Tests/FileSystem/EmbeddedViewFolderTester.cs
+++ b/src/Spark.Web.Tests/FileSystem/EmbeddedViewFolderTester.cs
@@ -27,28 +27,37 @@ public class EmbeddedViewFolderTester
         public void LocateEmbeddedFiles()
         {
             var viewFolder = new EmbeddedViewFolder(Assembly.Load("Spark.Web.Tests"), "Spark.FileSystem.Embedded");
-            Assert.IsTrue(viewFolder.HasView(Path.Combine("Home", "Index.spark")));
-            Assert.IsFalse(viewFolder.HasView(Path.Combine("Home", "NoSuchFile.spark")));
-            Assert.IsFalse(viewFolder.HasView("Home"));
-            Assert.IsTrue(viewFolder.HasView(Path.Combine("Shared", "Default.spark")));
+            Assert.That(viewFolder.HasView(Path.Combine("Home", "Index.spark")), Is.True);
+            Assert.Multiple(() =>
+            {
+                Assert.That(viewFolder.HasView(Path.Combine("Home", "NoSuchFile.spark")), Is.False);
+                Assert.That(viewFolder.HasView("Home"), Is.False);
+            });
+            Assert.That(viewFolder.HasView(Path.Combine("Shared", "Default.spark")), Is.True);
         }
 
         [Test]
         public void ListViewsSameResults()
         {
             var filesystem = new FileSystemViewFolder(Path.Combine("FileSystem", "Embedded"));
-            Assert.IsTrue(filesystem.HasView(Path.Combine("Home", "Index.spark")));
+            Assert.That(filesystem.HasView(Path.Combine("Home", "Index.spark")), Is.True);
 
             var files = filesystem.ListViews("Home");
-            Assert.AreEqual(2, files.Count);
-            Assert.That(files.Any(f => Path.GetFileName(f) == "Index.spark"));
-            Assert.That(files.Any(f => Path.GetFileName(f) == "List.spark"));
+            Assert.That(files.Count, Is.EqualTo(2));
+            Assert.Multiple(() =>
+            {
+                Assert.That(files.Any(f => Path.GetFileName(f) == "Index.spark"));
+                Assert.That(files.Any(f => Path.GetFileName(f) == "List.spark"));
+            });
 
             var embedded = new EmbeddedViewFolder(Assembly.Load("Spark.Web.Tests"), "Spark.FileSystem.Embedded");
             files = embedded.ListViews("home");
-            Assert.AreEqual(2, files.Count);
-            Assert.That(files.Any(f => Path.GetFileName(f) == "Index.spark"));
-            Assert.That(files.Any(f => Path.GetFileName(f) == "List.spark"));
+            Assert.That(files.Count, Is.EqualTo(2));
+            Assert.Multiple(() =>
+            {
+                Assert.That(files.Any(f => Path.GetFileName(f) == "Index.spark"));
+                Assert.That(files.Any(f => Path.GetFileName(f) == "List.spark"));
+            });
         }
     }
 }
diff --git a/src/Spark.Web.Tests/FileSystem/FileSystemViewFolderTester.cs b/src/Spark.Web.Tests/FileSystem/FileSystemViewFolderTester.cs
index 1c4cceaa..18ad537b 100644
--- a/src/Spark.Web.Tests/FileSystem/FileSystemViewFolderTester.cs
+++ b/src/Spark.Web.Tests/FileSystem/FileSystemViewFolderTester.cs
@@ -35,17 +35,23 @@ public void HasViewBoolean()
         {
             var fileExists = _viewFolder.HasView(Path.Combine("Home", "foreach.spark"));
             var fileNotFound = _viewFolder.HasView(Path.Combine("Home", "fakefile.spark"));
-            Assert.IsTrue(fileExists);
-            Assert.IsFalse(fileNotFound);
+            Assert.Multiple(() =>
+            {
+                Assert.That(fileExists, Is.True);
+                Assert.That(fileNotFound, Is.False);
+            });
         }
 
         [Test]
         public void ListingViewsInFolder()
         {
             var shared = _viewFolder.ListViews("Shared");
-            Assert.That(shared.Contains("_comment.spark"));
-            Assert.That(shared.Contains("layout.spark"));
-            Assert.That(shared.Contains("partial.spark"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(shared.Contains("_comment.spark"));
+                Assert.That(shared.Contains("layout.spark"));
+                Assert.That(shared.Contains("partial.spark"));
+            });
         }
 
         [Test]
@@ -61,7 +67,7 @@ public void ReadingFileContents()
             var viewSource = _viewFolder.GetViewSource(Path.Combine("Home", "foreach.spark"));
             var reader = new StreamReader(viewSource.OpenViewStream());
             var contents = reader.ReadToEnd();
-            Assert.That(contents.Contains("<for each="));
+            Assert.That(contents, Does.Contain("<for each="));
         }
 
         [Test]
@@ -73,12 +79,12 @@ public void LastModifiedChanges()
             Thread.Sleep(TimeSpan.FromMilliseconds(75));
             var lastModified2 = viewSource.LastModified;
 
-            Assert.AreEqual(lastModified1, lastModified2);
+            Assert.That(lastModified2, Is.EqualTo(lastModified1));
 
-            File.SetLastWriteTimeUtc(Path.Combine("Spark.Tests.Views","Home","foreach.spark"), DateTime.UtcNow);
+            File.SetLastWriteTimeUtc(Path.Combine("Spark.Tests.Views", "Home", "foreach.spark"), DateTime.UtcNow);
             var lastModified3 = viewSource.LastModified;
 
-            Assert.AreNotEqual(lastModified1, lastModified3);
+            Assert.That(lastModified3, Is.Not.EqualTo(lastModified1));
         }
     }
 }
diff --git a/src/Spark.Web.Tests/FileSystem/InMemoryViewFolderTester.cs b/src/Spark.Web.Tests/FileSystem/InMemoryViewFolderTester.cs
index 760505cc..7f83e94d 100644
--- a/src/Spark.Web.Tests/FileSystem/InMemoryViewFolderTester.cs
+++ b/src/Spark.Web.Tests/FileSystem/InMemoryViewFolderTester.cs
@@ -24,19 +24,22 @@
 namespace Spark.FileSystem
 {
     [TestFixture]
-    public class InMemoryViewFolderTester 
+    public class InMemoryViewFolderTester
     {
         [Test]
         public void HasViewCaseInsensitive()
         {
             var viewFolder = new InMemoryViewFolder();
 
-            Assert.IsFalse(viewFolder.HasView(Path.Combine("Home", "Index.spark")));
+            Assert.That(viewFolder.HasView(Path.Combine("Home", "Index.spark")), Is.False);
             viewFolder.Add(Path.Combine("Home", "Index.spark"), "stuff");
-            Assert.IsTrue(viewFolder.HasView(Path.Combine("Home", "Index.spark")));
-            Assert.IsFalse(viewFolder.HasView(Path.Combine("Home", "Index")));
-            Assert.IsTrue(viewFolder.HasView(Path.Combine("Home", "index.spark")));
-            Assert.IsTrue(viewFolder.HasView(Path.Combine("home", "INDEX.SPARK")));
+            Assert.Multiple(() =>
+            {
+                Assert.That(viewFolder.HasView(Path.Combine("Home", "Index.spark")), Is.True);
+                Assert.That(viewFolder.HasView(Path.Combine("Home", "Index")), Is.False);
+                Assert.That(viewFolder.HasView(Path.Combine("Home", "index.spark")), Is.True);
+                Assert.That(viewFolder.HasView(Path.Combine("home", "INDEX.SPARK")), Is.True);
+            });
         }
 
         [Test]
@@ -57,10 +60,10 @@ public void ListViewsInFolder()
                 .Select(Path.GetFileNameWithoutExtension)
                 .ToArray();
 
-            Assert.AreEqual(3, baseNames.Count());
-            Assert.Contains("Alpha", baseNames);
-            Assert.Contains("Beta", baseNames);
-            Assert.Contains("Delta", baseNames);
+            Assert.That(baseNames.Count(), Is.EqualTo(3));
+            Assert.That(baseNames, Does.Contain("Alpha"));
+            Assert.That(baseNames, Does.Contain("Beta"));
+            Assert.That(baseNames, Does.Contain("Delta"));
         }
 
         [Test]
@@ -86,10 +89,10 @@ public void ReadFileContents()
             var source = viewFolder.GetViewSource(Path.Combine("Home", "Index.spark"));
             using (var stream = source.OpenViewStream())
             {
-                using(var reader = new StreamReader(stream))
+                using (var reader = new StreamReader(stream))
                 {
                     var contents = reader.ReadToEnd();
-                    Assert.AreEqual("this is the file contents", contents);
+                    Assert.That(contents, Is.EqualTo("this is the file contents"));
                 }
             }
         }
@@ -104,18 +107,18 @@ public void LastModifiedChanges()
 
             var source1 = viewFolder.GetViewSource(Path.Combine("Home", "Index.spark"));
             var lastModified1 = source1.LastModified;
-            
+
             viewFolder.Set(Path.Combine("Home", "Index.spark"), "this is the file contents");
             var source2 = viewFolder.GetViewSource(Path.Combine("Home", "Index.spark"));
             var lastModified2 = source2.LastModified;
 
-            Assert.AreNotEqual(lastModified1, lastModified2);
+            Assert.That(lastModified2, Is.Not.EqualTo(lastModified1));
 
             var lastModified1b = source1.LastModified;
             var lastModified2b = source1.LastModified;
 
-            Assert.AreNotEqual(lastModified1, lastModified1b);
-            Assert.AreEqual(lastModified1b, lastModified2b);
+            Assert.That(lastModified1b, Is.Not.EqualTo(lastModified1));
+            Assert.That(lastModified2b, Is.EqualTo(lastModified1b));
         }
 
         [Test]
@@ -139,7 +142,7 @@ public void InMemoryViewFolderUsedByEngine()
             descriptor.Templates.Add(Path.Combine("home", "index.spark"));
             var view = engine.CreateInstance(descriptor);
             var contents = view.RenderView();
-            Assert.AreEqual("<p>Hello world</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>Hello world</p>"));
         }
 
         private static string ReadToEnd(IViewFolder viewFolder, string path)
@@ -159,7 +162,7 @@ private static string RenderView(ISparkViewEngine engine, string path)
                 .AddTemplate(path);
 
             return engine
-                .CreateInstance(descriptor)                
+                .CreateInstance(descriptor)
                 .RenderView();
         }
 
@@ -173,10 +176,13 @@ public void UnicodeCharactersSurviveConversionToByteArrayAndBack()
                 { Path.Combine("Home", "ja.spark"), "\u65E5\u672C\u8A9E" }
             };
 
-            Assert.That(ReadToEnd(viewFolder, Path.Combine("Home", "fr.spark")), Is.EqualTo("Français"));
-            Assert.That(ReadToEnd(viewFolder, Path.Combine("Home", "ru.spark")), Is.EqualTo("Русский"));
-            Assert.That(ReadToEnd(viewFolder, Path.Combine("Home", "ja.spark")), Is.EqualTo("日本語"));
-            
+            Assert.Multiple(() =>
+            {
+                Assert.That(ReadToEnd(viewFolder, Path.Combine("Home", "fr.spark")), Is.EqualTo("Français"));
+                Assert.That(ReadToEnd(viewFolder, Path.Combine("Home", "ru.spark")), Is.EqualTo("Русский"));
+                Assert.That(ReadToEnd(viewFolder, Path.Combine("Home", "ja.spark")), Is.EqualTo("日本語"));
+            });
+
             var settings = new SparkSettings().SetBaseClassTypeName(typeof(StubSparkView));
 
             var sp = new ServiceCollection()
@@ -186,9 +192,12 @@ public void UnicodeCharactersSurviveConversionToByteArrayAndBack()
 
             var engine = sp.GetService<ISparkViewEngine>();
 
-            Assert.That(RenderView(engine, Path.Combine("Home", "fr.spark")), Is.EqualTo("Français"));
-            Assert.That(RenderView(engine, Path.Combine("Home", "ru.spark")), Is.EqualTo("Русский"));
-            Assert.That(RenderView(engine, Path.Combine("Home", "ja.spark")), Is.EqualTo("日本語"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(RenderView(engine, Path.Combine("Home", "fr.spark")), Is.EqualTo("Français"));
+                Assert.That(RenderView(engine, Path.Combine("Home", "ru.spark")), Is.EqualTo("Русский"));
+                Assert.That(RenderView(engine, Path.Combine("Home", "ja.spark")), Is.EqualTo("日本語"));
+            });
         }
     }
 }
diff --git a/src/Spark.Web.Tests/FileSystem/SubViewFolderTester.cs b/src/Spark.Web.Tests/FileSystem/SubViewFolderTester.cs
index bab4e133..a4fb7028 100644
--- a/src/Spark.Web.Tests/FileSystem/SubViewFolderTester.cs
+++ b/src/Spark.Web.Tests/FileSystem/SubViewFolderTester.cs
@@ -25,7 +25,7 @@ public class SubViewFolderTester
         public void SharingExtraFolders()
         {
             var normal = new FileSystemViewFolder("Spark.Tests.Views");
-            var otherLocation = new FileSystemViewFolder(Path.Combine("Spark.Tests.Views","Prefix"));
+            var otherLocation = new FileSystemViewFolder(Path.Combine("Spark.Tests.Views", "Prefix"));
 
             var viewFolder = new CombinedViewFolder(normal, new SubViewFolder(otherLocation, "Shared"));
 
@@ -33,29 +33,29 @@ public void SharingExtraFolders()
             var otherLocationCount = otherLocation.ListViews("").Count;
             var totalSharedCount = viewFolder.ListViews("Shared").Count;
 
-            Assert.AreEqual(normalSharedCount + otherLocationCount, totalSharedCount);
+            Assert.That(totalSharedCount, Is.EqualTo(normalSharedCount + otherLocationCount));
         }
 
         [Test]
-		[Ignore("Is this test relevant after mono changes? : ahjohannessen")]
+        [Ignore("Is this test relevant after mono changes? : ahjohannessen")]
         public void ForwardAndBackSlashAreInterchangeable()
         {
             var viewsFolder = new InMemoryViewFolder
-			{
-				{@"Home\Index.spark", "1"},
-				{@"Shared\_global.spark", "2"},
-				{@"Collision\Home\Baaz.spark", "6"}
-			};
+            {
+                {@"Home\Index.spark", "1"},
+                {@"Shared\_global.spark", "2"},
+                {@"Collision\Home\Baaz.spark", "6"}
+            };
             var extraFolder = new InMemoryViewFolder
-			{
-				{@"Home\Foo.spark", "3"},
-				{@"Home\Bar.spark", "4"},
-				{@"Home\Quux.spark", "5"},
-			};
+            {
+                {@"Home\Foo.spark", "3"},
+                {@"Home\Bar.spark", "4"},
+                {@"Home\Quux.spark", "5"},
+            };
 
-            Assert.AreEqual(1, viewsFolder.ListViews(@"Collision/Home").Count);
-            Assert.AreEqual(1, viewsFolder.ListViews(@"Collision\Home").Count);
-            Assert.AreEqual(3, extraFolder.ListViews(@"Home").Count);
+            Assert.That(viewsFolder.ListViews(@"Collision/Home").Count, Is.EqualTo(1));
+            Assert.That(viewsFolder.ListViews(@"Collision\Home").Count, Is.EqualTo(1));
+            Assert.That(extraFolder.ListViews(@"Home").Count, Is.EqualTo(3));
 
             var combinedFolder = viewsFolder
                 .Append(new SubViewFolder(extraFolder, @"Extra/One"))
@@ -63,22 +63,25 @@ public void ForwardAndBackSlashAreInterchangeable()
                 .Append(new SubViewFolder(extraFolder, @"Collision"));
 
 
-            Assert.AreEqual(1, combinedFolder.ListViews("Home").Count);
-            Assert.AreEqual(3, combinedFolder.ListViews(@"Extra/One/Home").Count);
-            Assert.AreEqual(3, combinedFolder.ListViews(@"Extra\One/Home").Count);
-            Assert.AreEqual(3, combinedFolder.ListViews(@"Extra/One\Home").Count);
-            Assert.AreEqual(3, combinedFolder.ListViews(@"Extra\One\Home").Count);
-            Assert.AreEqual(3, combinedFolder.ListViews(@"Extra/Two/Home").Count);
-            Assert.AreEqual(3, combinedFolder.ListViews(@"Extra\Two/Home").Count);
-            Assert.AreEqual(3, combinedFolder.ListViews(@"Extra/Two\Home").Count);
-            Assert.AreEqual(3, combinedFolder.ListViews(@"Extra\Two\Home").Count);
-            Assert.AreEqual(4, combinedFolder.ListViews(@"Collision/Home").Count);
-            Assert.AreEqual(4, combinedFolder.ListViews(@"Collision\Home").Count);
+            Assert.That(combinedFolder.ListViews("Home").Count, Is.EqualTo(1));
+            Assert.That(combinedFolder.ListViews(@"Extra/One/Home").Count, Is.EqualTo(3));
+            Assert.That(combinedFolder.ListViews(@"Extra\One/Home").Count, Is.EqualTo(3));
+            Assert.That(combinedFolder.ListViews(@"Extra/One\Home").Count, Is.EqualTo(3));
+            Assert.That(combinedFolder.ListViews(@"Extra\One\Home").Count, Is.EqualTo(3));
+            Assert.That(combinedFolder.ListViews(@"Extra/Two/Home").Count, Is.EqualTo(3));
+            Assert.That(combinedFolder.ListViews(@"Extra\Two/Home").Count, Is.EqualTo(3));
+            Assert.That(combinedFolder.ListViews(@"Extra/Two\Home").Count, Is.EqualTo(3));
+            Assert.That(combinedFolder.ListViews(@"Extra\Two\Home").Count, Is.EqualTo(3));
+            Assert.That(combinedFolder.ListViews(@"Collision/Home").Count, Is.EqualTo(4));
+            Assert.That(combinedFolder.ListViews(@"Collision\Home").Count, Is.EqualTo(4));
 
-            Assert.IsTrue(combinedFolder.HasView(@"Extra/One/Home/Bar.spark"));
-            Assert.IsTrue(combinedFolder.HasView(@"Extra\One\Home\Bar.spark"));
-            Assert.IsTrue(combinedFolder.HasView(@"Extra/Two/Home/Bar.spark"));
-            Assert.IsTrue(combinedFolder.HasView(@"Extra\Two\Home\Bar.spark"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(combinedFolder.HasView(@"Extra/One/Home/Bar.spark"), Is.True);
+                Assert.That(combinedFolder.HasView(@"Extra\One\Home\Bar.spark"), Is.True);
+                Assert.That(combinedFolder.HasView(@"Extra/Two/Home/Bar.spark"), Is.True);
+                Assert.That(combinedFolder.HasView(@"Extra\Two\Home\Bar.spark"), Is.True);
+            });
 
         }
     }
diff --git a/src/Spark.Web.Tests/FileSystem/ViewFolderSettingsTester.cs b/src/Spark.Web.Tests/FileSystem/ViewFolderSettingsTester.cs
index ad661c86..f7089396 100644
--- a/src/Spark.Web.Tests/FileSystem/ViewFolderSettingsTester.cs
+++ b/src/Spark.Web.Tests/FileSystem/ViewFolderSettingsTester.cs
@@ -35,13 +35,13 @@ public void ApplySettings()
 
             var folder = engine.ViewFolder;
 
-            Assert.IsAssignableFrom(typeof(CombinedViewFolder), folder);
+            Assert.That(folder, Is.AssignableFrom(typeof(CombinedViewFolder)));
 
             var combined = (CombinedViewFolder)folder;
-            Assert.IsAssignableFrom(typeof(VirtualPathProviderViewFolder), combined.Second);
-            
+            Assert.That(combined.Second, Is.AssignableFrom(typeof(VirtualPathProviderViewFolder)));
+
             var vpp = (VirtualPathProviderViewFolder)combined.Second;
-            Assert.AreEqual("~/MoreViews/", vpp.VirtualBaseDir);
+            Assert.That(vpp.VirtualBaseDir, Is.EqualTo("~/MoreViews/"));
         }
 
         [Test]
@@ -55,12 +55,12 @@ public void CustomViewFolder()
             var engine = new SparkViewEngine(settings, null, null, null, null, null, null, null, null, null, null);
 
             var folder = engine.ViewFolder;
-            Assert.IsAssignableFrom(typeof(CombinedViewFolder), folder);
+            Assert.That(folder, Is.AssignableFrom(typeof(CombinedViewFolder)));
             var combined = (CombinedViewFolder)folder;
-            Assert.IsAssignableFrom(typeof(MyViewFolder), combined.Second);
+            Assert.That(combined.Second, Is.AssignableFrom(typeof(MyViewFolder)));
             var customFolder = (MyViewFolder)combined.Second;
-            Assert.AreEqual("quux", customFolder.Foo);
-            Assert.AreEqual(42, customFolder.Bar);
+            Assert.That(customFolder.Foo, Is.EqualTo("quux"));
+            Assert.That(customFolder.Bar, Is.EqualTo(42));
         }
 
         [Test]
@@ -75,11 +75,11 @@ public void AssemblyParameter()
             var engine = new SparkViewEngine(settings, null, null, null, null, null, null, null, null, null, null);
 
             var folder = engine.ViewFolder;
-            Assert.IsAssignableFrom(typeof(CombinedViewFolder), folder);
+            Assert.That(folder, Is.AssignableFrom(typeof(CombinedViewFolder)));
             var combined = (CombinedViewFolder)folder;
-            Assert.IsAssignableFrom(typeof(EmbeddedViewFolder), combined.Second);
+            Assert.That(combined.Second, Is.AssignableFrom(typeof(EmbeddedViewFolder)));
             var embeddedViewFolder = (EmbeddedViewFolder)combined.Second;
-            Assert.AreEqual(Assembly.Load("Spark.Tests"), embeddedViewFolder.Assembly);
+            Assert.That(embeddedViewFolder.Assembly, Is.EqualTo(Assembly.Load("Spark.Tests")));
         }
 
         [Test]
@@ -95,11 +95,11 @@ public void TypeFileSystemCreatesFileSystemViewFolder()
 
             var engine = new SparkViewEngine(settings, null, null, null, null, null, null, null, null, null, null);
             var folder = engine.ViewFolder;
-            Assert.IsAssignableFrom(typeof(CombinedViewFolder), folder);
+            Assert.That(folder, Is.AssignableFrom(typeof(CombinedViewFolder)));
             var combined = (CombinedViewFolder)folder;
-            Assert.IsAssignableFrom(typeof(FileSystemViewFolder), combined.Second);
+            Assert.That(combined.Second, Is.AssignableFrom(typeof(FileSystemViewFolder)));
             var fileSystemViewFolder = (FileSystemViewFolder)combined.Second;
-            Assert.AreEqual(@"e:\no\such\path", fileSystemViewFolder.BasePath);
+            Assert.That(fileSystemViewFolder.BasePath, Is.EqualTo(@"e:\no\such\path"));
         }
 
         public class MyViewFolder : IViewFolder
diff --git a/src/Spark.Web.Tests/ImportAndIncludeTester.cs b/src/Spark.Web.Tests/ImportAndIncludeTester.cs
index aad6a7ec..775abee8 100644
--- a/src/Spark.Web.Tests/ImportAndIncludeTester.cs
+++ b/src/Spark.Web.Tests/ImportAndIncludeTester.cs
@@ -54,8 +54,8 @@ public void ImportExplicitFile()
 
             var contents = view.RenderView();
 
-            Assert.AreEqual("<p>hello world</p>", contents);
-            Assert.IsFalse(contents.Contains("import"));
+            Assert.That(contents, Is.EqualTo("<p>hello world</p>"));
+            Assert.That(contents, Does.Not.Contain("import"));
         }
 
         [Test]
@@ -68,11 +68,11 @@ public void ImportExplicitFileFromShared()
                     { Path.Combine("shared", "extra.spark"), "this is imported <global name='\"world\"'/>" }
                 },
                 Path.Combine("importing", "index.spark"));
-            
+
             var contents = view.RenderView();
-            
-            Assert.AreEqual("<p>hello world</p>", contents);
-            Assert.IsFalse(contents.Contains("import"));
+
+            Assert.That(contents, Is.EqualTo("<p>hello world</p>"));
+            Assert.That(contents, Does.Not.Contain("import"));
         }
 
         [Test]
@@ -92,8 +92,8 @@ public void ImportExplicitWithoutExtension()
 
             var contents = view.RenderView();
 
-            Assert.AreEqual("<p>hello world</p>", contents);
-            Assert.IsFalse(contents.Contains("import"));
+            Assert.That(contents, Is.EqualTo("<p>hello world</p>"));
+            Assert.That(contents, Does.Not.Contain("import"));
         }
 
         [Test]
@@ -110,8 +110,8 @@ public void ImportImplicit()
 
             var contents = view.RenderView();
 
-            Assert.AreEqual("<p>hello world</p>", contents);
-            Assert.IsFalse(contents.Contains("import"));
+            Assert.That(contents, Is.EqualTo("<p>hello world</p>"));
+            Assert.That(contents, Does.Not.Contain("import"));
         }
 
         [Test]
@@ -124,10 +124,10 @@ public void IncludeFile()
                     { Path.Combine("including", "stuff.spark"), "hello world" }
                 },
                 Path.Combine("including", "index.spark"));
-            
+
             var contents = view.RenderView();
-            
-            Assert.AreEqual("<p>hello world</p>", contents);
+
+            Assert.That(contents, Is.EqualTo("<p>hello world</p>"));
         }
 
         [Test]
@@ -163,10 +163,10 @@ public void MissingFileWithEmptyFallbackIsBlank()
                     }
                 },
                 Path.Combine("including", "index.spark"));
-            
+
             var contents = view.RenderView();
 
-            Assert.AreEqual("<p></p>", contents);
+            Assert.That(contents, Is.EqualTo("<p></p>"));
         }
 
         [Test]
@@ -184,7 +184,7 @@ public void MissingFileWithFallbackUsesContents()
 
             var contents = view.RenderView();
 
-            Assert.AreEqual("<p>hello world</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>hello world</p>"));
         }
 
         [Test]
@@ -200,10 +200,10 @@ public void ValidIncludeFallbackDisappears()
                     { Path.Combine("including", "stuff.spark"), "another file" }
                 },
                 Path.Combine("including", "index.spark"));
-            
+
             var contents = view.RenderView();
-            
-            Assert.AreEqual("<p>another file</p>", contents);
+
+            Assert.That(contents, Is.EqualTo("<p>another file</p>"));
         }
 
         [Test]
@@ -219,10 +219,10 @@ public void FallbackContainsAnotherInclude()
                     { Path.Combine("including", "other.spark"), "other file" }
                 },
                 Path.Combine("including", "index.spark"));
-            
+
             var contents = view.RenderView();
-            
-            Assert.AreEqual("<p>other file</p>", contents);
+
+            Assert.That(contents, Is.EqualTo("<p>other file</p>"));
         }
 
         [Test]
@@ -235,10 +235,10 @@ public void IncludeRelativePath()
                     { Path.Combine("lib", "other.spark"), "other file" }
                 },
                 Path.Combine("including", "index.spark"));
-            
+
             var contents = view.RenderView();
 
-            Assert.AreEqual("<p>other file</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>other file</p>"));
         }
         [Test]
         public void IncludeInsideAnInclude()
@@ -252,7 +252,7 @@ public void IncludeInsideAnInclude()
                 },
                 Path.Combine("including", "index.spark"));
             var contents = view.RenderView();
-            Assert.AreEqual("<p>other third file file</p>", contents);
+            Assert.That(contents, Is.EqualTo("<p>other third file file</p>"));
         }
 
         [Test]
@@ -263,10 +263,10 @@ public void UsingXmlns()
                                           {Path.Combine("including", "index.spark"), "<p xmlns:x='http://www.w3.org/2001/XInclude'><include/><x:include href='../lib/other.spark'/></p>"},
                                           {Path.Combine("lib", "other.spark"), "other file"}
                                       }, Path.Combine("including", "index.spark"));
-            
+
             var contents = view.RenderView();
-            
-            Assert.AreEqual("<p xmlns:x='http://www.w3.org/2001/XInclude\'><include></include>other file</p>", contents);
+
+            Assert.That(contents, Is.EqualTo("<p xmlns:x='http://www.w3.org/2001/XInclude\'><include></include>other file</p>"));
         }
 
         [Test]
@@ -277,10 +277,10 @@ public void IncludingAsText()
                                           {Path.Combine("including", "index.spark"), "<p><include href='item.spark' parse='text'/></p>"},
                                           {Path.Combine("including", "item.spark"), "<li>at&t</li>"}
                                       }, Path.Combine("including", "index.spark"));
-            
+
             var contents = view.RenderView();
-            
-            Assert.AreEqual("<p>&lt;li&gt;at&amp;t&lt;/li&gt;</p>", contents);
+
+            Assert.That(contents, Is.EqualTo("<p>&lt;li&gt;at&amp;t&lt;/li&gt;</p>"));
         }
 
         [Test]
@@ -291,10 +291,10 @@ public void IncludingAsHtmlWithDollar()
                                           {Path.Combine("including", "index.spark"), "<p><include href='jquery.templ.htm' parse='html'/></p>"},
                                           {Path.Combine("including", "jquery.templ.htm"), "<h4>${Title}</h4>"}
                                       }, Path.Combine("including", "index.spark"));
-            
+
             var contents = view.RenderView();
-            
-            Assert.AreEqual("<p><h4>${Title}</h4></p>", contents);
+
+            Assert.That(contents, Is.EqualTo("<p><h4>${Title}</h4></p>"));
         }
     }
 }
diff --git a/src/Spark.Web.Tests/Parser/AutomaticEncodingTester.cs b/src/Spark.Web.Tests/Parser/AutomaticEncodingTester.cs
index 969e0a84..6971afae 100644
--- a/src/Spark.Web.Tests/Parser/AutomaticEncodingTester.cs
+++ b/src/Spark.Web.Tests/Parser/AutomaticEncodingTester.cs
@@ -39,12 +39,12 @@ public void Init()
             this.Init(false);
         }
 
-        public void Init(bool automaticEncoding)
+        private void Init(bool automaticEncoding)
         {
             this._settings = new SparkSettings()
                 .SetBaseClassTypeName(typeof(StubSparkView))
                 .SetAutomaticEncoding(automaticEncoding);
-            
+
             this._viewFolder = new InMemoryViewFolder();
 
             var sp = new ServiceCollection()
@@ -72,13 +72,13 @@ private Position Source(string content)
         [Test]
         public void DollarSyntaxHasRawContentWhenDisabled()
         {
-            var settings = new ParserSettings {AutomaticEncoding = false};
+            var settings = new ParserSettings { AutomaticEncoding = false };
             var grammar = new MarkupGrammar(settings);
             var result = grammar.Nodes(this.Source("${'hello world'}"));
 
-            Assert.AreEqual(1, result.Value.Count);
-            Assert.AreEqual("\"hello world\"", (string)((ExpressionNode)result.Value[0]).Code);
-            Assert.IsFalse(((ExpressionNode)result.Value[0]).AutomaticEncoding);
+            Assert.That(result.Value.Count, Is.EqualTo(1));
+            Assert.That((string)((ExpressionNode)result.Value[0]).Code, Is.EqualTo("\"hello world\""));
+            Assert.That(((ExpressionNode)result.Value[0]).AutomaticEncoding, Is.False);
         }
 
         [Test]
@@ -88,9 +88,9 @@ public void BangSyntaxHasRawContentWhenDisabled()
             var grammar = new MarkupGrammar(settings);
             var result = grammar.Nodes(this.Source("!{'hello world'}"));
 
-            Assert.AreEqual(1, result.Value.Count);
-            Assert.AreEqual("\"hello world\"", (string)((ExpressionNode)result.Value[0]).Code);
-            Assert.IsFalse(((ExpressionNode)result.Value[0]).AutomaticEncoding);
+            Assert.That(result.Value.Count, Is.EqualTo(1));
+            Assert.That((string)((ExpressionNode)result.Value[0]).Code, Is.EqualTo("\"hello world\""));
+            Assert.That(((ExpressionNode)result.Value[0]).AutomaticEncoding, Is.False);
         }
 
         [Test]
@@ -100,9 +100,9 @@ public void DollarHasEncodedContentWhenEnabled()
             var grammar = new MarkupGrammar(settings);
             var result = grammar.Nodes(this.Source("${'hello world'}"));
 
-            Assert.AreEqual(1, result.Value.Count);
-            Assert.AreEqual("\"hello world\"", (string)((ExpressionNode)result.Value[0]).Code);
-            Assert.IsTrue(((ExpressionNode)result.Value[0]).AutomaticEncoding);
+            Assert.That(result.Value.Count, Is.EqualTo(1));
+            Assert.That((string)((ExpressionNode)result.Value[0]).Code, Is.EqualTo("\"hello world\""));
+            Assert.That(((ExpressionNode)result.Value[0]).AutomaticEncoding, Is.True);
         }
 
         [Test]
@@ -112,9 +112,9 @@ public void BangSyntaxStillHasRawContentWhenEnabled()
             var grammar = new MarkupGrammar(settings);
             var result = grammar.Nodes(this.Source("!{'hello world'}"));
 
-            Assert.AreEqual(1, result.Value.Count);
-            Assert.AreEqual("\"hello world\"", (string)((ExpressionNode)result.Value[0]).Code);
-            Assert.IsFalse(((ExpressionNode)result.Value[0]).AutomaticEncoding);
+            Assert.That(result.Value.Count, Is.EqualTo(1));
+            Assert.That((string)((ExpressionNode)result.Value[0]).Code, Is.EqualTo("\"hello world\""));
+            Assert.That(((ExpressionNode)result.Value[0]).AutomaticEncoding, Is.False);
         }
 
         [Test]
@@ -123,7 +123,7 @@ public void AutomaticEncodingFalseAlwaysAllowsRawHtml()
             this.Init(false);
             this._viewFolder.Add(Path.Combine("home", "index.spark"), "${'<span>hello</span>'} !{'<span>world</span>'}");
             var content = this.RenderView(new SparkViewDescriptor().AddTemplate(Path.Combine("home", "index.spark")));
-            Assert.AreEqual("<span>hello</span> <span>world</span>", content);
+            Assert.That(content, Is.EqualTo("<span>hello</span> <span>world</span>"));
         }
 
         [Test]
@@ -132,7 +132,7 @@ public void AutomaticEncodingTrueEncodesDollarSyntax()
             this.Init(true);
             this._viewFolder.Add(Path.Combine("home", "index.spark"), "${'<span>hello</span>'} !{'<span>world</span>'}");
             var content = this.RenderView(new SparkViewDescriptor().AddTemplate(Path.Combine("home", "index.spark")));
-            Assert.AreEqual("&lt;span&gt;hello&lt;/span&gt; <span>world</span>", content);
+            Assert.That(content, Is.EqualTo("&lt;span&gt;hello&lt;/span&gt; <span>world</span>"));
         }
 
         [Test]
@@ -142,7 +142,7 @@ public void HashSyntaxForStatementsByDefault()
             var grammar = new MarkupGrammar(settings);
             var result = grammar.Nodes(this.Source("  #foo  \r\n"));
 
-            Assert.AreEqual(2, result.Value.Count);
+            Assert.That(result.Value.Count, Is.EqualTo(2));
             var statement = result.Value.OfType<StatementNode>().Single();
             Assert.That(statement.Code.ToString(), Is.EqualTo("foo  "));
         }
@@ -150,11 +150,11 @@ public void HashSyntaxForStatementsByDefault()
         [Test]
         public void CustomMarkerForStatements()
         {
-            var settings = new ParserSettings { AutomaticEncoding = true, StatementMarker="hi" };
+            var settings = new ParserSettings { AutomaticEncoding = true, StatementMarker = "hi" };
             var grammar = new MarkupGrammar(settings);
             var result = grammar.Nodes(this.Source("  hibernate  \r\n"));
 
-            Assert.AreEqual(2, result.Value.Count);
+            Assert.That(result.Value.Count, Is.EqualTo(2));
             var statement = result.Value.OfType<StatementNode>().Single();
             Assert.That(statement.Code.ToString(), Is.EqualTo("bernate  "));
         }
@@ -166,7 +166,7 @@ public void HashSyntaxIgnoredWhenCustomMarkerProvided()
             var grammar = new MarkupGrammar(settings);
             var result = grammar.Nodes(this.Source("  #foo  \r\n"));
 
-            Assert.AreEqual(1, result.Value.Count);
+            Assert.That(result.Value.Count, Is.EqualTo(1));
             var statement = result.Value.OfType<StatementNode>().Any();
             Assert.That(statement, Is.False);
         }
diff --git a/src/Spark.Web.Tests/Parser/CSharpSyntaxProviderTester.cs b/src/Spark.Web.Tests/Parser/CSharpSyntaxProviderTester.cs
index 1d84f615..0ad887aa 100644
--- a/src/Spark.Web.Tests/Parser/CSharpSyntaxProviderTester.cs
+++ b/src/Spark.Web.Tests/Parser/CSharpSyntaxProviderTester.cs
@@ -40,7 +40,7 @@ public void CanParseSimpleFile()
 
             var result = this._syntax.GetChunks(context, Path.Combine("Home", "childview.spark"));
 
-            Assert.IsNotNull(result);
+            Assert.That(result, Is.Not.Null);
         }
 
         [Test]
@@ -64,7 +64,7 @@ public void UsingCSharpSyntaxInsideEngine()
             view.ViewData["hello"] = "world";
             var code = view.RenderView();
 
-            Assert.IsNotNull(code);
+            Assert.That(code, Is.Not.Null);
         }
 
         [Test]
@@ -89,7 +89,7 @@ public void StatementAndExpressionInCode()
             view.ViewData["hello"] = "world";
             var code = view.RenderView();
 
-            Assert.IsNotNull(code);
+            Assert.That(code, Is.Not.Null);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Web.Tests/PartialProviderTester.cs b/src/Spark.Web.Tests/PartialProviderTester.cs
index 6ac97664..f9aca46e 100644
--- a/src/Spark.Web.Tests/PartialProviderTester.cs
+++ b/src/Spark.Web.Tests/PartialProviderTester.cs
@@ -26,20 +26,20 @@ public void Init()
                 .BuildServiceProvider();
 
             _partialReferenceProvider = sp.GetService<IPartialReferenceProvider>();
-            
-            this._result = new[] {"output"};
+
+            this._result = new[] { "output" };
         }
 
         [Test]
         public void DefaultPartialReferenceProviderWrapsPartialProvider()
         {
             this._partialProvider.Expect(x => x.GetPaths(this._viewPath)).Return(this._result);
-            
+
             var output = _partialReferenceProvider.GetPaths(this._viewPath, true);
-            
+
             this._partialProvider.VerifyAllExpectations();
-            
-            Assert.AreEqual(this._result, output);
+
+            Assert.That(output, Is.EqualTo(this._result));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Web.Tests/Precompiled/ComplexPrecompileController.cs b/src/Spark.Web.Tests/Precompiled/ComplexPrecompileController.cs
index 970c8bd4..265386f8 100644
--- a/src/Spark.Web.Tests/Precompiled/ComplexPrecompileController.cs
+++ b/src/Spark.Web.Tests/Precompiled/ComplexPrecompileController.cs
@@ -17,7 +17,7 @@ namespace Spark.Tests.Precompiled
     [Precompile(Exclude = "Show*", Layout = "Default")]
     [Precompile(Include = "_Foo _Bar", Layout = "Ajax")]
     [Precompile(Include = "Show*", Layout = "Showing")]
-    public class ComplexPrecompileController 
+    public class ComplexPrecompileController
     {
     }
 }
diff --git a/src/Spark.Web.Tests/Precompiled/SimplePrecompileController.cs b/src/Spark.Web.Tests/Precompiled/SimplePrecompileController.cs
index 173627aa..d62a7181 100644
--- a/src/Spark.Web.Tests/Precompiled/SimplePrecompileController.cs
+++ b/src/Spark.Web.Tests/Precompiled/SimplePrecompileController.cs
@@ -15,7 +15,7 @@
 namespace Spark.Tests.Precompiled
 {
     [Precompile]
-    public class SimplePrecompileController 
+    public class SimplePrecompileController
     {
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Web.Tests/Precompiled/View1.cs b/src/Spark.Web.Tests/Precompiled/View1.cs
index abd7b93c..68a21ed4 100644
--- a/src/Spark.Web.Tests/Precompiled/View1.cs
+++ b/src/Spark.Web.Tests/Precompiled/View1.cs
@@ -18,7 +18,7 @@
 namespace Spark.Tests.Precompiled
 {
     [SparkView(
-        TargetNamespace = "Spark.Tests.Precompiled", 
+        TargetNamespace = "Spark.Tests.Precompiled",
         Templates = new[] { "Foo\\Bar.spark", "Shared\\Quux.spark" })]
     public class View1 : StubSparkView
     {
diff --git a/src/Spark.Web.Tests/Precompiled/View3.cs b/src/Spark.Web.Tests/Precompiled/View3.cs
index 0b2e08b3..53443449 100644
--- a/src/Spark.Web.Tests/Precompiled/View3.cs
+++ b/src/Spark.Web.Tests/Precompiled/View3.cs
@@ -20,7 +20,7 @@ namespace Spark.Tests.Precompiled
     [SparkView(
         TargetNamespace = "Spark.Tests.Precompiled",
         Templates = new[] { "Hello\\Sailor.spark", "Shared\\Default.spark" })]
-    public class View3 
+    public class View3
     {
         public void RenderView(TextWriter writer)
         {
diff --git a/src/Spark.Web.Tests/PrefixSupportTester.cs b/src/Spark.Web.Tests/PrefixSupportTester.cs
index b502ccc8..4a6ff9de 100644
--- a/src/Spark.Web.Tests/PrefixSupportTester.cs
+++ b/src/Spark.Web.Tests/PrefixSupportTester.cs
@@ -48,7 +48,7 @@ static void ContainsInOrder(string content, params string[] values)
             foreach (string value in values)
             {
                 int nextIndex = content.IndexOf(value, index);
-                Assert.GreaterOrEqual(nextIndex, 0, string.Format("Looking for {0}", value));
+                Assert.That(nextIndex, Is.GreaterThanOrEqualTo(0), () => $"Looking for {value}");
                 index = nextIndex + value.Length;
             }
         }
@@ -128,11 +128,11 @@ public void ConditionalAttributes()
                 "ok3",
                 "ok4");
 
-            Assert.IsFalse(output.ToString().Contains("fail"));
-            Assert.IsFalse(output.ToString().Contains("if"));
-            Assert.IsFalse(output.ToString().Contains("else"));
-            Assert.IsFalse(output.ToString().Contains("condition"));
-            Assert.IsFalse(output.ToString().Contains("unless fail"));
+            Assert.That(output.ToString(), Does.Not.Contain("fail"));
+            Assert.That(output.ToString(), Does.Not.Contain("if"));
+            Assert.That(output.ToString(), Does.Not.Contain("else"));
+            Assert.That(output.ToString(), Does.Not.Contain("condition"));
+            Assert.That(output.ToString(), Does.Not.Contain("unless fail"));
         }
 
         [Test]
diff --git a/src/Spark.Web.Tests/Spark.Web.Tests.csproj b/src/Spark.Web.Tests/Spark.Web.Tests.csproj
index ee28d7ee..40cb0571 100644
--- a/src/Spark.Web.Tests/Spark.Web.Tests.csproj
+++ b/src/Spark.Web.Tests/Spark.Web.Tests.csproj
@@ -16,10 +16,14 @@
     <Reference Include="System.Web" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-	<PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="NUnit" Version="4.2.2" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.4.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+	<PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
 	<PackageReference Include="Shouldly" Version="4.2.1" />
 	<PackageReference Include="RhinoMocks" Version="3.6.1" />
   </ItemGroup>
diff --git a/src/Spark.Web.Tests/SparkBatchDescriptorTester.cs b/src/Spark.Web.Tests/SparkBatchDescriptorTester.cs
index 3ca557c9..14789fda 100644
--- a/src/Spark.Web.Tests/SparkBatchDescriptorTester.cs
+++ b/src/Spark.Web.Tests/SparkBatchDescriptorTester.cs
@@ -28,11 +28,11 @@ public void BatchForControllerWithSimplePrecompileAttrib()
             var batch = new SparkBatchDescriptor()
                 .FromAttributes<SimplePrecompileController>();
 
-            Assert.AreEqual(1, batch.Entries.Count);
-            Assert.AreSame(typeof(SimplePrecompileController), batch.Entries[0].ControllerType);
-            Assert.AreEqual(0, batch.Entries[0].ExcludeViews.Count);
-            Assert.AreEqual(0, batch.Entries[0].IncludeViews.Count);
-            Assert.AreEqual(0, batch.Entries[0].LayoutNames.Count);
+            Assert.That(batch.Entries.Count, Is.EqualTo(1));
+            Assert.That(batch.Entries[0].ControllerType, Is.SameAs(typeof(SimplePrecompileController)));
+            Assert.That(batch.Entries[0].ExcludeViews.Count, Is.EqualTo(0));
+            Assert.That(batch.Entries[0].IncludeViews.Count, Is.EqualTo(0));
+            Assert.That(batch.Entries[0].LayoutNames.Count, Is.EqualTo(0));
         }
 
         [Test]
@@ -41,17 +41,17 @@ public void BatchForControllerWithComplexPrecompileAttrib()
             var batch = new SparkBatchDescriptor()
                 .FromAttributes<ComplexPrecompileController>();
 
-            Assert.AreEqual(3, batch.Entries.Count);
+            Assert.That(batch.Entries.Count, Is.EqualTo(3));
             var forDefault = batch.Entries.First(e => e.LayoutNames[0][0] == "Default");
             var forAjax = batch.Entries.First(e => e.LayoutNames[0][0] == "Ajax");
             var forShowing = batch.Entries.First(e => e.LayoutNames[0][0] == "Showing");
 
-            Assert.AreEqual(0, forDefault.IncludeViews.Count);
-            Assert.AreEqual(1, forDefault.ExcludeViews.Count);
-            Assert.AreEqual(2, forAjax.IncludeViews.Count);
-            Assert.AreEqual(0, forAjax.ExcludeViews.Count);
-            Assert.AreEqual(1, forShowing.IncludeViews.Count);
-            Assert.AreEqual(0, forShowing.ExcludeViews.Count);
+            Assert.That(forDefault.IncludeViews.Count, Is.EqualTo(0));
+            Assert.That(forDefault.ExcludeViews.Count, Is.EqualTo(1));
+            Assert.That(forAjax.IncludeViews.Count, Is.EqualTo(2));
+            Assert.That(forAjax.ExcludeViews.Count, Is.EqualTo(0));
+            Assert.That(forShowing.IncludeViews.Count, Is.EqualTo(1));
+            Assert.That(forShowing.ExcludeViews.Count, Is.EqualTo(0));
         }
 
         [Test]
@@ -60,8 +60,8 @@ public void BatchFromAssembly()
             var batch = new SparkBatchDescriptor()
                 .FromAssemblyNamed("Spark.Web.Tests");
 
-            Assert.AreEqual(1, batch.Entries.Count(e => e.ControllerType == typeof(SimplePrecompileController)));
-            Assert.AreEqual(3, batch.Entries.Count(e => e.ControllerType == typeof(ComplexPrecompileController)));
+            Assert.That(batch.Entries.Count(e => e.ControllerType == typeof(SimplePrecompileController)), Is.EqualTo(1));
+            Assert.That(batch.Entries.Count(e => e.ControllerType == typeof(ComplexPrecompileController)), Is.EqualTo(3));
         }
     }
 }
diff --git a/src/Spark.Web.Tests/SparkDecoratorTester.cs b/src/Spark.Web.Tests/SparkDecoratorTester.cs
index bcf6fe79..6ffa5dbf 100644
--- a/src/Spark.Web.Tests/SparkDecoratorTester.cs
+++ b/src/Spark.Web.Tests/SparkDecoratorTester.cs
@@ -13,7 +13,7 @@ public void OutputContentCollectionWorksBetweenLayers()
             var layer0 = new TestLayer0();
             var layer1 = new TestLayer1(layer0);
             var content = layer1.RenderView();
-            Assert.AreEqual("[layer1top][layer0head][layer1head][layer0][layer1bottom]", content);
+            Assert.That(content, Is.EqualTo("[layer1top][layer0head][layer1head][layer0][layer1bottom]"));
         }
 
         public class TestLayer0 : SparkViewDecorator
diff --git a/src/Spark.Web.Tests/SparkExtensionTester.cs b/src/Spark.Web.Tests/SparkExtensionTester.cs
index 3a733721..da3339ea 100644
--- a/src/Spark.Web.Tests/SparkExtensionTester.cs
+++ b/src/Spark.Web.Tests/SparkExtensionTester.cs
@@ -51,7 +51,7 @@ public void TestExtensions()
             var descriptor = new SparkViewDescriptor();
             descriptor.Templates.Add(Path.Combine("Home", "extensionelements.spark"));
             var entry = engine.CreateEntry(descriptor);
-            Assert.That(entry.SourceCode.Contains("//this was a test"));
+            Assert.That(entry.SourceCode, Does.Contain("//this was a test"));
         }
     }
 
@@ -71,7 +71,7 @@ public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
     internal class TestExtension : ISparkExtension
     {
         public void VisitNode(INodeVisitor visitor, IList<Node> body, IList<Chunk> chunks)
-        {   
+        {
         }
 
         public void VisitChunk(IChunkVisitor visitor, OutputLocation location, IList<Chunk> chunks, StringBuilder output)
diff --git a/src/Spark.Web.Tests/SparkViewFactoryTester.cs b/src/Spark.Web.Tests/SparkViewFactoryTester.cs
index 0c23669d..945e8193 100644
--- a/src/Spark.Web.Tests/SparkViewFactoryTester.cs
+++ b/src/Spark.Web.Tests/SparkViewFactoryTester.cs
@@ -59,7 +59,7 @@ public void Init()
             factory = new StubViewFactory { Engine = engine };
 
             sb = new StringBuilder();
-           
+
             mocks = new MockRepository();
         }
 
@@ -94,9 +94,12 @@ public void ForEachTest()
 
             string content = sb.ToString();
 
-            Assert.That(content.Contains(@"<li class=""odd"">1: foo</li>"));
-            Assert.That(content.Contains(@"<li class=""even"">2: bar</li>"));
-            Assert.That(content.Contains(@"<li class=""odd"">3: baaz</li>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain(@"<li class=""odd"">1: foo</li>"));
+                Assert.That(content, Does.Contain(@"<li class=""even"">2: bar</li>"));
+                Assert.That(content, Does.Contain(@"<li class=""odd"">3: baaz</li>"));
+            });
         }
 
         [Test]
@@ -110,8 +113,11 @@ public void GlobalSetTest()
 
             string content = sb.ToString();
 
-            Assert.That(content.Contains("<p>default: Global set test</p>"));
-            Assert.That(content.Contains("<p>7==7</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>default: Global set test</p>"));
+                Assert.That(content, Does.Contain("<p>7==7</p>"));
+            });
         }
 
         [Test]
@@ -124,10 +130,13 @@ public void MasterTest()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.That(content.Contains("<title>Standalone Index View</title>"));
-            Assert.That(content.Contains("<h1>Standalone Index View</h1>"));
-            Assert.That(content.Contains("<p>no header by default</p>"));
-            Assert.That(content.Contains("<p>no footer by default</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<title>Standalone Index View</title>"));
+                Assert.That(content, Does.Contain("<h1>Standalone Index View</h1>"));
+                Assert.That(content, Does.Contain("<p>no header by default</p>"));
+                Assert.That(content, Does.Contain("<p>no footer by default</p>"));
+            });
         }
 
         [Test]
@@ -140,10 +149,13 @@ public void CaptureNamedContent()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.That(content.Contains("<p>main content</p>"));
-            Assert.That(content.Contains("<p>this is the header</p>"));
-            Assert.That(content.Contains("<p>footer part one</p>"));
-            Assert.That(content.Contains("<p>footer part two</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>main content</p>"));
+                Assert.That(content, Does.Contain("<p>this is the header</p>"));
+                Assert.That(content, Does.Contain("<p>footer part one</p>"));
+                Assert.That(content, Does.Contain("<p>footer part two</p>"));
+            });
         }
 
         [Test]
@@ -156,11 +168,14 @@ public void UsingPartialFile()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.That(content.Contains("<li>Partial where x=\"zero\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"one\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"two\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"three\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"four\"</li>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<li>Partial where x=\"zero\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"one\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"two\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"three\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"four\"</li>"));
+            });
         }
 
         [Test]
@@ -173,11 +188,14 @@ public void UsingPartialWithRenderElement()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.That(content.Contains("<li>Partial where x=\"zero\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"one\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"two\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"three\"</li>"));
-            Assert.That(content.Contains("<li>Partial where x=\"four\"</li>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<li>Partial where x=\"zero\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"one\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"two\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"three\"</li>"));
+                Assert.That(content, Does.Contain("<li>Partial where x=\"four\"</li>"));
+            });
         }
 
         [Test]
@@ -190,8 +208,11 @@ public void UsingPartialFileImplicit()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.That(content.Contains("<li class=\"odd\">one</li>"));
-            Assert.That(content.Contains("<li class=\"even\">two</li>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<li class=\"odd\">one</li>"));
+                Assert.That(content, Does.Contain("<li class=\"even\">two</li>"));
+            });
         }
 
         [Test]
@@ -204,9 +225,12 @@ public void UsingNamespace()
 
             mocks.VerifyAll();
             string content = sb.ToString();
-            Assert.That(content.Contains("<p>Foo</p>"));
-            Assert.That(content.Contains("<p>Bar</p>"));
-            Assert.That(content.Contains("<p>Hello</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>Foo</p>"));
+                Assert.That(content, Does.Contain("<p>Bar</p>"));
+                Assert.That(content, Does.Contain("<p>Hello</p>"));
+            });
         }
 
         [Test]
@@ -219,15 +243,21 @@ public void IfElseElements()
 
             string content = sb.ToString();
 
-            Assert.That(!content.Contains("<if"));
-            Assert.That(!content.Contains("<else"));
+            Assert.That(content, Does.Not.Contain("<if"));
+            Assert.That(content, Does.Not.Contain("<else"));
 
-            Assert.That(content.Contains("<p>argis5</p>"));
-            Assert.That(!content.Contains("<p>argis6</p>"));
-            Assert.That(content.Contains("<p>argisstill5</p>"));
-            Assert.That(!content.Contains("<p>argisnotstill5</p>"));
-            Assert.That(!content.Contains("<p>argisnow6</p>"));
-            Assert.That(content.Contains("<p>argisstillnot6</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>argis5</p>"));
+                Assert.That(content, Does.Not.Contain("<p>argis6</p>"));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>argisstill5</p>"));
+                Assert.That(content, Does.Not.Contain("<p>argisnotstill5</p>"));
+            });
+            Assert.That(content, Does.Not.Contain("<p>argisnow6</p>"));
+            Assert.That(content, Does.Contain("<p>argisstillnot6</p>"));
         }
 
         [Test]
@@ -240,15 +270,21 @@ public void IfElseAttributes()
 
             string content = sb.ToString();
 
-            Assert.That(!content.Contains("<if"));
-            Assert.That(!content.Contains("<else"));
+            Assert.That(content, Does.Not.Contain("<if"));
+            Assert.That(content, Does.Not.Contain("<else"));
 
-            Assert.That(content.Contains("<p>argis5</p>"));
-            Assert.That(!content.Contains("<p>argis6</p>"));
-            Assert.That(content.Contains("<p>argisstill5</p>"));
-            Assert.That(!content.Contains("<p>argisnotstill5</p>"));
-            Assert.That(!content.Contains("<p>argisnow6</p>"));
-            Assert.That(content.Contains("<p>argisstillnot6</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>argis5</p>"));
+                Assert.That(content, Does.Not.Contain("<p>argis6</p>"));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>argisstill5</p>"));
+                Assert.That(content, Does.Not.Contain("<p>argisnotstill5</p>"));
+            });
+            Assert.That(content, Does.Not.Contain("<p>argisnow6</p>"));
+            Assert.That(content, Does.Contain("<p>argisstillnot6</p>"));
         }
 
         [Test]
@@ -261,10 +297,13 @@ public void UnlessElements()
 
             string content = sb.ToString();
 
-            Assert.That(!content.Contains("<unless"));
+            Assert.That(content, Does.Not.Contain("<unless"));
 
-            Assert.That(content.Contains("<p>argisnot6</p>"));
-            Assert.That(!content.Contains("<p>argis5</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>argisnot6</p>"));
+                Assert.That(content, Does.Not.Contain("<p>argis5</p>"));
+            });
         }
 
         [Test]
@@ -277,10 +316,13 @@ public void UnlessAttributes()
 
             string content = sb.ToString();
 
-            Assert.That(!content.Contains("<unless"));
+            Assert.That(content, Does.Not.Contain("<unless"));
 
-            Assert.That(content.Contains("<p>argisnot6</p>"));
-            Assert.That(!content.Contains("<p>argis5</p>"));
+            Assert.Multiple(() =>
+            {
+                Assert.That(content, Does.Contain("<p>argisnot6</p>"));
+                Assert.That(content, Does.Not.Contain("<p>argis5</p>"));
+            });
         }
 
         [Test]
@@ -417,7 +459,7 @@ public void MarkupBasedMacros()
         {
             var data = new StubViewData
                            {
-                               {"username", "Bob"}, 
+                               {"username", "Bob"},
                                {"comments", new[] {
                                    new Comment {Text = "Alpha"},
                                    new Comment {Text = "Beta"},
@@ -505,7 +547,7 @@ public void ConditionalTestElement()
                             "<p>out-5</p>",
                             "<p>out-6</p>"));
 
-            Assert.IsFalse(content.Contains("fail"));
+            Assert.That(content, Does.Not.Contain("fail"));
         }
 
         [Test]
@@ -518,7 +560,7 @@ public void ConditionalTestElementNested()
 
             string content = sb.ToString().Replace(" ", "").Replace("\r", "").Replace("\n", "");
 
-            Assert.AreEqual("<p>a</p><p>b</p><p>c</p><p>d</p><p>e</p><p>f</p>", content);
+            Assert.That(content, Is.EqualTo("<p>a</p><p>b</p><p>c</p><p>d</p><p>e</p><p>f</p>"));
         }
 
         [Test]
@@ -546,7 +588,7 @@ public void StatementTerminatingStrings()
 
             string content = sb.ToString().Replace(" ", "").Replace("\r", "").Replace("\n", "");
 
-            Assert.AreEqual("<p>a:1</p><p>b:2</p><p>c:3%></p><p>d:<%4%></p><p>e:5%></p><p>f:<%6%></p>", content);
+            Assert.That(content, Is.EqualTo("<p>a:1</p><p>b:2</p><p>c:3%></p><p>d:<%4%></p><p>e:5%></p><p>f:<%6%></p>"));
         }
 
         [Test]
@@ -559,7 +601,7 @@ public void ExpressionHasVerbatimStrings()
 
             string content = sb.ToString().Replace(" ", "").Replace("\r", "").Replace("\n", "");
 
-            Assert.AreEqual("<p>a\\\"b</p><p>c\\\"}d</p>", content);
+            Assert.That(content, Is.EqualTo("<p>a\\\"b</p><p>c\\\"}d</p>"));
         }
 
         [Test]
@@ -756,7 +798,7 @@ public void RenderPartialWithDotInName()
                     "test456",
                     "</p>"));
 
-            Assert.IsFalse(content.Contains("<PartialWith.Dot"));
+            Assert.That(content, Does.Not.Contain("<PartialWith.Dot"));
         }
 
         [Test]
@@ -795,7 +837,7 @@ public void ConstAndReadonlyGlobals()
             mocks.VerifyAll();
             string content = sb.ToString().Replace("\r", "").Replace("\n", "").Replace("\t", "").Replace(" ", "");
 
-            Assert.AreEqual("<ol><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li></ol>", content);
+            Assert.That(content, Is.EqualTo("<ol><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li></ol>"));
         }
 
         [Test]
@@ -807,7 +849,7 @@ public void PrefixContentNotation()
             mocks.VerifyAll();
             string content = sb.ToString().Replace("\r", "").Replace("\n", "").Replace("\t", "").Replace(" ", "");
 
-            Assert.That(content.Contains("onetwothree"));
+            Assert.That(content, Does.Contain("onetwothree"));
         }
 
         [Test]
@@ -918,10 +960,10 @@ public void DefaultValuesDontCollideWithExistingLocals()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.IsFalse(content.Contains("default"));
+            Assert.That(content, Does.Not.Contain("default"));
 
             Assert.That(content, Contains.InOrder("ok1", "ok2"));
-            Assert.IsFalse(content.Contains("fail"));
+            Assert.That(content, Does.Not.Contain("fail"));
         }
 
         [Test]
@@ -934,10 +976,10 @@ public void DefaultValuesDontReplaceGlobals()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.IsFalse(content.Contains("default"));
+            Assert.That(content, Does.Not.Contain("default"));
 
             Assert.That(content, Contains.InOrder("ok1", "ok2"));
-            Assert.IsFalse(content.Contains("fail"));
+            Assert.That(content, Does.Not.Contain("fail"));
         }
 
         [Test]
@@ -950,10 +992,10 @@ public void DefaultValuesDontReplaceViewData()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.IsFalse(content.Contains("default"));
+            Assert.That(content, Does.Not.Contain("default"));
 
             Assert.That(content, Contains.InOrder("ok1", "ok2"));
-            Assert.IsFalse(content.Contains("fail"));
+            Assert.That(content, Does.Not.Contain("fail"));
         }
 
 
@@ -966,10 +1008,10 @@ public void DefaultValuesActAsLocal()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.IsFalse(content.Contains("default"));
+            Assert.That(content, Does.Not.Contain("default"));
 
             Assert.That(content, Contains.InOrder("ok1", "ok2"));
-            Assert.IsFalse(content.Contains("fail"));
+            Assert.That(content, Does.Not.Contain("fail"));
         }
 
         [Test]
@@ -982,10 +1024,10 @@ public void DefaultValuesStandInForNullViewData()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.IsFalse(content.Contains("default"));
+            Assert.That(content, Does.Not.Contain("default"));
 
             Assert.That(content, Contains.InOrder("ok1", "ok2"));
-            Assert.IsFalse(content.Contains("fail"));
+            Assert.That(content, Does.Not.Contain("fail"));
         }
 
         [Test]
@@ -998,7 +1040,7 @@ public void NullExceptionHandledAutomatically()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.IsFalse(content.Contains("default"));
+            Assert.That(content, Does.Not.Contain("default"));
 
             Assert.That(content, Contains.InOrder(
                 "<p>name kaboom *${user.Name}*</p>",
@@ -1015,7 +1057,7 @@ public void CodeCommentsCanHaveQuotes()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.IsFalse(content.Contains("broken"));
+            Assert.That(content, Does.Not.Contain("broken"));
             Assert.That(content, Contains.InOrder("one", "two", "three", "four", "five"));
         }
 
@@ -1028,7 +1070,7 @@ public void ConditionalAttributeDelimitedBySpaces()
             mocks.VerifyAll();
             string content = sb.ToString();
 
-            Assert.IsFalse(content.Contains("broken"));
+            Assert.That(content, Does.Not.Contain("broken"));
             Assert.That(content, Contains.InOrder(
                 "<h1 class=\"one three\"></h1>",
                 "<h2></h2>",
@@ -1054,11 +1096,11 @@ public void OnceAttribute()
                             "quux2",
                             "a1"));
 
-            Assert.IsFalse(content.Contains("foo2"));
-            Assert.IsFalse(content.Contains("foo3"));
-            Assert.IsFalse(content.Contains("bar1"));
-            Assert.IsFalse(content.Contains("bar3"));
-            Assert.IsFalse(content.Contains("a2"));
+            Assert.That(content, Does.Not.Contain("foo2"));
+            Assert.That(content, Does.Not.Contain("foo3"));
+            Assert.That(content, Does.Not.Contain("bar1"));
+            Assert.That(content, Does.Not.Contain("bar3"));
+            Assert.That(content, Does.Not.Contain("a2"));
         }
 
         [Test]
@@ -1094,8 +1136,8 @@ public void IfAttributeWorksOnSpecialNodes()
                             "<span>one</span>",
                             "<span>three</span>"));
 
-            Assert.IsFalse(content.Contains("beta"));
-            Assert.IsFalse(content.Contains("two"));
+            Assert.That(content, Does.Not.Contain("beta"));
+            Assert.That(content, Does.Not.Contain("two"));
         }
 
         [Test]
@@ -1113,8 +1155,8 @@ public void UnlessAttributeWorksOnSpecialNodes()
                             "<span>one</span>",
                             "<span>three</span>"));
 
-            Assert.IsFalse(content.Contains("beta"));
-            Assert.IsFalse(content.Contains("two"));
+            Assert.That(content, Does.Not.Contain("beta"));
+            Assert.That(content, Does.Not.Contain("two"));
         }
 
         [Test]
@@ -1132,12 +1174,12 @@ public void OnceAttributeWorksOnSpecialNodes()
                             "<span>bar0</span>",
                             "<span>quux2</span>"));
 
-            Assert.IsFalse(content.Contains("name-1"));
-            Assert.IsFalse(content.Contains("name-2"));
-            Assert.IsFalse(content.Contains("foo2"));
-            Assert.IsFalse(content.Contains("foo3"));
-            Assert.IsFalse(content.Contains("bar1"));
-            Assert.IsFalse(content.Contains("bar3"));
+            Assert.That(content, Does.Not.Contain("name-1"));
+            Assert.That(content, Does.Not.Contain("name-2"));
+            Assert.That(content, Does.Not.Contain("foo2"));
+            Assert.That(content, Does.Not.Contain("foo3"));
+            Assert.That(content, Does.Not.Contain("bar1"));
+            Assert.That(content, Does.Not.Contain("bar3"));
         }
 
         [Test]
@@ -1265,8 +1307,8 @@ public void Ignore()
                 "Regular text ${This.isnt.code < 0}",
                 "<var dummy=\"This isn't a variable\" />",
                 "</div>"));
-            Assert.IsFalse(content.Contains("<ignore>"));
-            Assert.IsFalse(content.Contains("</ignore>"));
+            Assert.That(content, Does.Not.Contain("<ignore>"));
+            Assert.That(content, Does.Not.Contain("</ignore>"));
         }
 
         [Test]
@@ -1339,13 +1381,13 @@ public void ShadeFileRenders()
 
             Assert.That(content, Contains.InOrder(
                 "<html>",
-                "<head>", 
-                "<title>", 
+                "<head>",
+                "<title>",
                 "offset test",
-                "</title>", 
-                "<body>", 
-                "<div class=\"container\">", 
-                "<h1 id=\"top\">", 
+                "</title>",
+                "<body>",
+                "<div class=\"container\">",
+                "<h1 id=\"top\">",
                 "offset test",
                 "</h1>",
                 "</div>",
@@ -1442,7 +1484,7 @@ public void TextOrientedAttributesApplyToVarAndSet()
             mocks.VerifyAll();
 
             var content = sb.ToString();
-            
+
             Assert.That(content, Contains.InOrder(
                 "<p>String:HelloWorld</p>",
                 "<p>Int32:42</p>"));
diff --git a/src/Spark.Web.Tests/Stubs/StubCacheService.cs b/src/Spark.Web.Tests/Stubs/StubCacheService.cs
index 74ee302c..a3191a7d 100644
--- a/src/Spark.Web.Tests/Stubs/StubCacheService.cs
+++ b/src/Spark.Web.Tests/Stubs/StubCacheService.cs
@@ -14,8 +14,7 @@ public StubCacheService()
 
         public object Get(string identifier)
         {
-            Entry item;
-            return _cache.TryGetValue(identifier, out item) && IsValid(item) ? item.Value : null;
+            return _cache.TryGetValue(identifier, out Entry item) && IsValid(item) ? item.Value : null;
         }
 
         private bool IsValid(Entry item)
@@ -26,7 +25,7 @@ private bool IsValid(Entry item)
 
         public void Store(string identifier, CacheExpires expires, ICacheSignal signal, object item)
         {
-            _cache[identifier] = new Entry {Value = item, UtcExpires = ToAbsolute(expires)};
+            _cache[identifier] = new Entry { Value = item, UtcExpires = ToAbsolute(expires) };
 
             if (signal != null)
             {
diff --git a/src/Spark.Web.Tests/Stubs/StubSparkView2.cs b/src/Spark.Web.Tests/Stubs/StubSparkView2.cs
index a16de67a..9da7d78f 100644
--- a/src/Spark.Web.Tests/Stubs/StubSparkView2.cs
+++ b/src/Spark.Web.Tests/Stubs/StubSparkView2.cs
@@ -46,7 +46,7 @@ public abstract class StubSparkView3<TModel, TMore> : StubSparkView2<TModel>
     {
         public TMore GetMore()
         {
-            return default(TMore);
+            return default;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark.Web.Tests/Stubs/StubViewFactory.cs b/src/Spark.Web.Tests/Stubs/StubViewFactory.cs
index 0c409f32..421c0d94 100644
--- a/src/Spark.Web.Tests/Stubs/StubViewFactory.cs
+++ b/src/Spark.Web.Tests/Stubs/StubViewFactory.cs
@@ -26,10 +26,10 @@ public void RenderView(StubViewContext viewContext, string extension = null)
         {
             var descriptor = new SparkViewDescriptor();
             descriptor.Templates.Add(Path.Combine(viewContext.ControllerName, viewContext.ViewName + (extension ?? Constants.DotSpark)));
-            
+
             if (viewContext.MasterName != null)
                 descriptor.Templates.Add(Path.Combine(Constants.Shared, viewContext.MasterName + (extension ?? Constants.DotSpark)));
- 
+
             var sparkView = Engine.CreateInstance(descriptor);
 
             ((StubSparkView)sparkView).ViewData = viewContext.Data;
diff --git a/src/Spark.Web.Tests/ViewActivatorTester.cs b/src/Spark.Web.Tests/ViewActivatorTester.cs
index adac9568..3ad1f22d 100644
--- a/src/Spark.Web.Tests/ViewActivatorTester.cs
+++ b/src/Spark.Web.Tests/ViewActivatorTester.cs
@@ -72,8 +72,8 @@ public void CreateViewInstance()
             var factory = new DefaultViewActivator();
             var activator = factory.Register(type);
             var view = activator.Activate(type);
-            Assert.IsNotNull(view);
-            Assert.IsAssignableFrom(typeof(TestView), view);
+            Assert.That(view, Is.Not.Null);
+            Assert.That(view, Is.AssignableFrom(typeof(TestView)));
         }
 
         [Test]
@@ -83,8 +83,8 @@ public void FastCreateViewInstance()
             var factory = new FastViewActivator();
             var activator = factory.Register(type);
             var view = activator.Activate(type);
-            Assert.IsNotNull(view);
-            Assert.IsAssignableFrom(typeof(TestView), view);
+            Assert.That(view, Is.Not.Null);
+            Assert.That(view, Is.AssignableFrom(typeof(TestView)));
         }
 
         [Test]
@@ -97,14 +97,14 @@ public void CustomViewActivator()
                 .AddSingleton<IViewActivatorFactory, CustomFactory>()
                 .AddSingleton<IViewFolder>(new InMemoryViewFolder { { "hello/world.spark", "<p>hello world</p>" } })
                 .BuildServiceProvider();
-            
-            var engine = (SparkViewEngine) sp.GetService<ISparkViewEngine>();
+
+            var engine = (SparkViewEngine)sp.GetService<ISparkViewEngine>();
 
             var descriptor = new SparkViewDescriptor().AddTemplate("hello/world.spark");
             var view = engine.CreateInstance(descriptor);
 
-            Assert.IsNotNull(view);
-            Assert.IsAssignableFrom(typeof(TestView), view);
+            Assert.That(view, Is.Not.Null);
+            Assert.That(view, Is.AssignableFrom(typeof(TestView)));
         }
 
         [Test, Explicit]
@@ -123,10 +123,10 @@ public void PerfTest()
 
             for (int i = 0; i < iterations; i++)
             {
-                var view = activator.Activate(type);
+                _ = activator.Activate(type);
             }
             sw.Stop();
-            
+
             Console.WriteLine("Default took: {0}ms", sw.Elapsed.TotalMilliseconds);
             sw.Reset();
 
@@ -134,7 +134,7 @@ public void PerfTest()
 
             for (int i = 0; i < iterations; i++)
             {
-                var view = fastActivator.Activate(type);
+                _ = fastActivator.Activate(type);
             }
             sw.Stop();
             Console.WriteLine("Fast took: {0}ms", sw.Elapsed.TotalMilliseconds);
diff --git a/src/Spark.Web.Tests/Visitors/DetectCodeExpressionTester.cs b/src/Spark.Web.Tests/Visitors/DetectCodeExpressionTester.cs
index 3b3dba30..8738047b 100644
--- a/src/Spark.Web.Tests/Visitors/DetectCodeExpressionTester.cs
+++ b/src/Spark.Web.Tests/Visitors/DetectCodeExpressionTester.cs
@@ -30,10 +30,10 @@ public class DetectCodeExpressionTester : BaseVisitorTester
         public void FindLoopParameters()
         {
             var context = new VisitorContext
-                              {
-                                  SyntaxProvider = new DefaultSyntaxProvider(new SparkSettings())
-                              };
-            
+            {
+                SyntaxProvider = new DefaultSyntaxProvider(new SparkSettings())
+            };
+
             var nodes = ParseNodes(
                 "<for each='var x in new [] {1,2,3}'>${xIndex}${xIsLast}</for>",
                 new SpecialNodeVisitor(context));
@@ -48,10 +48,13 @@ public void FindLoopParameters()
             var isLast = expressionVisitor.Add("xIsLast");
             expressionVisitor.Accept(visitor.Chunks);
 
-            Assert.IsTrue(index.Detected);
-            Assert.IsFalse(count.Detected);
-            Assert.IsFalse(isFirst.Detected);
-            Assert.IsTrue(isLast.Detected);
+            Assert.That(index.Detected, Is.True);
+            Assert.Multiple(() =>
+            {
+                Assert.That(count.Detected, Is.False);
+                Assert.That(isFirst.Detected, Is.False);
+            });
+            Assert.That(isLast.Detected, Is.True);
         }
 
         [Test]
@@ -83,8 +86,11 @@ public void ParametersInPartial()
             var count = detectCode.Add("xCount");
             detectCode.Accept(chunks);
 
-            Assert.IsTrue(index.Detected);
-            Assert.IsFalse(count.Detected);
+            Assert.Multiple(() =>
+            {
+                Assert.That(index.Detected, Is.True);
+                Assert.That(count.Detected, Is.False);
+            });
         }
 
 
@@ -117,8 +123,11 @@ public void ParametersInCallerBody()
             var count = detectCode.Add("xCount");
             detectCode.Accept(chunks);
 
-            Assert.IsTrue(index.Detected);
-            Assert.IsFalse(count.Detected);
+            Assert.Multiple(() =>
+            {
+                Assert.That(index.Detected, Is.True);
+                Assert.That(count.Detected, Is.False);
+            });
         }
 
         [Test]
@@ -129,7 +138,7 @@ public void ParametersInNamedSegment()
                 { Path.Combine("home", "index.spark"), "<for each='var x in new[]{1,2,3}'><Guts><segment:foo>${xIndex}</segment:foo></Guts></for>" },
                 { Path.Combine("home", "_Guts.spark"), "<p><render:foo/></p>" }
             };
-            
+
             var settings = new SparkSettings();
 
             var partialProvider = new DefaultPartialProvider();
@@ -150,8 +159,11 @@ public void ParametersInNamedSegment()
             var count = detectCode.Add("xCount");
             detectCode.Accept(chunks);
 
-            Assert.IsTrue(index.Detected);
-            Assert.IsFalse(count.Detected);
+            Assert.Multiple(() =>
+            {
+                Assert.That(index.Detected, Is.True);
+                Assert.That(count.Detected, Is.False);
+            });
         }
 
         [Test]
@@ -162,7 +174,7 @@ public void IterationInPartialFile()
                 { Path.Combine("home", "index.spark"), "<Guts items='new[]{1,2,3}'><segment:each>${xIndex}</segment:each></Guts>" },
                 { Path.Combine("home", "_Guts.spark"), "<for each='var x in items'><render:each/></for>" }
             };
-            
+
             var settings = new SparkSettings();
 
             var partialProvider = new DefaultPartialProvider();
@@ -183,8 +195,11 @@ public void IterationInPartialFile()
             var count = detectCode.Add("xCount");
             detectCode.Accept(chunks);
 
-            Assert.IsTrue(index.Detected);
-            Assert.IsFalse(count.Detected);
+            Assert.Multiple(() =>
+            {
+                Assert.That(index.Detected, Is.True);
+                Assert.That(count.Detected, Is.False);
+            });
         }
     }
 }
\ No newline at end of file
diff --git a/src/Spark/Compiler/BatchCompiler.cs b/src/Spark/Compiler/BatchCompiler.cs
index b004cc74..8e61fb1a 100644
--- a/src/Spark/Compiler/BatchCompiler.cs
+++ b/src/Spark/Compiler/BatchCompiler.cs
@@ -338,8 +338,6 @@ public Assembly Compile(bool debug, string languageOrExtension, string outputAss
         this.AddNetCoreDefaultReferences();
 #endif
 
-        // TODO: Is this needed?
-        //this.AddAssembly(typeof(System.Drawing.Color));
         foreach(var assemblyLocation in settings.UseAssemblies)
         {
             // Assumes full path to assemblies
diff --git a/src/Spark/ISparkViewEngine.cs b/src/Spark/ISparkViewEngine.cs
index c0fd1ef5..be4a51ec 100644
--- a/src/Spark/ISparkViewEngine.cs
+++ b/src/Spark/ISparkViewEngine.cs
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // 
+
+using System;
 using System.Collections.Generic;
 using System.Reflection;
 using Spark.FileSystem;
@@ -34,6 +36,20 @@ public interface ISparkViewEngine
 
         Assembly BatchCompilation(IList<SparkViewDescriptor> descriptors);
         Assembly BatchCompilation(string outputAssembly, IList<SparkViewDescriptor> descriptors);
+        
+        /// <summary>
+        /// Get all the exported types in the assembly and loads the ones assignable from <see cref="ISparkView"/>.
+        /// </summary>
+        /// <param name="assembly"></param>
+        /// <seealso cref="LoadBatchCompilation(Type[])"/>
+        /// <returns>A list of <see cref="SparkViewDescriptor"/> for every loaded type.</returns>
         IList<SparkViewDescriptor> LoadBatchCompilation(Assembly assembly);
+
+        /// <summary>
+        /// Loads the specified types (when assignable from <see cref="ISparkView"/>) into the <see cref="ICompiledViewHolder"/> implemenation.
+        /// </summary>
+        /// <param name="types"></param>
+        /// <returns>A list of <see cref="SparkViewDescriptor"/> for every loaded type.</returns>
+        IList<SparkViewDescriptor> LoadBatchCompilation(Type[] assembly);
     }
 }
diff --git a/src/Spark/Spark.csproj b/src/Spark/Spark.csproj
index f060c4e1..ae144324 100644
--- a/src/Spark/Spark.csproj
+++ b/src/Spark/Spark.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFrameworks>net48;net8.0</TargetFrameworks>
+    <TargetFrameworks>net48;net8.0;net9.0</TargetFrameworks>
     <LangVersion>latest</LangVersion>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <SignAssembly>False</SignAssembly>
@@ -26,11 +26,11 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="MarkdownSharp" Version="2.0.5" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic" Version="4.8.0" />
-    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.12.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic" Version="4.12.0" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="9.0.0" />
     <PackageReference Include="System.CodeDom" Version="8.0.0" Condition="'${TargetFramework}' == 'net48'" />
-    <PackageReference Include="System.Configuration.ConfigurationManager" Version="8.0.0" />
+    <PackageReference Include="System.Configuration.ConfigurationManager" Version="9.0.0" />
   </ItemGroup>
   <ItemGroup>
     <Compile Remove="Compiler\NodeVisitors\FileReferenceVisitor.cs" />
diff --git a/src/Spark/SparkViewEngine.cs b/src/Spark/SparkViewEngine.cs
index f5a6010c..9bf250e2 100644
--- a/src/Spark/SparkViewEngine.cs
+++ b/src/Spark/SparkViewEngine.cs
@@ -229,11 +229,29 @@ public Assembly BatchCompilation(string outputAssembly, IList<SparkViewDescripto
             return assembly;
         }
 
+        /// <summary>
+        /// Get all the exported types in the assembly and loads the ones assignable from <see cref="ISparkView"/>.
+        /// </summary>
+        /// <param name="assembly"></param>
+        /// <seealso cref="LoadBatchCompilation(Type[])"/>
+        /// <returns>A list of <see cref="SparkViewDescriptor"/> for every loaded type.</returns>
         public IList<SparkViewDescriptor> LoadBatchCompilation(Assembly assembly)
+        {
+            var exportedTypes = assembly.GetExportedTypes();
+
+            return LoadBatchCompilation(exportedTypes);
+        }
+
+        /// <summary>
+        /// Loads the specified types (when assignable from <see cref="ISparkView"/>) into the <see cref="ICompiledViewHolder"/> implemenation.
+        /// </summary>
+        /// <param name="types"></param>
+        /// <returns>A list of <see cref="SparkViewDescriptor"/> for every loaded type.</returns>
+        public IList<SparkViewDescriptor> LoadBatchCompilation(Type[] types)
         {
             var descriptors = new List<SparkViewDescriptor>();
 
-            foreach (var type in assembly.GetExportedTypes())
+            foreach (var type in types)
             {
                 if (!typeof(ISparkView).IsAssignableFrom(type))
                 {
diff --git a/src/spark-pack.slnf b/src/spark-pack.slnf
index 58575004..d0e0a80a 100644
--- a/src/spark-pack.slnf
+++ b/src/spark-pack.slnf
@@ -2,6 +2,7 @@
   "solution": {
     "path": "Spark.sln",
     "projects": [
+      "Spark.AspNetCore.Mvc\\Spark.AspNetCore.Mvc.csproj",
       "Spark.Web.Mvc\\Spark.Web.Mvc.csproj",
       "Spark.Web\\Spark.Web.csproj",
       "Spark\\Spark.csproj"