Migrate Common tests to NUnit

AGENTS.md

@@ -28,7 +28,7 @@ For changes to Common public APIs, target frameworks, packages, or shared behavi
 
 Match the existing C# conventions: tabs, braces on new lines, top-of-file `using` directives, PascalCase public members, and established `Sacs`, `Sa`, `Sam`, and `Sax` prefixes. Follow nearby code where no repository-wide formatter rule exists. Target the framework versions declared in project files. Do not upgrade frameworks or NuGet packages unless explicitly requested.
 
-Across all code files that support `//` line comments, use meaningful section comments instead of solid decorative comment lines. Format a section delimiter as `// --- Caption ---`, where the caption describes the code that follows, such as `Data Members`, `Construction`, `Properties`, `Test Support`, or another context-specific description. Reserve `Utilities` for internal methods that provide relatively simple supporting functionality; use a more specific caption for complex or domain-significant behavior. A delimiter may be followed by explanatory comments when useful. Surround the complete comment block with a blank line so it is visually separate from the preceding and following code; omit only the outside blank line that would otherwise appear directly after an opening brace or directly before a closing brace. Finish the file's main outer class or type block with `// --- The End ---` immediately before its closing brace. Leave nested or internal classes/types comment-free unless the type is complex enough to warrant sections and is at least 32 lines long; `// --- The End ---` is not required for such nested types. Do not add other delimiters where they do not clarify a distinct section. Apply this convention to new files. When an existing file receives significant modification, bring its section comments into line throughout that file as part of the same edit; small, isolated changes do not require unrelated wholesale reformatting.
+Across all code files that support `//` line comments, use meaningful section comments instead of solid decorative comment lines. Format a section delimiter as `// --- Caption ---`, where the caption describes the code that follows, such as `Data Members`, `Construction`, `Properties`, `Test Support`, or another context-specific description. `Definitions` is appropriate where the following code declares classes, structs, interfaces, enums, or similar types. Reserve `Utilities` for internal methods that provide relatively simple supporting functionality; use a more specific caption for complex or domain-significant behavior. A delimiter may be followed by explanatory comments when useful. Surround the complete comment block with a blank line so it is visually separate from the preceding and following code; omit only the outside blank line that would otherwise appear directly after an opening brace or directly before a closing brace. Finish the file's main outer class or type block with `// --- The End ---` immediately before its closing brace. Leave nested or internal classes/types comment-free unless the type is complex enough to warrant sections and is at least 32 lines long; `// --- The End ---` is not required for such nested types. Do not add other delimiters where they do not clarify a distinct section. Apply this convention to new files. When an existing file receives significant modification, bring its section comments into line throughout that file as part of the same edit; small, isolated changes do not require unrelated wholesale reformatting.
 
 Processes derived from `SaProcess_Base` must actively poll `IsInterrupted` during long-running loops and before expensive or blocking stages, then exit promptly when cancellation is requested.
 
@@ -47,7 +47,7 @@ table td {
 
 ## Testing Guidelines
 
-Tests use MSTest and live in `SacsCoreUnitTests`. Add focused tests under the directory matching the affected source component. Run the affected tests after a change and run the full test project when behavior crosses module boundaries. Some database, network, or platform tests may require external configuration; distinguish environment failures from code regressions.
+Tests use NUnit and live in `SacsCoreUnitTests`. Add `[TestFixture]` and `[Test]` attributes, use the NUnit constraint model with `Assert.That` wherever possible, and place focused tests under the directory matching the affected source component. Run the affected tests after a change and run the full test project when behavior crosses module boundaries. Some database, network, or platform tests may require external configuration; distinguish environment failures from code regressions.
 
 ## Change Discipline
 

SacsCoreUnitTests/SacsCoreUnitTests.csproj

@@ -10,8 +10,15 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.10.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="4.4.0" />
+    <PackageReference Include="NUnit" Version="4.6.1" />
-    <PackageReference Include="MSTest.TestFramework" Version="4.4.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.3.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="NUnit.Analyzers" Version="4.15.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="coverlet.collector" Version="10.0.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

SacsCoreUnitTests/Standard/Base/App/SacsCommandLineInfo_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.App;
 using System;
 using System.Collections.Generic;
@@ -6,15 +6,12 @@ using System.Text;
 
 namespace Sacs.UnitTests.Net.Standard.Base.App
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsCommandLineInfo_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		// Data members.
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SacsCommandLineInfo_CTR()
 		{
 			SacsCommandLineInfo cmdLineInfo = new SacsCommandLineInfo(new String[]
@@ -24,12 +21,11 @@ namespace Sacs.UnitTests.Net.Standard.Base.App
 				"Andy",
 				"-SaProcess:ExportData",
 			});
-			Assert.IsNotNull(cmdLineInfo);
+			Assert.That(cmdLineInfo, Is.Not.Null);
-			Assert.AreEqual(4, cmdLineInfo.ParamCount);
+			Assert.That(cmdLineInfo.ParamCount, Is.EqualTo(4));
-			Assert.AreEqual(1, cmdLineInfo.ProcessDefinitions.Count);
+			Assert.That(cmdLineInfo.ProcessDefinitions.Count, Is.EqualTo(1));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/App/SacsProcessDefinition_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.App;
 using System;
 using System.Collections.Generic;
@@ -6,21 +6,18 @@ using System.Text;
 
 namespace Sacs.UnitTests.Net.Standard.Base.App
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsProcessDefinition_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		// Data members.
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SacsProcessDefinition_CTR()
 		{
 			// Valid process definitions.
-			Assert.IsNotNull(new SacsProcessDefinition("SaProcess:ExportData"));
+			Assert.That(new SacsProcessDefinition("SaProcess:ExportData"), Is.Not.Null);
-			Assert.IsNotNull(new SacsProcessDefinition("SaProcess:Proc=ExportData"));
+			Assert.That(new SacsProcessDefinition("SaProcess:Proc=ExportData"), Is.Not.Null);
-			Assert.IsNotNull(new SacsProcessDefinition("SaProcess:ExportData;User=System"));
+			Assert.That(new SacsProcessDefinition("SaProcess:ExportData;User=System"), Is.Not.Null);
 
 			// Invalid process definition - blank argument.
 			try
@@ -29,24 +26,22 @@ namespace Sacs.UnitTests.Net.Standard.Base.App
 			}
 			catch (Exception exc)
 			{
-				Assert.AreEqual(typeof(NotSupportedException), exc.GetType());
+				Assert.That(exc.GetType(), Is.EqualTo(typeof(NotSupportedException)));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SacsProcessDefinition_IsValidProcessDefinition()
 		{
 			// Valid process params.
-			Assert.AreEqual(true, SacsProcessDefinition.IsValidProcessDefinition("SaProcess:ExportData"));
+			Assert.That(SacsProcessDefinition.IsValidProcessDefinition("SaProcess:ExportData"), Is.EqualTo(true));
 
 			// Invalid process params.
-			Assert.AreEqual(false, SacsProcessDefinition.IsValidProcessDefinition(""));
+			Assert.That(SacsProcessDefinition.IsValidProcessDefinition(""), Is.EqualTo(false));
-			Assert.AreEqual(false, SacsProcessDefinition.IsValidProcessDefinition("Abc"));
+			Assert.That(SacsProcessDefinition.IsValidProcessDefinition("Abc"), Is.EqualTo(false));
-			Assert.AreEqual(false, SacsProcessDefinition.IsValidProcessDefinition("SaProcess"));
+			Assert.That(SacsProcessDefinition.IsValidProcessDefinition("SaProcess"), Is.EqualTo(false));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Bus/SysId_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Bus;
 using Sarand.Net.Standard.Base.Utils;
 using System;
@@ -6,93 +6,91 @@ using System.Collections.Generic;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Bus
 {
-	[TestClass]
+	[TestFixture]
 	public class SysId_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data members.
+
 		private readonly SysId idNull = null;
 		private readonly SysId id_ = new SysId();
 		private readonly SysId id0 = new SysId(0);
 		private readonly SysId id1 = new SysId(1);
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public void SysId_CTR_Void ()
 		{
-			Assert.IsNotNull(new SysId());
+			Assert.That(new SysId(), Is.Not.Null);
-			Assert.AreEqual(0, new SysId().ToInt());
+			Assert.That(new SysId().ToInt(), Is.EqualTo(0));
-			Assert.IsTrue(String.IsNullOrEmpty(new SysId().ToString()));
+			Assert.That(String.IsNullOrEmpty(new SysId().ToString()), Is.True);
-			Assert.IsTrue(StringUtil.IsEmpty(new SysId().ToString()));
+			Assert.That(StringUtil.IsEmpty(new SysId().ToString()), Is.True);
-			Assert.AreEqual("", new SysId().ToString());
+			Assert.That(new SysId().ToString(), Is.Empty);
-			Assert.AreEqual(string.Empty, new SysId().ToString());
+			Assert.That(new SysId().ToString(), Is.Empty);
 		}
 
-		[TestMethod]
+		[Test]
 		public void SysId_CTR_Long ()
 		{
 			// Zero - invalid.
-			Assert.IsNotNull(new SysId(0));
+			Assert.That(new SysId(0), Is.Not.Null);
 
 			// 1 - Valid.
-			Assert.IsNotNull(new SysId(1));
+			Assert.That(new SysId(1), Is.Not.Null);
-			Assert.IsNotNull(new SysId(-1));
+			Assert.That(new SysId(-1), Is.Not.Null);
 		}
 
-		//-------------------------------------------------------------------
 		// Is Valid.
-		[TestMethod]
+		[Test]
 		public void SysId_IsValid ()
 		{
-			Assert.IsFalse(SysId.IsValid(null));
+			Assert.That(SysId.IsValid(null), Is.False);
-			Assert.IsFalse(SysId.IsValid(new SysId()));
+			Assert.That(SysId.IsValid(new SysId()), Is.False);
-			Assert.IsFalse(SysId.IsValid(new SysId(0)));
+			Assert.That(SysId.IsValid(new SysId(0)), Is.False);
-			Assert.IsTrue(SysId.IsValid(new SysId(1)));
+			Assert.That(SysId.IsValid(new SysId(1)), Is.True);
-			Assert.IsTrue(SysId.IsValid(new SysId(-1)));
+			Assert.That(SysId.IsValid(new SysId(-1)), Is.True);
 		}
 
-		//-------------------------------------------------------------------
 		// Invalid on null.
-		[TestMethod]
+		[Test]
 		public void SysId_InvalidOnNull ()
 		{
-			Assert.IsNotNull(SysId.InvalidOnNull(null));
+			Assert.That(SysId.InvalidOnNull(null), Is.Not.Null);
-			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(null)));
+			Assert.That(SysId.IsValid(SysId.InvalidOnNull(null)), Is.False);
-			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(new SysId())));
+			Assert.That(SysId.IsValid(SysId.InvalidOnNull(new SysId())), Is.False);
-			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(new SysId(0))));
+			Assert.That(SysId.IsValid(SysId.InvalidOnNull(new SysId(0))), Is.False);
-			Assert.IsTrue(SysId.IsValid(SysId.InvalidOnNull(new SysId(1))));
+			Assert.That(SysId.IsValid(SysId.InvalidOnNull(new SysId(1))), Is.True);
-			Assert.IsTrue(SysId.IsValid(SysId.InvalidOnNull(new SysId(-1))));
+			Assert.That(SysId.IsValid(SysId.InvalidOnNull(new SysId(-1))), Is.True);
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SysId_Equals_Object ()
 		{
-			Assert.IsFalse(id_.Equals(null));
+			Assert.That(id_.Equals(null), Is.False);
-			Assert.IsFalse(id0.Equals(null));
+			Assert.That(id0.Equals(null), Is.False);
-			Assert.IsFalse(id1.Equals(null));
+			Assert.That(id1.Equals(null), Is.False);
-			Assert.IsFalse(id_.Equals((Object)id_));
+			Assert.That(id_.Equals((Object)id_), Is.False);
-			Assert.IsFalse(id_.Equals((Object)id0));
+			Assert.That(id_.Equals((Object)id0), Is.False);
-			Assert.IsFalse(id_.Equals((Object)id1));
+			Assert.That(id_.Equals((Object)id1), Is.False);
-			Assert.IsFalse(id0.Equals((Object)id_));
+			Assert.That(id0.Equals((Object)id_), Is.False);
-			Assert.IsFalse(id0.Equals((Object)id0));
+			Assert.That(id0.Equals((Object)id0), Is.False);
-			Assert.IsFalse(id0.Equals((Object)id1));
+			Assert.That(id0.Equals((Object)id1), Is.False);
-			Assert.IsFalse(id1.Equals((Object)id_));
+			Assert.That(id1.Equals((Object)id_), Is.False);
-			Assert.IsFalse(id1.Equals((Object)id0));
+			Assert.That(id1.Equals((Object)id0), Is.False);
-			Assert.IsTrue(id1.Equals((Object)id1));
+			Assert.That(id1.Equals((Object)id1), Is.True);
 		}
-		[TestMethod]
+		[Test]
 		public void SysId_Equals_SysId ()
 		{
 			// Invalid values always unequal.
-			Assert.IsFalse(id_.Equals(null));
+			Assert.That(id_.Equals(null), Is.False);
-			Assert.IsFalse(id_.Equals(idNull));
+			Assert.That(id_.Equals(idNull), Is.False);
-			Assert.IsFalse(id_.Equals(id_));
+			Assert.That(id_.Equals(id_), Is.False);
-			Assert.IsFalse(id_.Equals(id0));
+			Assert.That(id_.Equals(id0), Is.False);
-			Assert.IsFalse(id_.Equals(new SysId()));
+			Assert.That(id_.Equals(new SysId()), Is.False);
 
 			// Valid values.
-			Assert.IsTrue(id1.Equals(new SysId(1)));
+			Assert.That(id1.Equals(new SysId(1)), Is.True);
 
 			for (int i = 1; i <= 1000; i++)
 			{
@@ -100,18 +98,15 @@ namespace Sacs.UnitTests.Net.Standard.Base.Bus
 				for (int j = 1; j <= 1000; j++)
 				{
 					SysId idJ = new SysId(j);
-					if (i == j) Assert.IsTrue(idI.Equals(idJ));
+					if (i == j) Assert.That(idI.Equals(idJ), Is.True);
-					else Assert.IsFalse(idI.Equals(idJ));
+					else Assert.That(idI.Equals(idJ), Is.False);
 
 				}
 			}
 		}
-		//-------------------------------------------------------------------
 
-		//-------------------------------------------------------------------
+		// --- Lists ---
-		//                        S y s I d   L i s t
+		[Test]
-		//-------------------------------------------------------------------
-		[TestMethod]
 		public void SysId_List_GetIdCount ()
 		{
 			List<SysId> ids = new List<SysId>()
@@ -127,19 +122,18 @@ namespace Sacs.UnitTests.Net.Standard.Base.Bus
 				new SysId(),
 			};
 			// Unique, valid only.
-			Assert.AreEqual(3, ids.GetIdCount());
+			Assert.That(ids.GetIdCount(), Is.EqualTo(3));
-			Assert.AreEqual(3, ids.GetIdCount(true,true));
+			Assert.That(ids.GetIdCount(true, true), Is.EqualTo(3));
 			// Unique including invalid.
-			Assert.AreEqual(4, ids.GetIdCount(false));
+			Assert.That(ids.GetIdCount(false), Is.EqualTo(4));
-			Assert.AreEqual(4, ids.GetIdCount(false,true));
+			Assert.That(ids.GetIdCount(false, true), Is.EqualTo(4));
 			// Duplicate, valid only.
-			Assert.AreEqual(6, ids.GetIdCount(true, false));
+			Assert.That(ids.GetIdCount(true, false), Is.EqualTo(6));
 			// Duplicate including invalid.
-			Assert.AreEqual(9, ids.GetIdCount(false,false));
+			Assert.That(ids.GetIdCount(false, false), Is.EqualTo(9));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SysId_List_HasValidIds ()
 		{
 			List<SysId> ids = new List<SysId>();
@@ -147,7 +141,7 @@ namespace Sacs.UnitTests.Net.Standard.Base.Bus
 			// Single valid Id.
 			ids.Clear();
 			ids.Add(new SysId(123));
-			Assert.AreEqual(true, ids.HasValidIds());
+			Assert.That(ids.HasValidIds(), Is.EqualTo(true));
 
 			// Several valid ids.
 			ids.Clear();
@@ -157,7 +151,7 @@ namespace Sacs.UnitTests.Net.Standard.Base.Bus
 				new SysId(2),
 				new SysId(3),
 			});
-			Assert.AreEqual(true, ids.HasValidIds());
+			Assert.That(ids.HasValidIds(), Is.EqualTo(true));
 
 			// Invalid only.
 			ids.Clear();
@@ -167,13 +161,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Bus
 				new SysId(),
 				new SysId(),
 			});
-			Assert.AreEqual(false, ids.HasValidIds());
+			Assert.That(ids.HasValidIds(), Is.EqualTo(false));
 
 			// Add valid Id.
 			ids.Add(new SysId(123));
-			Assert.AreEqual(true, ids.HasValidIds());
+			Assert.That(ids.HasValidIds(), Is.EqualTo(true));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Base/Data/SacsAesIvCrypter_Tester.cs

@@ -1,58 +1,22 @@
 using System;
 using System.Text;
 using System.Collections.Generic;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using System.Linq;
 using Sarand.Net.Standard.Base.Data;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Data
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsAesIvCrypter_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data members.
+
 		private static Random random = new Random();
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		// Construction.
-		public SacsAesIvCrypter_Tester ()
-		{
-		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		/// <summary>
-		///Gets or sets the test context which provides
-		///information about and functionality for the current test run.
-		///</summary>
-		public TestContext TestContext { get; set; }
-
-		//-------------------------------------------------------------------
-		#region Additional test attributes
-		//
-		// You can use the following additional attributes as you write your tests:
-		//
-		// Use ClassInitialize to run code before running the first test in the class
-		// [ClassInitialize()]
-		// public static void MyClassInitialize(TestContext testContext) { }
-		//
-		// Use ClassCleanup to run code after all tests in a class have run
-		// [ClassCleanup()]
-		// public static void MyClassCleanup() { }
-		//
-		// Use TestInitialize to run code before running each test 
-		// [TestInitialize()]
-		// public void MyTestInitialize() { }
-		//
-		// Use TestCleanup to run code after each test has run
-		// [TestCleanup()]
-		// public void MyTestCleanup() { }
-		//
-		#endregion
-
-		//-------------------------------------------------------------------
-		[TestMethod]
 		public void SacsAesIvCrypter_Test ()
 		{
 			for (int i = 0; i < 200; i++)
@@ -63,13 +27,14 @@ namespace Sacs.UnitTests.Net.Standard.Base.Data
 				int keyLength = key.Length;
 				String encrypted = SacsAesIvCrypter.Encrypt(data, key);
 				int encryptedLength = encrypted.Length;
-				Assert.AreEqual(data, SacsAesIvCrypter.Decrypt(encrypted, key));
+				Assert.That(SacsAesIvCrypter.Decrypt(encrypted, key), Is.EqualTo(data));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- Utilities ---
+
 		/// <summary>Generate random alphanumeric string</summary>
-		public static String RandomString (int length, bool includeLowerCase = true, bool includeSymbols = true)
+		private static String RandomString (int length, bool includeLowerCase = true, bool includeSymbols = true)
 		{
 			String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 			if (includeLowerCase) chars += "abcdefghijklmnopqrstuvwxyz";
@@ -77,7 +42,6 @@ namespace Sacs.UnitTests.Net.Standard.Base.Data
 			return new string(Enumerable.Repeat(chars, length).Select(s => s[random.Next(s.Length)]).ToArray());
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Data/SacsCsvHandler_Tester.cs

@@ -1,75 +1,70 @@
-using System;
+using System;
 using System.Collections.Generic;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Data;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Data
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsCsvHandler_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public void ParseCsvRecord_FieldCount ()
 		{
-			Assert.AreEqual(0, SacsCsvHandler.ParseCsvRecord(null).Count);
+			Assert.That(SacsCsvHandler.ParseCsvRecord(null).Count, Is.EqualTo(0));
-			Assert.AreEqual(1, SacsCsvHandler.ParseCsvRecord("").Count);
+			Assert.That(SacsCsvHandler.ParseCsvRecord("").Count, Is.EqualTo(1));
-			Assert.AreEqual(2, SacsCsvHandler.ParseCsvRecord(",").Count);
+			Assert.That(SacsCsvHandler.ParseCsvRecord(",").Count, Is.EqualTo(2));
-			Assert.AreEqual(3, SacsCsvHandler.ParseCsvRecord("A,B,C").Count);
+			Assert.That(SacsCsvHandler.ParseCsvRecord("A,B,C").Count, Is.EqualTo(3));
-			Assert.AreEqual(5, SacsCsvHandler.ParseCsvRecord("A,B,C,D,E").Count);
+			Assert.That(SacsCsvHandler.ParseCsvRecord("A,B,C,D,E").Count, Is.EqualTo(5));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void ParseCsvRecord_Simple_NoText ()
 		{
 			String data = "A,B,C";
 			List<String> fields = SacsCsvHandler.ParseCsvRecord(data);
-			Assert.AreEqual(3, fields.Count);
+			Assert.That(fields.Count, Is.EqualTo(3));
-			Assert.AreEqual("B", fields[1]);
+			Assert.That(fields[1], Is.EqualTo("B"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void ParseCsvRecord_Text_Simple ()
 		{
 			List<String> fields = SacsCsvHandler.ParseCsvRecord("A,\"B\",C");
-			Assert.AreEqual(3, fields.Count);
+			Assert.That(fields.Count, Is.EqualTo(3));
-			Assert.AreEqual("A", fields[0]);
+			Assert.That(fields[0], Is.EqualTo("A"));
-			Assert.AreEqual("B", fields[1]);
+			Assert.That(fields[1], Is.EqualTo("B"));
-			Assert.AreEqual("C", fields[2]);
+			Assert.That(fields[2], Is.EqualTo("C"));
 
 			fields = SacsCsvHandler.ParseCsvRecord("A,\"B\",\"C\"");
-			Assert.AreEqual(3, fields.Count);
+			Assert.That(fields.Count, Is.EqualTo(3));
-			Assert.AreEqual("A", fields[0]);
+			Assert.That(fields[0], Is.EqualTo("A"));
-			Assert.AreEqual("B", fields[1]);
+			Assert.That(fields[1], Is.EqualTo("B"));
-			Assert.AreEqual("C", fields[2]);
+			Assert.That(fields[2], Is.EqualTo("C"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void ParseCsvRecord_Text_WithFieldDelim ()
 		{
 			List<String> fields = SacsCsvHandler.ParseCsvRecord("A,\",\",C");
-			Assert.AreEqual(3, fields.Count);
+			Assert.That(fields.Count, Is.EqualTo(3));
-			Assert.AreEqual("A", fields[0]);
+			Assert.That(fields[0], Is.EqualTo("A"));
-			Assert.AreEqual(",", fields[1]);
+			Assert.That(fields[1], Is.EqualTo(","));
-			Assert.AreEqual("C", fields[2]);
+			Assert.That(fields[2], Is.EqualTo("C"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void ParseCsvRecord_Text_EmbeddedTextDelims ()
 		{
 			List<String> fields = SacsCsvHandler.ParseCsvRecord("A,\"\"\"\",C");
-			Assert.AreEqual(3, fields.Count);
+			Assert.That(fields.Count, Is.EqualTo(3));
-			Assert.AreEqual("A", fields[0]);
+			Assert.That(fields[0], Is.EqualTo("A"));
-			Assert.AreEqual("\"", fields[1]);
+			Assert.That(fields[1], Is.EqualTo("\""));
-			Assert.AreEqual("C", fields[2]);
+			Assert.That(fields[2], Is.EqualTo("C"));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Data/SacsDataFn_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Data;
 using System;
 using System.Collections.Generic;
@@ -8,34 +8,34 @@ using System.Threading.Tasks;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Data
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsDataFn_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data memebrs.
+
 		private static Random random = new Random();
 
-		//-------------------------------------------------------------------
+		// --- Utilities ---
+
 		/// <summary>Create random alphanumeric string of specified length.</summary>
-		public static string RandomString (int length)
+		private static string RandomString (int length)
 		{
 			const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 			return new string(Enumerable.Repeat(chars, length)
 			  .Select(s => s[random.Next(s.Length)]).ToArray());
 		}
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public void Sapphire ()
 		{
 			String encodedEncrypted = "6NP   R78:P.8$2Q";
 			String raw = SacsDataFn._sadcs (encodedEncrypted, new SacsData("SaItemOptionMgr_Odbc"));
-			Assert.AreEqual("sarand", raw);
+			Assert.That(raw, Is.EqualTo("sarand"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void Encode ()
 		{
 			// Test the Encoding algorythm.
@@ -43,14 +43,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Data
 			{
 				String rawData = RandomString(random.Next(10,21));
 				SacsData dataEnc = SacsDataFn._saecd (new SacsData(rawData).DataBuffer);
-				Assert.AreNotEqual(rawData, dataEnc.NullTerminatedString);
+				Assert.That(dataEnc.NullTerminatedString, Is.Not.EqualTo(rawData));
 				SacsData dataDec = SacsDataFn._sadcd (dataEnc.DataBuffer);
-				Assert.AreEqual(rawData, dataDec.NullTerminatedString);
+				Assert.That(dataDec.NullTerminatedString, Is.EqualTo(rawData));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void Encrypt_String ()
 		{
 			// Test the Encryption algorythm.
@@ -58,14 +57,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Data
 			{
 				String rawData = RandomString(random.Next(10,21));
 				String dataEnc = SacsDataFn._saecs (rawData);
-				Assert.AreNotEqual(rawData, dataEnc);
+				Assert.That(dataEnc, Is.Not.EqualTo(rawData));
 				String dataDec = SacsDataFn._sadcs (dataEnc);
-				Assert.AreEqual(rawData, dataDec);
+				Assert.That(dataDec, Is.EqualTo(rawData));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void RC4Encrypt_String ()
 		{
 			// Test the RC4 algorythm:
@@ -73,13 +71,12 @@ namespace Sacs.UnitTests.Net.Standard.Base.Data
 			{
 				String rawData = RandomString(random.Next(10,21));
 				SacsData dataEnc = SacsDataFn.RC4 (new SacsData(rawData).DataBuffer);
-				Assert.AreNotEqual(rawData, dataEnc.NullTerminatedString);
+				Assert.That(dataEnc.NullTerminatedString, Is.Not.EqualTo(rawData));
 				SacsData dataDec = SacsDataFn.RC4 (dataEnc.DataBuffer);
-				Assert.AreEqual(rawData, dataDec.NullTerminatedString);
+				Assert.That(dataDec.NullTerminatedString, Is.EqualTo(rawData));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Data/SacsData_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Data;
 using System;
 using System.Collections.Generic;
@@ -8,54 +8,53 @@ using System.Threading.Tasks;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Data
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsData_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data memebrs.
+
 		private static Random random = new Random();
 
-		//-------------------------------------------------------------------
+		// --- Utilities ---
+
 		/// <summary>Create random alphanumeric string of specified length.</summary>
-		public static string RandomString (int length)
+		private static string RandomString (int length)
 		{
 			const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 			return new string(Enumerable.Repeat(chars, length)
 			  .Select(s => s[random.Next(s.Length)]).ToArray());
 		}
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public void CTR_String ()
 		{
 			for (int i = 0; i < 1000; i++)
 			{
 				String rawValue = RandomString(random.Next(10,21));
 				// Default (ASCII) encoding.
-				Assert.AreEqual(rawValue, (String)new SacsData(rawValue));
+				Assert.That((String)new SacsData(rawValue), Is.EqualTo(rawValue));
 				// UniCode encoding.
-				Assert.AreEqual(rawValue, (String)new SacsData(rawValue, Encoding.Unicode));
+				Assert.That((String)new SacsData(rawValue, Encoding.Unicode), Is.EqualTo(rawValue));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void CTR_Copy ()
 		{
 			for (int i = 0; i < 1000; i++)
 			{
 				String rawValue = RandomString(random.Next(10,21));
 				// Default (ASCII) encoding.
-				Assert.AreEqual(rawValue, (String)new SacsData(new SacsData(rawValue)));
+				Assert.That((String)new SacsData(new SacsData(rawValue)), Is.EqualTo(rawValue));
 				// UTF-8 encoding.
-				Assert.AreEqual(rawValue, (String)new SacsData(new SacsData(rawValue, Encoding.UTF8)));
+				Assert.That((String)new SacsData(new SacsData(rawValue, Encoding.UTF8)), Is.EqualTo(rawValue));
 				// UniCode encoding.
-				Assert.AreEqual(rawValue, (String)new SacsData(new SacsData(rawValue, Encoding.Unicode)));
+				Assert.That((String)new SacsData(new SacsData(rawValue, Encoding.Unicode)), Is.EqualTo(rawValue));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Dbas/DatabaseProvider_Tester.cs

@@ -1,5 +1,5 @@
 using Microsoft.Data.SqlClient;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Dbas;
 using Sarand.Net.Standard.Dbas.Base;
 using Sarand.Net.Standard.Dbas.Data;
@@ -11,9 +11,11 @@ using System.Data.Odbc;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Dbas
 {
-	[TestClass]
+	[TestFixture]
 	public class DatabaseProvider_Tester
 	{
+		// --- Definitions ---
+
 		private class ParameterTestItem : DbDataItem
 		{
 			public ParameterTestItem() : base() { }
@@ -27,7 +29,7 @@ namespace Sacs.UnitTests.Net.Standard.Base.Dbas
 
 		// --- Provider Selection ---
 
-		[TestMethod]
+		[Test]
 		public void OpenOdbcDatabase_CreatesSqlClientAndForcedOdbcConnections()
 		{
 			SacsDatabaseConsole.OdbcConfig config = new SacsDatabaseConsole.OdbcConfig
@@ -42,16 +44,16 @@ namespace Sacs.UnitTests.Net.Standard.Base.Dbas
 			using DbConnection sqlConnection = database.CreateConnection();
 			using DbConnection odbcConnection = database.CreateConnection(true);
 
-			Assert.IsInstanceOfType(sqlConnection, typeof(SqlConnection));
+			Assert.That(sqlConnection, Is.TypeOf<SqlConnection>());
-			StringAssert.Contains(sqlConnection.ConnectionString, "Server=localhost");
+			Assert.That(sqlConnection.ConnectionString, Does.Contain("Server=localhost"));
-			StringAssert.Contains(sqlConnection.ConnectionString, "Database=TestDb");
+			Assert.That(sqlConnection.ConnectionString, Does.Contain("Database=TestDb"));
-			Assert.IsInstanceOfType(odbcConnection, typeof(OdbcConnection));
+			Assert.That(odbcConnection, Is.TypeOf<OdbcConnection>());
-			Assert.AreEqual(config.ConnectionString, odbcConnection.ConnectionString);
+			Assert.That(odbcConnection.ConnectionString, Is.EqualTo(config.ConnectionString));
 		}
 
 		// --- Command Parameters ---
 
-		[TestMethod]
+		[Test]
 		public void AddCommandParameter_AssignsValuesNullsAndExplicitTypes()
 		{
 			ParameterTestItem item = new ParameterTestItem();
@@ -61,16 +63,16 @@ namespace Sacs.UnitTests.Net.Standard.Base.Dbas
 			item.AddParameter<int?>(command, "@MissingCount", null);
 			item.AddParameter<byte[]>(command, "@Data", null);
 
-			Assert.AreEqual("@Count", command.Parameters[0].ParameterName);
+			Assert.That(command.Parameters[0].ParameterName, Is.EqualTo("@Count"));
-			Assert.AreEqual(12, command.Parameters[0].Value);
+			Assert.That(command.Parameters[0].Value, Is.EqualTo(12));
-			Assert.AreEqual(DbType.Int32, command.Parameters[0].DbType);
+			Assert.That(command.Parameters[0].DbType, Is.EqualTo(DbType.Int32));
-			Assert.AreEqual(DBNull.Value, command.Parameters[1].Value);
+			Assert.That(command.Parameters[1].Value, Is.EqualTo(DBNull.Value));
-			Assert.AreEqual(DbType.Int32, command.Parameters[1].DbType);
+			Assert.That(command.Parameters[1].DbType, Is.EqualTo(DbType.Int32));
-			Assert.AreEqual(DBNull.Value, command.Parameters[2].Value);
+			Assert.That(command.Parameters[2].Value, Is.EqualTo(DBNull.Value));
-			Assert.AreEqual(DbType.Binary, command.Parameters[2].DbType);
+			Assert.That(command.Parameters[2].DbType, Is.EqualTo(DbType.Binary));
 		}
 
-		[TestMethod]
+		[Test]
 		public void AddCommandParameter_NormalisesSqlAndOdbcDates()
 		{
 			ParameterTestItem item = new ParameterTestItem();
@@ -81,13 +83,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Dbas
 			item.AddParameter(sqlCommand, "@When", value);
 			item.AddParameter(odbcCommand, "When", value);
 
-			Assert.AreEqual(DbType.DateTime2, sqlCommand.Parameters[0].DbType);
+			Assert.That(sqlCommand.Parameters[0].DbType, Is.EqualTo(DbType.DateTime2));
-			Assert.AreEqual(DbType.DateTime, odbcCommand.Parameters[0].DbType);
+			Assert.That(odbcCommand.Parameters[0].DbType, Is.EqualTo(DbType.DateTime));
-			Assert.AreEqual(value.AddMilliseconds(-456), sqlCommand.Parameters[0].Value);
+			Assert.That(sqlCommand.Parameters[0].Value, Is.EqualTo(value.AddMilliseconds(-456)));
-			Assert.AreEqual(value.AddMilliseconds(-456), odbcCommand.Parameters[0].Value);
+			Assert.That(odbcCommand.Parameters[0].Value, Is.EqualTo(value.AddMilliseconds(-456)));
 		}
 
-		[TestMethod]
+		[Test]
 		public void AddCommandParameter_MapsSentinelDatesToDatabaseNull()
 		{
 			ParameterTestItem item = new ParameterTestItem();
@@ -97,12 +99,12 @@ namespace Sacs.UnitTests.Net.Standard.Base.Dbas
 			item.AddParameter<DateTime?>(command, "@Maximum", DateTime.MaxValue);
 			item.AddParameter<DateTime?>(command, "@Missing", null);
 
-			Assert.AreEqual(DBNull.Value, command.Parameters[0].Value);
+			Assert.That(command.Parameters[0].Value, Is.EqualTo(DBNull.Value));
-			Assert.AreEqual(DBNull.Value, command.Parameters[1].Value);
+			Assert.That(command.Parameters[1].Value, Is.EqualTo(DBNull.Value));
-			Assert.AreEqual(DBNull.Value, command.Parameters[2].Value);
+			Assert.That(command.Parameters[2].Value, Is.EqualTo(DBNull.Value));
-			Assert.AreEqual(DbType.DateTime2, command.Parameters[0].DbType);
+			Assert.That(command.Parameters[0].DbType, Is.EqualTo(DbType.DateTime2));
-			Assert.AreEqual(DbType.DateTime2, command.Parameters[1].DbType);
+			Assert.That(command.Parameters[1].DbType, Is.EqualTo(DbType.DateTime2));
-			Assert.AreEqual(DbType.DateTime2, command.Parameters[2].DbType);
+			Assert.That(command.Parameters[2].DbType, Is.EqualTo(DbType.DateTime2));
 		}
 
 		// --- The End ---

SacsCoreUnitTests/Standard/Base/Email/SaEmailConsole_Tester.cs

@@ -1,15 +1,15 @@
 using System.Linq;
 using System.Text;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using MimeKit;
 using Sarand.Net.Standard.Base.Email;
 
 namespace Sarand.UnitTests.Standard.Base.Email
 {
-	[TestClass]
+	[TestFixture]
 	public class SaEmailConsole_Tester
 	{
-		// --- Test Support ---
+		// --- Definitions ---
 
 		private class TestEmailConsole : SaEmailConsole
 		{
@@ -21,7 +21,7 @@ namespace Sarand.UnitTests.Standard.Base.Email
 
 		// --- Message Content ---
 
-		[TestMethod]
+		[Test]
 		public void CreateMailMessage_PopulatesAddressesSubjectAndTextBody()
 		{
 			SaEmailData emailData = CreateEmailData();
@@ -34,18 +34,18 @@ namespace Sarand.UnitTests.Standard.Base.Email
 
 			MimeMessage message = new TestEmailConsole().CreateMessage(emailData);
 
-			Assert.AreEqual("sender@example.com", ((MailboxAddress)message.From.Single()).Address);
+			Assert.That(((MailboxAddress)message.From.Single()).Address, Is.EqualTo("sender@example.com"));
-			Assert.AreEqual("to@example.com", ((MailboxAddress)message.To.Single()).Address);
+			Assert.That(((MailboxAddress)message.To.Single()).Address, Is.EqualTo("to@example.com"));
-			Assert.AreEqual("cc@example.com", ((MailboxAddress)message.Cc.Single()).Address);
+			Assert.That(((MailboxAddress)message.Cc.Single()).Address, Is.EqualTo("cc@example.com"));
-			CollectionAssert.AreEquivalent(
+			Assert.That(
-				new[] { "bcc@example.com", "configured-bcc@example.com" },
+				message.Bcc.Mailboxes.Select(address => address.Address).ToArray(),
-				message.Bcc.Mailboxes.Select(address => address.Address).ToArray());
+				Is.EquivalentTo(new[] { "bcc@example.com", "configured-bcc@example.com" }));
-			Assert.AreEqual("Test subject", message.Subject);
+			Assert.That(message.Subject, Is.EqualTo("Test subject"));
-			Assert.AreEqual("Test body", message.TextBody);
+			Assert.That(message.TextBody, Is.EqualTo("Test body"));
-			Assert.IsNull(message.HtmlBody);
+			Assert.That(message.HtmlBody, Is.Null);
 		}
 
-		[TestMethod]
+		[Test]
 		public void CreateMailMessage_PopulatesHtmlBody()
 		{
 			SaEmailData emailData = CreateEmailData();
@@ -54,13 +54,13 @@ namespace Sarand.UnitTests.Standard.Base.Email
 
 			MimeMessage message = new TestEmailConsole().CreateMessage(emailData);
 
-			Assert.AreEqual("<p>Test body</p>", message.HtmlBody);
+			Assert.That(message.HtmlBody, Is.EqualTo("<p>Test body</p>"));
-			Assert.IsNull(message.TextBody);
+			Assert.That(message.TextBody, Is.Null);
 		}
 
 		// --- Attachments ---
 
-		[TestMethod]
+		[Test]
 		public void CreateMailMessage_PopulatesAttachment()
 		{
 			SaEmailData emailData = CreateEmailData();
@@ -73,13 +73,13 @@ namespace Sarand.UnitTests.Standard.Base.Email
 			MimeMessage message = new TestEmailConsole().CreateMessage(emailData);
 			MimePart attachment = (MimePart)message.Attachments.Single();
 
-			Assert.AreEqual("test.txt", attachment.FileName);
+			Assert.That(attachment.FileName, Is.EqualTo("test.txt"));
-			Assert.AreEqual("text/plain", attachment.ContentType.MimeType);
+			Assert.That(attachment.ContentType.MimeType, Is.EqualTo("text/plain"));
-			Assert.AreEqual(ContentDisposition.Attachment, attachment.ContentDisposition.Disposition);
+			Assert.That(attachment.ContentDisposition.Disposition, Is.EqualTo(ContentDisposition.Attachment));
-			Assert.AreEqual(ContentEncoding.Base64, attachment.ContentTransferEncoding);
+			Assert.That(attachment.ContentTransferEncoding, Is.EqualTo(ContentEncoding.Base64));
 		}
 
-		[TestMethod]
+		[Test]
 		public void CreateMailMessage_UsesDefaultAttachmentFilename()
 		{
 			SaEmailData emailData = CreateEmailData();
@@ -91,10 +91,10 @@ namespace Sarand.UnitTests.Standard.Base.Email
 			MimeMessage message = new TestEmailConsole().CreateMessage(emailData);
 			MimePart attachment = (MimePart)message.Attachments.Single();
 
-			Assert.AreEqual("Attachment_001.dat", attachment.FileName);
+			Assert.That(attachment.FileName, Is.EqualTo("Attachment_001.dat"));
 		}
 
-		[TestMethod]
+		[Test]
 		public void CreateMailMessage_PopulatesInlineAttachment()
 		{
 			SaEmailData emailData = CreateEmailData();
@@ -111,30 +111,30 @@ namespace Sarand.UnitTests.Standard.Base.Email
 			MimeMessage message = new TestEmailConsole().CreateMessage(emailData);
 			MimePart attachment = message.BodyParts.OfType<MimePart>().Single(part => part.ContentId == "test-image@example.com");
 
-			Assert.AreEqual("test.png", attachment.FileName);
+			Assert.That(attachment.FileName, Is.EqualTo("test.png"));
-			Assert.AreEqual(ContentDisposition.Inline, attachment.ContentDisposition.Disposition);
+			Assert.That(attachment.ContentDisposition.Disposition, Is.EqualTo(ContentDisposition.Inline));
-			Assert.AreEqual("<img src=\"cid:test-image@example.com\">", message.HtmlBody);
+			Assert.That(message.HtmlBody, Is.EqualTo("<img src=\"cid:test-image@example.com\">"));
 		}
 
 		// --- Formatting and Tag Tests ---
 
-		[TestMethod]
+		[Test]
 		public void DynamicEmailTags_AreMatchedAndReplacedCaseInsensitively()
 		{
 			SaEmailData emailData = CreateEmailData();
 			emailData.MessageBody = "Before [#Test.Tag] after [#TEST.TAG].";
 
-			Assert.IsTrue(SaEmailConsole.EmailContainsTag(emailData, "[#test.tag]"));
+			Assert.That(SaEmailConsole.EmailContainsTag(emailData, "[#test.tag]"), Is.True);
 
 			SaEmailConsole.ReplaceDynamicEmailTag(emailData, "[#test.tag]", "replacement");
 
-			Assert.AreEqual("Before replacement after replacement.", emailData.MessageBody);
+			Assert.That(emailData.MessageBody, Is.EqualTo("Before replacement after replacement."));
 		}
 
-		[TestMethod]
+		[Test]
 		public void FormatAttachmentContentId_ReplacesAddressAndWhitespaceCharacters()
 		{
-			Assert.AreEqual("test_image_name@saxonite.com", SaEmailConsole.FormatAttachmentContentId("test @ image  name"));
+			Assert.That(SaEmailConsole.FormatAttachmentContentId("test @ image  name"), Is.EqualTo("test_image_name@saxonite.com"));
 		}
 
 		// --- Test Data ---

SacsCoreUnitTests/Standard/Base/Generic/ObjectReferences_Tester.cs

@@ -1,47 +1,47 @@
-using System.Drawing;
+using System.Drawing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Generic
 {
-	[TestClass]
+	[TestFixture]
 	public class ObjectReferences_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public void ObjectReferences_ChangeValuesOnReferencedObject ()
 		{
 			// size2 starts as a reference to size1.
 			Size size1 = new Size(10, 20);
 			Size size2 = size1;
 			Size size3 = new Size(10, 20);
-			Assert.AreEqual(size1, size2);
+			Assert.That(size2, Is.EqualTo(size1));
-			Assert.AreEqual(size1, size3);
+			Assert.That(size3, Is.EqualTo(size1));
-			Assert.AreEqual(size2, size3);
+			Assert.That(size3, Is.EqualTo(size2));
 			// Change size1 values - doesn't change size2.
 			size1.Width = 100;
 			size1.Height = 200;
-			Assert.AreNotEqual(size1, size2);
+			Assert.That(size2, Is.Not.EqualTo(size1));
-			Assert.AreNotEqual(size1, size3);
+			Assert.That(size3, Is.Not.EqualTo(size1));
-			Assert.AreEqual(size2, size3);
+			Assert.That(size3, Is.EqualTo(size2));
 		}
-		[TestMethod]
+		[Test]
 		public void ObjectReferences_ChangeValuesOnObjectReference ()
 		{
 			// size2 starts as a reference to size1.
 			Size size1 = new Size(10, 20);
 			Size size2 = size1;
 			Size size3 = new Size(10, 20);
-			Assert.AreEqual(size1, size2);
+			Assert.That(size2, Is.EqualTo(size1));
-			Assert.AreEqual(size1, size3);
+			Assert.That(size3, Is.EqualTo(size1));
-			Assert.AreEqual(size2, size3);
+			Assert.That(size3, Is.EqualTo(size2));
 			// Change size2 values - doesn't change size1.
 			size2.Width = 100;
 			size2.Height = 200;
-			Assert.AreNotEqual(size1, size2);
+			Assert.That(size2, Is.Not.EqualTo(size1));
-			Assert.AreEqual(size1, size3);
+			Assert.That(size3, Is.EqualTo(size1));
-			Assert.AreNotEqual(size2, size3);
+			Assert.That(size3, Is.Not.EqualTo(size2));
 		}
-		//-------------------------------------------------------------------
 		// Modify class value.
 		class TestData
 		{
@@ -50,37 +50,38 @@ namespace Sacs.UnitTests.Net.Standard.Base.Generic
 			public Size size1 = new Size(10,20);
 			public Size Size2 { get; set; } = new Size(30, 40);
 		}
-		[TestMethod]
+		[Test]
 		public void ObjectReferences_ChangeClassValues ()
 		{
 			TestData td1 = new TestData();
 			TestData td2 = td1;
-			Assert.AreEqual(td1, td2);
+			Assert.That(td2, Is.EqualTo(td1));
 			td1.a++;  // td2 is still a reference to td1 with the same values.
-			Assert.AreEqual(td1, td2);
+			Assert.That(td2, Is.EqualTo(td1));
-			Assert.AreEqual(td1.a, td2.a);
+			Assert.That(td2.a, Is.EqualTo(td1.a));
-			Assert.AreEqual(td1.B, td2.B);
+			Assert.That(td2.B, Is.EqualTo(td1.B));
-			Assert.AreEqual(td1.size1, td2.size1);
+			Assert.That(td2.size1, Is.EqualTo(td1.size1));
-			Assert.AreEqual(td1.Size2, td2.Size2);
+			Assert.That(td2.Size2, Is.EqualTo(td1.Size2));
 			td1.B++;  // td2 is still a reference to td1 with the same values.
-			Assert.AreEqual(td1, td2);
+			Assert.That(td2, Is.EqualTo(td1));
-			Assert.AreEqual(td1.a, td2.a);
+			Assert.That(td2.a, Is.EqualTo(td1.a));
-			Assert.AreEqual(td1.B, td2.B);
+			Assert.That(td2.B, Is.EqualTo(td1.B));
-			Assert.AreEqual(td1.size1, td2.size1);
+			Assert.That(td2.size1, Is.EqualTo(td1.size1));
-			Assert.AreEqual(td1.Size2, td2.Size2);
+			Assert.That(td2.Size2, Is.EqualTo(td1.Size2));
 			td1.size1.Width += 10;  // td2 is still a reference to td1 with the same values.
-			Assert.AreEqual(td1, td2);
+			Assert.That(td2, Is.EqualTo(td1));
-			Assert.AreEqual(td1.a, td2.a);
+			Assert.That(td2.a, Is.EqualTo(td1.a));
-			Assert.AreEqual(td1.B, td2.B);
+			Assert.That(td2.B, Is.EqualTo(td1.B));
-			Assert.AreEqual(td1.size1, td2.size1);
+			Assert.That(td2.size1, Is.EqualTo(td1.size1));
-			Assert.AreEqual(td1.Size2, td2.Size2);
+			Assert.That(td2.Size2, Is.EqualTo(td1.Size2));
 			td1.Size2 = new Size(td1.Size2.Width, td1.Size2.Height + 10);  // td2 is still a reference to td1 with the same values.
-			Assert.AreEqual(td1, td2);
+			Assert.That(td2, Is.EqualTo(td1));
-			Assert.AreEqual(td1.a, td2.a);
+			Assert.That(td2.a, Is.EqualTo(td1.a));
-			Assert.AreEqual(td1.B, td2.B);
+			Assert.That(td2.B, Is.EqualTo(td1.B));
-			Assert.AreEqual(td1.size1, td2.size1);
+			Assert.That(td2.size1, Is.EqualTo(td1.size1));
-			Assert.AreEqual(td1.Size2, td2.Size2);
+			Assert.That(td2.Size2, Is.EqualTo(td1.Size2));
 		}
-		//-------------------------------------------------------------------
+
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Base/Generic/Regex_Tester.cs

@@ -1,58 +1,55 @@
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Generic
 {
-	[TestClass]
+	[TestFixture]
 	public class Regex_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		// Data members.
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void Regex_FolderPaths()
 		{
-			Assert.AreEqual(true, Regex.IsMatch("abcabcabc\\.metadata\\.plugins\\abcabcabc", ".*?\\\\\\.metadata\\\\\\.plugins\\\\.*?"));
+			Assert.That(Regex.IsMatch("abcabcabc\\.metadata\\.plugins\\abcabcabc", ".*?\\\\\\.metadata\\\\\\.plugins\\\\.*?"), Is.EqualTo(true));
 
 			// Path ends in.
-			Assert.AreEqual(true, Regex.IsMatch("D:\\Home\\Data\\Logs\\App", "[\\\\/]app$", RegexOptions.IgnoreCase));
+			Assert.That(Regex.IsMatch("D:\\Home\\Data\\Logs\\App", "[\\\\/]app$", RegexOptions.IgnoreCase), Is.EqualTo(true));
-			Assert.AreEqual(true, Regex.IsMatch("/home/data/logs/app", "[\\\\/]app$", RegexOptions.IgnoreCase));
+			Assert.That(Regex.IsMatch("/home/data/logs/app", "[\\\\/]app$", RegexOptions.IgnoreCase), Is.EqualTo(true));
 
 			// Path doesn't end in.
-			Assert.AreEqual(false, Regex.IsMatch("D:\\Home\\Data\\Logs", "[\\\\/]app$", RegexOptions.IgnoreCase));
+			Assert.That(Regex.IsMatch("D:\\Home\\Data\\Logs", "[\\\\/]app$", RegexOptions.IgnoreCase), Is.EqualTo(false));
-			Assert.AreEqual(false, Regex.IsMatch("/home/data/logs", "[\\\\/]app$", RegexOptions.IgnoreCase));
+			Assert.That(Regex.IsMatch("/home/data/logs", "[\\\\/]app$", RegexOptions.IgnoreCase), Is.EqualTo(false));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void Regex_IsMatch()
 		{
 			string input = "abcdefghi";
 
-			Assert.AreEqual(true, Regex.IsMatch(input, "a"));
+			Assert.That(Regex.IsMatch(input, "a"), Is.EqualTo(true));
-			Assert.AreEqual(true, Regex.IsMatch(input, "^a"));
+			Assert.That(Regex.IsMatch(input, "^a"), Is.EqualTo(true));
-			Assert.AreEqual(true, Regex.IsMatch(input, "d"));
+			Assert.That(Regex.IsMatch(input, "d"), Is.EqualTo(true));
-			Assert.AreEqual(true, Regex.IsMatch(input, "i$"));
+			Assert.That(Regex.IsMatch(input, "i$"), Is.EqualTo(true));
 
 			// Combination characters.
-			Assert.AreEqual(true, Regex.IsMatch(input, "[adg]"));
+			Assert.That(Regex.IsMatch(input, "[adg]"), Is.EqualTo(true));
-			Assert.AreEqual(true, Regex.IsMatch(input, "[cba]"));
+			Assert.That(Regex.IsMatch(input, "[cba]"), Is.EqualTo(true));
 
 			// Blank matches input.
-			Assert.AreEqual(true, Regex.IsMatch(input, ""));
+			Assert.That(Regex.IsMatch(input, ""), Is.EqualTo(true));
 
 			// Characters at incorrect position.
-			Assert.AreEqual(false, Regex.IsMatch(input, "a$"));
+			Assert.That(Regex.IsMatch(input, "a$"), Is.EqualTo(false));
-			Assert.AreEqual(false, Regex.IsMatch(input, "^d"));
+			Assert.That(Regex.IsMatch(input, "^d"), Is.EqualTo(false));
-			Assert.AreEqual(false, Regex.IsMatch(input, "d$"));
+			Assert.That(Regex.IsMatch(input, "d$"), Is.EqualTo(false));
-			Assert.AreEqual(false, Regex.IsMatch(input, "^i"));
+			Assert.That(Regex.IsMatch(input, "^i"), Is.EqualTo(false));
 
 			// Incorrect characters.
-			Assert.AreEqual(false, Regex.IsMatch(input, "j"));
+			Assert.That(Regex.IsMatch(input, "j"), Is.EqualTo(false));
-			Assert.AreEqual(false, Regex.IsMatch(input, " "));
+			Assert.That(Regex.IsMatch(input, " "), Is.EqualTo(false));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Base/Helpers/SacsCsvHelper_Tester.cs

@@ -1,22 +1,22 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Helpers;
 using Sarand.Net.Standard.Base.Utils;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsCsvHelper_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- CSV Parsing ---
-		//                  C o n v e r t   F r o m   C S V
+
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public void ParseCsv_Data ()
 		{
 			List<String> data = new List<string>()
@@ -48,23 +48,22 @@ namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 			{
 				List<String[]> records = SacsCsvHelper.ParseCsv(data.Concat(Environment.NewLine), parserConfig);
 
-				Assert.IsNotNull(records);
+				Assert.That(records, Is.Not.Null);
 				// Record count.
-				Assert.AreEqual(data.Count, records.Count);
+				Assert.That(records.Count, Is.EqualTo(data.Count));
 				// Field counts.
-				Assert.AreEqual(3, records[0].Length);
+				Assert.That(records[0].Length, Is.EqualTo(3));
-				Assert.AreEqual(6, records[1].Length);
+				Assert.That(records[1].Length, Is.EqualTo(6));
-				Assert.AreEqual(4, records[2].Length);
+				Assert.That(records[2].Length, Is.EqualTo(4));
 				// Field values.
-				Assert.AreEqual("B", records[0][1]);
+				Assert.That(records[0][1], Is.EqualTo("B"));
-				Assert.AreEqual("E", records[1][1]);
+				Assert.That(records[1][1], Is.EqualTo("E"));
-				Assert.AreEqual("\"G\"", records[1][3]);
+				Assert.That(records[1][3], Is.EqualTo("\"G\""));
-				Assert.AreEqual("I,", records[1][5]);
+				Assert.That(records[1][5], Is.EqualTo("I,"));
-				Assert.AreEqual("X", records[2][1]);
+				Assert.That(records[2][1], Is.EqualTo("X"));
 			}
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void ParseCsv_Data_InvalidQuotes ()
 		{
 			List<String> data = new List<string>()
@@ -76,35 +75,32 @@ namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 			SacsCsvHelper.ParserConfig config = new SacsCsvHelper.ParserConfig();
 			List<String[]> records = SacsCsvHelper.ParseCsv(data.Concat(Environment.NewLine));
 
-			Assert.IsNotNull(records);
+			Assert.That(records, Is.Not.Null);
 			// 1 invalid record ignored.
-			Assert.AreEqual(data.Count - 1, records.Count);
+			Assert.That(records.Count, Is.EqualTo(data.Count - 1));
 		}
 
-		//-------------------------------------------------------------------
+		// --- CSV Formatting ---
-		//                    C o n v e r t   T o   C S V
+		[Test]
-		//-------------------------------------------------------------------
-		[TestMethod]
 		public void ToCsv_Fields ()
 		{
 			//SaCsvHelper csvHelper = new SaCsvHelper();
 
 			// Single record, alternative collections.
-			Assert.AreEqual("A,B,C", SacsCsvHelper.ToCsv(new String[] { "A", "B", "C" }));
+			Assert.That(SacsCsvHelper.ToCsv(new String[] { "A", "B", "C" }), Is.EqualTo("A,B,C"));
-			Assert.AreEqual("A,B,C", SacsCsvHelper.ToCsv(new Collection<String>() { "A", "B", "C" }));
+			Assert.That(SacsCsvHelper.ToCsv(new Collection<String>() { "A", "B", "C" }), Is.EqualTo("A,B,C"));
-			Assert.AreEqual("A,B,C", SacsCsvHelper.ToCsv(new List<String>() { "A", "B", "C" }));
+			Assert.That(SacsCsvHelper.ToCsv(new List<String>() { "A", "B", "C" }), Is.EqualTo("A,B,C"));
-			Assert.AreEqual("D,E,F", SacsCsvHelper.ToCsv(new String[] { "D", "E", "F" }));
+			Assert.That(SacsCsvHelper.ToCsv(new String[] { "D", "E", "F" }), Is.EqualTo("D,E,F"));
 
 			// Embedded delimiter.
-			Assert.AreEqual("\"A,\",B,C", SacsCsvHelper.ToCsv(new String[] { "A,", "B", "C" }));
+			Assert.That(SacsCsvHelper.ToCsv(new String[] { "A,", "B", "C" }), Is.EqualTo("\"A,\",B,C"));
-			Assert.AreEqual("A,\",B\",C", SacsCsvHelper.ToCsv(new String[] { "A", ",B", "C" }));
+			Assert.That(SacsCsvHelper.ToCsv(new String[] { "A", ",B", "C" }), Is.EqualTo("A,\",B\",C"));
 
 			// Embedded quotes.
-			Assert.AreEqual("\"\"\"A\"\"\",B,C", SacsCsvHelper.ToCsv(new String[] { "\"A\"", "B", "C" }));
+			Assert.That(SacsCsvHelper.ToCsv(new String[] { "\"A\"", "B", "C" }), Is.EqualTo("\"\"\"A\"\"\",B,C"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void ToCsv_Records ()
 		{
 			//SaCsvHelper csvHelper = new SaCsvHelper();
@@ -120,14 +116,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 			// Multiple records, multiple times to verify clearing of data each time.
 			for (int i = 0; i < 10; i++)
 			{
-				Assert.AreEqual(3, records.Count);
+				Assert.That(records.Count, Is.EqualTo(3));
-				Assert.AreEqual("A,B,C", records[0]);
+				Assert.That(records[0], Is.EqualTo("A,B,C"));
-				Assert.AreEqual("D,E,F,G,H,I", records[1]);
+				Assert.That(records[1], Is.EqualTo("D,E,F,G,H,I"));
-				Assert.AreEqual("W,X,Y,Z", records[2]);
+				Assert.That(records[2], Is.EqualTo("W,X,Y,Z"));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Helpers/SacsDataValidationHelper_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Helpers;
 using System;
 using System.Collections.Generic;
@@ -6,105 +6,100 @@ using System.Text;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsDataValidationHelper_Tester
 	{
-		//-------------------------------------------------------------------
 		// Email addresses.
-		//-------------------------------------------------------------------
+
-		[TestMethod]
+		// --- Tests ---
+
+		[Test]
 		public void IsValidEmailAddress()
 		{
 			// Valid addresses.
-			Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.com"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.com"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.xx"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.xx"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.co.uk"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.co.uk"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("jb@bloggs.co.uk"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("jb@bloggs.co.uk"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe.bloggs@bloggs.co.uk"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe.bloggs@bloggs.co.uk"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe-bloggs@bloggs.co.uk"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe-bloggs@bloggs.co.uk"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe_bloggs@bloggs.co.uk"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe_bloggs@bloggs.co.uk"), Is.True);
 
 			// Invalid addresses.
-			Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress(null));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress(null), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress(""));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress(""), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress(" "));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress(" "), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress("joe"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress("joe.bloggs.com"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe.bloggs.com"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress("joe@blo ggs.com"));
+			Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@blo ggs.com"), Is.False);
 		}
 
-		//-------------------------------------------------------------------
 		// URLs.
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void IsValidUrl()
 		{
 			// Valid addresses.
-			Assert.IsTrue(SacsDataValidationHelper.IsValidUrl("http://joe.bloggs"));
+			Assert.That(SacsDataValidationHelper.IsValidUrl("http://joe.bloggs"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidUrl("https://joe.bloggs"));
+			Assert.That(SacsDataValidationHelper.IsValidUrl("https://joe.bloggs"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidUrl("//joe.bloggs"));
+			Assert.That(SacsDataValidationHelper.IsValidUrl("//joe.bloggs"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidUrl("joe.bloggs"));
+			Assert.That(SacsDataValidationHelper.IsValidUrl("joe.bloggs"), Is.True);
 
 			// Invalid addresses.
-			Assert.IsFalse(SacsDataValidationHelper.IsValidUrl(null));
+			Assert.That(SacsDataValidationHelper.IsValidUrl(null), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidUrl(""));
+			Assert.That(SacsDataValidationHelper.IsValidUrl(""), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidUrl(" "));
+			Assert.That(SacsDataValidationHelper.IsValidUrl(" "), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidUrl("joe"));
+			Assert.That(SacsDataValidationHelper.IsValidUrl("joe"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidUrl("joe@bloggs.com"));
+			Assert.That(SacsDataValidationHelper.IsValidUrl("joe@bloggs.com"), Is.False);
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void IsValidWikipediaUrl()
 		{
 			// Valid addresses.
-			Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("en.wikipedia.org/wiki/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("en.wikipedia.org/wiki/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("//en.wikipedia.org/wiki/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("//en.wikipedia.org/wiki/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("https://en.wikipedia.org/wiki/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("https://en.wikipedia.org/wiki/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("en.wikipedia.org/w/index.php?etc"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("en.wikipedia.org/w/index.php?etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("//en.wikipedia.org/w/index.php?etc"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("//en.wikipedia.org/w/index.php?etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("https://en.wikipedia.org/w/index.php?etc"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("https://en.wikipedia.org/w/index.php?etc"), Is.True);
 
 			// Invalid addresses.
-			Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl(null));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl(null), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl(""));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl(""), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl(" "));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl(" "), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl("http://en.wikipedia.org/wiki/"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("http://en.wikipedia.org/wiki/"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl("http://en.wikipedia.org/w/index.php"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("http://en.wikipedia.org/w/index.php"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl("htps://www.bbc.co.uk"));
+			Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("htps://www.bbc.co.uk"), Is.False);
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void IsValidLinkedInUrl()
 		{
 			// Valid addresses.
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("www.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("www.linkedin.com/in/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("//www.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("//www.linkedin.com/in/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("https://www.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("https://www.linkedin.com/in/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("en.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("en.linkedin.com/in/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("//en.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("//en.linkedin.com/in/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("https://en.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("https://en.linkedin.com/in/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("xx.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("xx.linkedin.com/in/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("//xx.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("//xx.linkedin.com/in/etc"), Is.True);
-			Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("https://xx.linkedin.com/in/etc"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("https://xx.linkedin.com/in/etc"), Is.True);
 
 			// Invalid addresses.
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl(null));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl(null), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl(""));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl(""), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl(" "));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl(" "), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("http://www.linkedin.com/in/"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("http://www.linkedin.com/in/"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("http://xx.linkedin.com/in/"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("http://xx.linkedin.com/in/"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("http://xx.linkedin.com/in/"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("http://xx.linkedin.com/in/"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("linkedin.com/in/"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("linkedin.com/in/"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("x.linkedin.com/in/"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("x.linkedin.com/in/"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("xxx.linkedin.com/in/"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("xxx.linkedin.com/in/"), Is.False);
-			Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("htps://www.bbc.co.uk"));
+			Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("htps://www.bbc.co.uk"), Is.False);
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Helpers/SacsRandomHelper_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Helpers;
 using System;
 using System.Collections.Generic;
@@ -7,24 +7,24 @@ using System.Text;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SacsRandomHelper_Tester
 	{
-		//-------------------------------------------------------------------
 		// Random Helper.
-		//-------------------------------------------------------------------
 		// Fill byte array.
-		[TestMethod]
+
+		// --- Tests ---
+
+		[Test]
 		public void Fill_ByteArray()
 		{
 			int dataLength = 10;
 			byte[] data = new byte[dataLength];
-			Assert.IsNotNull(data);
+			Assert.That(data, Is.Not.Null);
 
 			// Initial values should be zero.
 			for (int i = 0; i < dataLength; i++)
-				Assert.AreEqual(0, data[i]);
+				Assert.That(data[i], Is.EqualTo(0));
 
 			SacsRandomHelper.Fill(data);
 
@@ -32,24 +32,22 @@ namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 			int total = 0;
 			for (int i = 0; i < dataLength; i++)
 				total += data[i];
-			Assert.AreNotEqual(0, total);
+			Assert.That(total, Is.Not.EqualTo(0));
 
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void GetInt32_ToExclusive()
 		{
 			for (int i = 1; i < 1000; i++)
 			{
 				int value = SacsRandomHelper.GetInt32(i);
-				Assert.IsTrue(value >= 0);
+				Assert.That(value >= 0, Is.True);
-				Assert.IsTrue(value < i);
+				Assert.That(value < i, Is.True);
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void GetInt32_FromInclusive_ToExclusive()
 		{
 			for (int i = -100; i < 101; i++)
@@ -58,14 +56,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 				{
 					int value = SacsRandomHelper.GetInt32(i, j);
 					//Debug.WriteLine("Value: "+value);
-					Assert.IsTrue(value >= i);
+					Assert.That(value >= i, Is.True);
-					Assert.IsTrue(value < j);
+					Assert.That(value < j, Is.True);
 				}
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void GetInt32_getRandomLengthNumber()
 		{
 			for (ushort i = 1; i < 13; i++)
@@ -74,13 +71,12 @@ namespace Sacs.UnitTests.Net.Standard.Base.Helpers
 				{
 					String value = SacsRandomHelper.GetRandomLengthNumber(i);
 					//Debug.WriteLine("Value: " + value);
-					Assert.IsTrue(value.Length > 0);
+					Assert.That(value.Length > 0, Is.True);
-					Assert.IsTrue(value.Length < i + 1);
+					Assert.That(value.Length < i + 1, Is.True);
 				}
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Procs/SaProcess_Base_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Procs;
 using Sarand.Net.Standard.Base.Tasks;
 using System;
@@ -8,11 +8,11 @@ using System.Threading.Tasks;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Procs
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class SaProcess_Base_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Definitions ---
+
 		private class TestProcessConfig : SaProcess_Base.Config
 		{
 			public TestProcessConfig()
@@ -22,7 +22,6 @@ namespace Sacs.UnitTests.Net.Standard.Base.Procs
 			}
 		}
 
-		//-------------------------------------------------------------------
 		private class TestProcess : SaProcess_Base
 		{
 			public TestProcess(bool stopOnCancellation) : base(new TestProcessConfig())
@@ -51,120 +50,119 @@ namespace Sacs.UnitTests.Net.Standard.Base.Procs
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public async Task RunAsync_CompletesAndClearsAsyncState()
 		{
 			using (TestProcess process = new TestProcess(false))
 			{
 				Task runTask = process.RunAsync();
-				Assert.IsTrue(process.Started.Wait(1000), "Process did not start.");
+				Assert.That(process.Started.Wait(1000), Is.True, "Process did not start.");
-				Assert.IsTrue(process.IsAsync);
+				Assert.That(process.IsAsync, Is.True);
 
 				process.Release.Set();
 				await runTask;
 
-				Assert.IsFalse(process.IsAsync);
+				Assert.That(process.IsAsync, Is.False);
-				Assert.IsFalse(process.Processing);
+				Assert.That(process.Processing, Is.False);
-				Assert.IsTrue(process.ProcessEnded);
+				Assert.That(process.ProcessEnded, Is.True);
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public async Task RunAsync_RejectsOverlappingRun()
 		{
 			using (TestProcess process = new TestProcess(false))
 			{
 				Task runTask = process.RunAsync();
-				Assert.IsTrue(process.Started.Wait(1000), "Process did not start.");
+				Assert.That(process.Started.Wait(1000), Is.True, "Process did not start.");
 
-				await Assert.ThrowsExactlyAsync<SaProcess_Base.InProgressException>(() => process.RunAsync());
+				Assert.ThrowsAsync<SaProcess_Base.InProgressException>(() => process.RunAsync());
 
 				process.Release.Set();
 				await runTask;
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public async Task StopProcessAsync_TimeoutRetainsAsyncState()
 		{
 			using (TestProcess process = new TestProcess(false))
 			{
 				Task runTask = process.RunAsync();
-				Assert.IsTrue(process.Started.Wait(1000), "Process did not start.");
+				Assert.That(process.Started.Wait(1000), Is.True, "Process did not start.");
 
-				Assert.IsFalse(await process.StopProcessAsync(40));
+				Assert.That(await process.StopProcessAsync(40), Is.False);
-				Assert.IsTrue(process.IsAsync, "A timed-out stop must retain the active process state.");
+				Assert.That(process.IsAsync, Is.True, "A timed-out stop must retain the active process state.");
-				await Assert.ThrowsExactlyAsync<SaProcess_Base.InProgressException>(() => process.RunAsync());
+				Assert.ThrowsAsync<SaProcess_Base.InProgressException>(() => process.RunAsync());
 
 				process.Release.Set();
 				await runTask;
-				Assert.IsFalse(process.IsAsync);
+				Assert.That(process.IsAsync, Is.False);
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public async Task StopProcessAsync_CooperativeCancellationStopsProcess()
 		{
 			using (TestProcess process = new TestProcess(true))
 			{
 				Task runTask = process.RunAsync();
-				Assert.IsTrue(process.Started.Wait(1000), "Process did not start.");
+				Assert.That(process.Started.Wait(1000), Is.True, "Process did not start.");
 
-				Assert.IsTrue(await process.StopProcessAsync(1000));
+				Assert.That(await process.StopProcessAsync(1000), Is.True);
 				await runTask;
 
-				Assert.IsTrue(process.CancellationObserved);
+				Assert.That(process.CancellationObserved, Is.True);
-				Assert.IsFalse(process.IsAsync);
+				Assert.That(process.IsAsync, Is.False);
-				Assert.IsTrue(await process.StopProcessAsync(20), "Stopping an idle process should succeed.");
+				Assert.That(await process.StopProcessAsync(20), Is.True, "Stopping an idle process should succeed.");
 			}
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public async Task StopProcessAsync_CancellationCallbackCanReadAsyncState()
 		{
 			using (TestProcess process = new TestProcess(true))
 			{
 				Task runTask = process.RunAsync();
-				Assert.IsTrue(process.Started.Wait(1000), "Process did not start.");
+				Assert.That(process.Started.Wait(1000), Is.True, "Process did not start.");
 
 				CancellationToken cancellationToken = GetCancellationToken(process);
 				bool callbackInvoked = false;
 				using (cancellationToken.Register(() =>
 				{
 					callbackInvoked = true;
-					Assert.IsTrue(process.IsAsync);
+					Assert.That(process.IsAsync, Is.True);
 				}))
 				{
 					Task<bool> stopTask = process.StopProcessAsync(1000);
 					Task completedTask = await Task.WhenAny(stopTask, Task.Delay(2000));
-					Assert.AreSame(stopTask, completedTask, "Cancellation callback deadlocked on the lifecycle lock.");
+					Assert.That(completedTask, Is.SameAs(stopTask), "Cancellation callback deadlocked on the lifecycle lock.");
-					Assert.IsTrue(await stopTask);
+					Assert.That(await stopTask, Is.True);
 				}
 
 				await runTask;
-				Assert.IsTrue(callbackInvoked);
+				Assert.That(callbackInvoked, Is.True);
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- Utilities ---
+
 		private static CancellationToken GetCancellationToken(SaProcess_Base process)
 		{
 			PropertyInfo controlProperty = typeof(SaProcess_Base).GetProperty("Control", BindingFlags.Instance | BindingFlags.NonPublic);
-			Assert.IsNotNull(controlProperty);
+			Assert.That(controlProperty, Is.Not.Null);
 			Object control = controlProperty.GetValue(process);
-			Assert.IsNotNull(control);
+			Assert.That(control, Is.Not.Null);
 
 			PropertyInfo taskDataProperty = control.GetType().GetProperty("TaskData", BindingFlags.Instance | BindingFlags.Public);
-			Assert.IsNotNull(taskDataProperty);
+			Assert.That(taskDataProperty, Is.Not.Null);
 			SacsTaskData taskData = (SacsTaskData)taskDataProperty.GetValue(control);
-			Assert.IsNotNull(taskData);
+			Assert.That(taskData, Is.Not.Null);
 			return taskData.CancellationToken;
 		}
+
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Utils/DateUtil_Tester.cs

@@ -1,56 +1,53 @@
 using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Utils;
 
 namespace Sarand.UnitTests.Core.Base.Utils
 {
-	//=======================================================================
+	[TestFixture]
-	[TestClass]
 	public class DateUtil_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data members.
+
 		private Random random = new Random();
 		private DateTime today = DateTime.Today;
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public void DateTime_CTR_Void ()
 		{
-			Assert.IsNotNull(new DateTime());
+			Assert.That(DateTime.MinValue, Is.EqualTo(new DateTime()));
-			Assert.AreEqual(new DateTime(), DateTime.MinValue);
 		}
 
-		//-------------------------------------------------------------------
+		// --- Time Assignment ---
-		//                          S e t   T i m e
+
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SetTime_DateTime ()
 		{
 			for (int i = 0; i < 1000; i++)
 			{
 				DateTime date = new DateTime(random.Next(1970, 2100), random.Next(1, 13), random.Next(1, 28), random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
 				DateTime time = new DateTime(random.Next(1970, 2100), random.Next(1, 13), random.Next(1, 28), random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
-				Assert.AreEqual(DateUtil.FormatXmlDate(date), DateUtil.FormatXmlDate(date.SetTime(time)));
+				Assert.That(DateUtil.FormatXmlDate(date.SetTime(time)), Is.EqualTo(DateUtil.FormatXmlDate(date)));
-				Assert.AreEqual(DateUtil.FormatXmlTime(time), DateUtil.FormatXmlTime(date.SetTime(time)));
+				Assert.That(DateUtil.FormatXmlTime(date.SetTime(time)), Is.EqualTo(DateUtil.FormatXmlTime(time)));
 			}
 		}
-		[TestMethod]
+		[Test]
 		public void SetTime_TimeSpan ()
 		{
 			for (int i = 0; i < 1000; i++)
 			{
 				DateTime date = new DateTime(random.Next(1970, 2100), random.Next(1, 13), random.Next(1, 28), random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
 				TimeSpan time = new TimeSpan(random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
-				Assert.AreEqual(DateUtil.FormatXmlDate(date), DateUtil.FormatXmlDate(date.SetTime(time)));
+				Assert.That(DateUtil.FormatXmlDate(date.SetTime(time)), Is.EqualTo(DateUtil.FormatXmlDate(date)));
-				Assert.AreEqual(DateUtil.FormatXmlTime(today + time), DateUtil.FormatXmlTime(date.SetTime(time)));
+				Assert.That(DateUtil.FormatXmlTime(date.SetTime(time)), Is.EqualTo(DateUtil.FormatXmlTime(today + time)));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- Time Rounding ---
-		//                        R o u n d   T i m e
+
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void RoundTime ()
 		{
 			for (int i = 0; i < 2000; i++)
@@ -62,28 +59,28 @@ namespace Sarand.UnitTests.Core.Base.Utils
 					int expectedMins = ((datetime.Minute / intervalMins) + (datetime.Minute % intervalMins > 0 ? 1 : 0)) * intervalMins;
 					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
 					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Up,true);
-					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
+					Assert.That(DateUtil.FormatXmlDateTime(rounded), Is.EqualTo(DateUtil.FormatXmlDateTime(expected)));
 				}
 				{
 					// Round up with seconds.
 					int expectedMins = ((datetime.Minute / intervalMins) + ((datetime.Minute * 60 + datetime.Second) % (intervalMins * 60) > 0 ? 1 : 0)) * intervalMins;
 					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
 					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Up,false);
-					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
+					Assert.That(DateUtil.FormatXmlDateTime(rounded), Is.EqualTo(DateUtil.FormatXmlDateTime(expected)));
 				}
 				{
 					// Round down without seconds.
 					int expectedMins = (datetime.Minute / intervalMins) * intervalMins;
 					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
 					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Down,true);
-					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
+					Assert.That(DateUtil.FormatXmlDateTime(rounded), Is.EqualTo(DateUtil.FormatXmlDateTime(expected)));
 				}
 				{
 					// Round down with seconds.
 					int expectedMins = (datetime.Minute / intervalMins) * intervalMins;
 					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
 					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Down,false);
-					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
+					Assert.That(DateUtil.FormatXmlDateTime(rounded), Is.EqualTo(DateUtil.FormatXmlDateTime(expected)));
 				}
 				{
 					// Nearest without seconds.
@@ -94,7 +91,7 @@ namespace Sarand.UnitTests.Core.Base.Utils
 					{
 						//String s = "";
 					}
-					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
+					Assert.That(DateUtil.FormatXmlDateTime(rounded), Is.EqualTo(DateUtil.FormatXmlDateTime(expected)));
 				}
 				{
 					// Nearest with seconds.
@@ -105,62 +102,57 @@ namespace Sarand.UnitTests.Core.Base.Utils
 					{
 						//String s = "";
 					}
-					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
+					Assert.That(DateUtil.FormatXmlDateTime(rounded), Is.EqualTo(DateUtil.FormatXmlDateTime(expected)));
 				}
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- Parsing ---
-		//               C o n v e r t   F r o m   S t r i n g
+
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void DateTime_ParseXmlDate ()
 		{
 			String xmlDate = "2015-05-28";
-			Assert.AreEqual(new DateTime(2015, 5, 28), DateUtil.ParseXmlDate(xmlDate));
+			Assert.That(DateUtil.ParseXmlDate(xmlDate), Is.EqualTo(new DateTime(2015, 5, 28)));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void DateTime_ParseXmlTime ()
 		{
 			String xmlTime = "16:25:57";
-			Assert.AreEqual(new DateTime(today.Year, today.Month, today.Day, 16, 25, 57), DateUtil.ParseXmlTime(xmlTime));
+			Assert.That(DateUtil.ParseXmlTime(xmlTime), Is.EqualTo(new DateTime(today.Year, today.Month, today.Day, 16, 25, 57)));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void DateTime_ParseXmlDateTime ()
 		{
 			String xmlDateTime = "2010-05-28T17:05:01";
-			Assert.AreEqual(new DateTime(2010, 5, 28, 17, 5, 1), DateUtil.ParseXmlDateTime(xmlDateTime));
+			Assert.That(DateUtil.ParseXmlDateTime(xmlDateTime), Is.EqualTo(new DateTime(2010, 5, 28, 17, 5, 1)));
 		}
 
-		//-------------------------------------------------------------------------
+		// --- Validation ---
-		//                           V a l i d a t i o n
+
-		//-------------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void DateTime_IsValid ()
 		{
 			// Valid.
-			Assert.AreEqual(true, DateUtil.IsValid(DateTime.Now));
+			Assert.That(DateUtil.IsValid(DateTime.Now), Is.EqualTo(true));
-			Assert.AreEqual(true, DateUtil.IsValid(DateTime.Today));
+			Assert.That(DateUtil.IsValid(DateTime.Today), Is.EqualTo(true));
-			Assert.AreEqual(true, DateUtil.IsValid(new DateTime(2018, 2, 12, 10, 32, 56)));
+			Assert.That(DateUtil.IsValid(new DateTime(2018, 2, 12, 10, 32, 56)), Is.EqualTo(true));
 
 			// Invalid.
-			Assert.AreEqual(false, DateUtil.IsValid(DateTime.MinValue));
+			Assert.That(DateUtil.IsValid(DateTime.MinValue), Is.EqualTo(false));
-			Assert.AreEqual(false, DateUtil.IsValid(DateTime.MaxValue));
+			Assert.That(DateUtil.IsValid(DateTime.MaxValue), Is.EqualTo(false));
-			Assert.AreEqual(false, DateUtil.IsValid(new DateTime(0)));
+			Assert.That(DateUtil.IsValid(new DateTime(0)), Is.EqualTo(false));
-			Assert.AreEqual(false, DateUtil.IsValid(new DateTime(1, 1, 1)));
+			Assert.That(DateUtil.IsValid(new DateTime(1, 1, 1)), Is.EqualTo(false));
 
 			// Nullable.
-			Assert.AreEqual(false, DateUtil.IsValid(null));
+			Assert.That(DateUtil.IsValid(null), Is.EqualTo(false));
 		}
 
-		//-------------------------------------------------------------------
 		// Relative dates - Week.
 		// DateUtil.StartOfWeek
-		[TestMethod]
+		[Test]
 		public void DateTime_StartOfWeek ()
 		{
 			for (int i = 0; i < 1000; i++)
@@ -168,11 +160,11 @@ namespace Sarand.UnitTests.Core.Base.Utils
 				// Random date between 0AD and 3000AD (or thereabouts):
 				DateTime date = new DateTime(random.Next(0, 365 * 3000) * TimeSpan.TicksPerDay);
 				//Trace.WriteLine("DateUtil_Tester.DateTime_StartOfWeek Date=" + date.Format("ddd d-MMM-yyyy") + ", Start of week=" + date.StartOfWeek().Format("ddd d-MMM-yyyy"));
-				Assert.AreEqual("Sun", date.StartOfWeek().Format("ddd"));
+				Assert.That(date.StartOfWeek().Format("ddd"), Is.EqualTo("Sun"));
 			}
 		}
 		// DateUtil.StartOfWeek
-		[TestMethod]
+		[Test]
 		public void DateTime_StartOfWorkingWeek ()
 		{
 			for (int i = 0; i < 1000; i++)
@@ -180,80 +172,74 @@ namespace Sarand.UnitTests.Core.Base.Utils
 				// Random date between 0AD and 3000AD (or thereabouts):
 				DateTime date = new DateTime(random.Next(0, 365 * 3000) * TimeSpan.TicksPerDay);
 				//Trace.WriteLine("DateUtil_Tester.DateTime_StartOfWorkingWeek Date=" + date.Format("ddd d-MMM-yyyy") + ", Start of week=" + date.StartOfWorkingWeek().Format("ddd d-MMM-yyyy"));
-				Assert.AreEqual("Mon", date.StartOfWorkingWeek().Format("ddd"));
+				Assert.That(date.StartOfWorkingWeek().Format("ddd"), Is.EqualTo("Mon"));
 			}
 		}
 
-		//-------------------------------------------------------------------
 		// Relative dates - Month.
 		// DateUtil.StartOfMonth
-		[TestMethod]
+		[Test]
 		public void DateTime_StartOfMonth ()
 		{
 			DateTime dt20160723 = new DateTime(2016, 7, 23);
-			Assert.AreEqual(dt20160723.StartOfMonth(), new DateTime(2016, 7, 1));
+			Assert.That(new DateTime(2016, 7, 1), Is.EqualTo(dt20160723.StartOfMonth()));
 		}
 		// DateUtil.EndOfMonth
-		[TestMethod]
+		[Test]
 		public void DateTime_DaysInMonth ()
 		{
 			DateTime dt20160723 = new DateTime(2016, 7, 23);
-			Assert.AreEqual(31, dt20160723.DaysInMonth());
+			Assert.That(dt20160723.DaysInMonth(), Is.EqualTo(31));
 		}
 		// DateUtil.EndOfMonth
-		[TestMethod]
+		[Test]
 		public void DateTime_EndOfMonth ()
 		{
 			DateTime dt20160723 = new DateTime(2016, 7, 23);
-			Assert.AreEqual(dt20160723.EndOfMonth(), new DateTime(2016, 7, 31));
+			Assert.That(new DateTime(2016, 7, 31), Is.EqualTo(dt20160723.EndOfMonth()));
 		}
 
-		//-------------------------------------------------------------------
+		// --- Formatting ---
-		//                        F o r m a t t i n g
+
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void DateTime_Format_Void ()
 		{
 			DateTime dt20160723 = new DateTime(2016, 7, 23);
 			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);
 
-			Assert.AreEqual("23/07/2016", dt20160723.Format("dd/MM/yyyy"));
+			Assert.That(dt20160723.Format("dd/MM/yyyy"), Is.EqualTo("23/07/2016"));
-			Assert.AreEqual("23/07/2016 00:00:00", dt20160723.Format("dd/MM/yyyy HH:mm:ss"));
+			Assert.That(dt20160723.Format("dd/MM/yyyy HH:mm:ss"), Is.EqualTo("23/07/2016 00:00:00"));
 
-			Assert.AreEqual("23/07/2016", dt20160723172829.Format("dd/MM/yyyy"));
+			Assert.That(dt20160723172829.Format("dd/MM/yyyy"), Is.EqualTo("23/07/2016"));
-			Assert.AreEqual("23/07/2016 17:28:39", dt20160723172829.Format("dd/MM/yyyy HH:mm:ss"));
+			Assert.That(dt20160723172829.Format("dd/MM/yyyy HH:mm:ss"), Is.EqualTo("23/07/2016 17:28:39"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void DateTime_FormatXmlDate ()
 		{
 			DateTime dt20160723 = new DateTime(2016, 7, 23);
 			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);
 
-			Assert.AreEqual("2016-07-23", DateUtil.FormatXmlDate(dt20160723));
+			Assert.That(DateUtil.FormatXmlDate(dt20160723), Is.EqualTo("2016-07-23"));
-			Assert.AreEqual("2016-07-23", DateUtil.FormatXmlDate(dt20160723172829));
+			Assert.That(DateUtil.FormatXmlDate(dt20160723172829), Is.EqualTo("2016-07-23"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void DateTime_FormatXmlTime ()
 		{
 			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);
 
-			Assert.AreEqual("17:28:39", DateUtil.FormatXmlTime(dt20160723172829));
+			Assert.That(DateUtil.FormatXmlTime(dt20160723172829), Is.EqualTo("17:28:39"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void DateTime_FormatXmlDateTime ()
 		{
 			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);
 
-			Assert.AreEqual("2016-07-23T17:28:39", DateUtil.FormatXmlDateTime(dt20160723172829));
+			Assert.That(DateUtil.FormatXmlDateTime(dt20160723172829), Is.EqualTo("2016-07-23T17:28:39"));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
-	//=======================================================================
 }

SacsCoreUnitTests/Standard/Base/Utils/EnumUtil_Tester.cs

@@ -1,70 +1,66 @@
 using System;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Core;
 using Sarand.Net.Standard.Base.Utils;
 
 namespace Sarand.UnitTests.Core.Base.Utils
 {
-	[TestClass]
+	[TestFixture]
 	public class EnumUtil_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		// Data members.
+
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void EnumUtil_IsValid ()
 		{
-			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(0));
+			Assert.That(EnumUtil.IsValid<SaMessageLevel>(0), Is.True);
-			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(1));
+			Assert.That(EnumUtil.IsValid<SaMessageLevel>(1), Is.True);
-			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(2));
+			Assert.That(EnumUtil.IsValid<SaMessageLevel>(2), Is.True);
-			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(3));
+			Assert.That(EnumUtil.IsValid<SaMessageLevel>(3), Is.True);
-			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(4));
+			Assert.That(EnumUtil.IsValid<SaMessageLevel>(4), Is.True);
-			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(5));
+			Assert.That(EnumUtil.IsValid<SaMessageLevel>(5), Is.True);
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void EnumUtil_GetName ()
 		{
-			Assert.AreEqual("Info", EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Info));
+			Assert.That(EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Info), Is.EqualTo("Info"));
-			Assert.AreEqual("Debug", EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Debug));
+			Assert.That(EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Debug), Is.EqualTo("Debug"));
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void EnumUtil_GetValues ()
 		{
-			Assert.AreEqual(9,EnumUtil.GetValues<SaMessageLevel>().ToList().Count);
+			Assert.That(EnumUtil.GetValues<SaMessageLevel>().ToList().Count, Is.EqualTo(9));
-			Assert.AreEqual(SaMessageLevel.Info,EnumUtil.GetValues<SaMessageLevel>().ToArray()[6]);
+			Assert.That(EnumUtil.GetValues<SaMessageLevel>().ToArray()[6], Is.EqualTo(SaMessageLevel.Info));
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void EnumUtil_ParseEnum ()
 		{
-			Assert.AreEqual(SaMessageLevel.Info, EnumUtil.ParseEnum<SaMessageLevel>("Info"));
+			Assert.That(EnumUtil.ParseEnum<SaMessageLevel>("Info"), Is.EqualTo(SaMessageLevel.Info));
-			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.ParseEnum<SaMessageLevel>("Debug"));
+			Assert.That(EnumUtil.ParseEnum<SaMessageLevel>("Debug"), Is.EqualTo(SaMessageLevel.Debug));
 		}
-		[TestMethod]
+		[Test]
 		public void EnumUtil_ParseEnum_Exception ()
 		{
-			Assert.ThrowsExactly<ArgumentException>(() => EnumUtil.ParseEnum<SaMessageLevel>("ABC"));
+			Assert.Throws<ArgumentException>(() => EnumUtil.ParseEnum<SaMessageLevel>("ABC"));
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void EnumUtil_StartsWith ()
 		{
-			Assert.AreEqual(SaMessageLevel.Info, EnumUtil.StartsWith<SaMessageLevel>("I", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("I", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Info));
-			Assert.AreEqual(SaMessageLevel.Info, EnumUtil.StartsWith<SaMessageLevel>("i", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("i", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Info));
-			Assert.AreEqual(SaMessageLevel.Info, EnumUtil.StartsWith<SaMessageLevel>("inf", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("inf", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Info));
-			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("D", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("D", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
-			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("d", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("d", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
-			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("DE", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("DE", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
-			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("DEB", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("DEB", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
-			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("DEBU", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("DEBU", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
-			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("DEBUG", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("DEBUG", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
-			Assert.AreEqual(SaMessageLevel.Error, EnumUtil.StartsWith<SaMessageLevel>("Err", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("Err", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Error));
-			Assert.AreEqual(SaMessageLevel.None, EnumUtil.StartsWith<SaMessageLevel>("", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.None));
-			Assert.AreEqual(SaMessageLevel.Error, EnumUtil.StartsWith<SaMessageLevel>("ABC", SaMessageLevel.Error));
+			Assert.That(EnumUtil.StartsWith<SaMessageLevel>("ABC", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Error));
 		}
-		//-------------------------------------------------------------------
+
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Base/Utils/FtpUtil_Tester.cs

@@ -1,63 +1,63 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Utils;
 using System;
 
 namespace Sarand.UnitTests.Core.Base.Utils
 
 {
-	[TestClass]
+	[TestFixture]
 	public class FtpUtil_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data members.
+
 		private Random random = new Random();
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		[TestMethod]
+
+		[Test]
 		public void FtpUtil_CleansePath ()
 		{
-			Assert.AreEqual("abc", FtpUtil.CleansePath("abc"));
+			Assert.That(FtpUtil.CleansePath("abc"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.CleansePath("/abc"));
+			Assert.That(FtpUtil.CleansePath("/abc"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.CleansePath("\\abc"));
+			Assert.That(FtpUtil.CleansePath("\\abc"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.CleansePath("/abc/"));
+			Assert.That(FtpUtil.CleansePath("/abc/"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.CleansePath("\\abc\\"));
+			Assert.That(FtpUtil.CleansePath("\\abc\\"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("abc/def"));
+			Assert.That(FtpUtil.CleansePath("abc/def"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("abc\\def"));
+			Assert.That(FtpUtil.CleansePath("abc\\def"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("/abc/def"));
+			Assert.That(FtpUtil.CleansePath("/abc/def"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("\\abc\\def"));
+			Assert.That(FtpUtil.CleansePath("\\abc\\def"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("abc/def/"));
+			Assert.That(FtpUtil.CleansePath("abc/def/"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("abc\\def\\"));
+			Assert.That(FtpUtil.CleansePath("abc\\def\\"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("/abc/def/"));
+			Assert.That(FtpUtil.CleansePath("/abc/def/"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("\\abc\\def\\"));
+			Assert.That(FtpUtil.CleansePath("\\abc\\def\\"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("/abc//def/"));
+			Assert.That(FtpUtil.CleansePath("/abc//def/"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc/def", FtpUtil.CleansePath("\\abc\\\\def\\"));
+			Assert.That(FtpUtil.CleansePath("\\abc\\\\def\\"), Is.EqualTo("abc/def"));
-			Assert.AreEqual("abc-def", FtpUtil.CleansePath("abc-def"));
+			Assert.That(FtpUtil.CleansePath("abc-def"), Is.EqualTo("abc-def"));
-			Assert.AreEqual("abc.def", FtpUtil.CleansePath("abc.def"));
+			Assert.That(FtpUtil.CleansePath("abc.def"), Is.EqualTo("abc.def"));
 		}
 
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void FtpUtil_ParentFolder ()
 		{
-			Assert.AreEqual("", FtpUtil.GetParentFolder("abc"));
+			Assert.That(FtpUtil.GetParentFolder("abc"), Is.Empty);
-			Assert.AreEqual("", FtpUtil.GetParentFolder("/abc"));
+			Assert.That(FtpUtil.GetParentFolder("/abc"), Is.Empty);
-			Assert.AreEqual("", FtpUtil.GetParentFolder("\\abc"));
+			Assert.That(FtpUtil.GetParentFolder("\\abc"), Is.Empty);
-			Assert.AreEqual("", FtpUtil.GetParentFolder("/abc/"));
+			Assert.That(FtpUtil.GetParentFolder("/abc/"), Is.Empty);
-			Assert.AreEqual("", FtpUtil.GetParentFolder("\\abc\\"));
+			Assert.That(FtpUtil.GetParentFolder("\\abc\\"), Is.Empty);
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("abc/def"));
+			Assert.That(FtpUtil.GetParentFolder("abc/def"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("abc\\def"));
+			Assert.That(FtpUtil.GetParentFolder("abc\\def"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("/abc/def"));
+			Assert.That(FtpUtil.GetParentFolder("/abc/def"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("\\abc\\def"));
+			Assert.That(FtpUtil.GetParentFolder("\\abc\\def"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("abc/def/"));
+			Assert.That(FtpUtil.GetParentFolder("abc/def/"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("abc\\def\\"));
+			Assert.That(FtpUtil.GetParentFolder("abc\\def\\"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("/abc/def/"));
+			Assert.That(FtpUtil.GetParentFolder("/abc/def/"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("\\abc\\def\\"));
+			Assert.That(FtpUtil.GetParentFolder("\\abc\\def\\"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("/abc//def/"));
+			Assert.That(FtpUtil.GetParentFolder("/abc//def/"), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", FtpUtil.GetParentFolder("\\abc\\\\def\\"));
+			Assert.That(FtpUtil.GetParentFolder("\\abc\\\\def\\"), Is.EqualTo("abc"));
-			Assert.AreEqual("", FtpUtil.GetParentFolder("abc-def"));
+			Assert.That(FtpUtil.GetParentFolder("abc-def"), Is.Empty);
-			Assert.AreEqual("", FtpUtil.GetParentFolder("abc.def"));
+			Assert.That(FtpUtil.GetParentFolder("abc.def"), Is.Empty);
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Base/Utils/ImageUtils_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Utils;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.Formats;
@@ -11,12 +11,12 @@ using System.Text;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Utils
 {
-	[TestClass]
+	[TestFixture]
 	public class ImageUtils_Tester
 	{
 		// --- Image Recognition ---
 
-		[TestMethod]
+		[Test]
 		public void VerifyImageData_RecognisesPngAndJpegDimensions()
 		{
 			byte[] pngData = CreateImageData(7, 5, new PngEncoder());
@@ -25,45 +25,45 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 			ImageUtils.ImageConfig pngConfig = ImageUtils.VerifyImageData(pngData);
 			ImageUtils.ImageConfig jpegConfig = ImageUtils.VerifyImageData(jpegData);
 
-			Assert.IsTrue(pngConfig.ValidImage);
+			Assert.That(pngConfig.ValidImage, Is.True);
-			Assert.AreEqual("PNG", pngConfig.ImageFormatName);
+			Assert.That(pngConfig.ImageFormatName, Is.EqualTo("PNG"));
-			Assert.AreEqual("image/png", pngConfig.DefaultMimeType);
+			Assert.That(pngConfig.DefaultMimeType, Is.EqualTo("image/png"));
-			Assert.AreEqual(7, pngConfig.Width);
+			Assert.That(pngConfig.Width, Is.EqualTo(7));
-			Assert.AreEqual(5, pngConfig.Height);
+			Assert.That(pngConfig.Height, Is.EqualTo(5));
-			Assert.IsTrue(jpegConfig.ValidImage);
+			Assert.That(jpegConfig.ValidImage, Is.True);
-			Assert.AreEqual("JPEG", jpegConfig.ImageFormatName);
+			Assert.That(jpegConfig.ImageFormatName, Is.EqualTo("JPEG"));
-			Assert.AreEqual("image/jpeg", jpegConfig.DefaultMimeType);
+			Assert.That(jpegConfig.DefaultMimeType, Is.EqualTo("image/jpeg"));
-			Assert.AreEqual(9, jpegConfig.Width);
+			Assert.That(jpegConfig.Width, Is.EqualTo(9));
-			Assert.AreEqual(4, jpegConfig.Height);
+			Assert.That(jpegConfig.Height, Is.EqualTo(4));
 		}
 
-		[TestMethod]
+		[Test]
 		public void VerifyImageData_RejectsInvalidAndTruncatedData()
 		{
 			byte[] pngData = CreateImageData(3, 2, new PngEncoder());
 			byte[] truncatedData = new byte[Math.Min(12, pngData.Length)];
 			Array.Copy(pngData, truncatedData, truncatedData.Length);
 
-			Assert.IsFalse(ImageUtils.VerifyImageData(Array.Empty<byte>()).ValidImage);
+			Assert.That(ImageUtils.VerifyImageData(Array.Empty<byte>()).ValidImage, Is.False);
-			Assert.IsFalse(ImageUtils.VerifyImageData(Encoding.UTF8.GetBytes("not an image")).ValidImage);
+			Assert.That(ImageUtils.VerifyImageData(Encoding.UTF8.GetBytes("not an image")).ValidImage, Is.False);
-			Assert.IsFalse(ImageUtils.VerifyImageData(truncatedData).ValidImage);
+			Assert.That(ImageUtils.VerifyImageData(truncatedData).ValidImage, Is.False);
 		}
 
-		[TestMethod]
+		[Test]
 		public void IsSvg_RecognisesSvgAndRejectsFalsePositives()
 		{
 			byte[] svgData = Encoding.UTF8.GetBytes("<SVG xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 10 10\"></SVG>");
 			byte[] missingNamespace = Encoding.UTF8.GetBytes("<svg viewBox=\"0 0 10 10\"></svg>");
 
-			Assert.IsTrue(ImageUtils.IsSvg(svgData));
+			Assert.That(ImageUtils.IsSvg(svgData), Is.True);
-			Assert.IsFalse(ImageUtils.IsSvg(missingNamespace));
+			Assert.That(ImageUtils.IsSvg(missingNamespace), Is.False);
-			Assert.IsFalse(ImageUtils.IsSvg(Encoding.UTF8.GetBytes("svg xmlns=\"http://www.w3.org/2000/svg\"")));
+			Assert.That(ImageUtils.IsSvg(Encoding.UTF8.GetBytes("svg xmlns=\"http://www.w3.org/2000/svg\"")), Is.False);
-			Assert.IsFalse(ImageUtils.IsSvg(null));
+			Assert.That(ImageUtils.IsSvg(null), Is.False);
 		}
 
 		// --- Encoding and Resizing ---
 
-		[TestMethod]
+		[Test]
 		public void LoadAndEncodeImage_PreservesFormatAndDimensions()
 		{
 			byte[] originalData = CreateImageData(8, 6, new PngEncoder());
@@ -72,13 +72,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 			byte[] encodedData = image.GetImageData(format);
 			ImageUtils.ImageConfig encodedConfig = ImageUtils.VerifyImageData(encodedData);
 
-			Assert.AreEqual("PNG", format.Name);
+			Assert.That(format.Name, Is.EqualTo("PNG"));
-			Assert.IsTrue(encodedConfig.ValidImage);
+			Assert.That(encodedConfig.ValidImage, Is.True);
-			Assert.AreEqual(8, encodedConfig.Width);
+			Assert.That(encodedConfig.Width, Is.EqualTo(8));
-			Assert.AreEqual(6, encodedConfig.Height);
+			Assert.That(encodedConfig.Height, Is.EqualTo(6));
 		}
 
-		[TestMethod]
+		[Test]
 		public void ConstrainImage_ResizesLandscapeAndPortraitWithoutUpscaling()
 		{
 			ImageUtils.ImageConfig landscape = ImageUtils.VerifyImageData(CreateImageData(20, 10, new PngEncoder()));
@@ -86,16 +86,16 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 			ImageUtils.ImageConfig withinLimits = ImageUtils.VerifyImageData(CreateImageData(4, 3, new PngEncoder()));
 			byte[] originalData = withinLimits.ImageData;
 
-			Assert.IsTrue(ImageUtils.ConstrainImage(landscape, 8, 8));
+			Assert.That(ImageUtils.ConstrainImage(landscape, 8, 8), Is.True);
-			Assert.AreEqual(8, landscape.Width);
+			Assert.That(landscape.Width, Is.EqualTo(8));
-			Assert.AreEqual(4, landscape.Height);
+			Assert.That(landscape.Height, Is.EqualTo(4));
-			Assert.IsTrue(ImageUtils.ConstrainImage(portrait, 8, 8));
+			Assert.That(ImageUtils.ConstrainImage(portrait, 8, 8), Is.True);
-			Assert.AreEqual(4, portrait.Width);
+			Assert.That(portrait.Width, Is.EqualTo(4));
-			Assert.AreEqual(8, portrait.Height);
+			Assert.That(portrait.Height, Is.EqualTo(8));
-			Assert.IsTrue(ImageUtils.ConstrainImage(withinLimits, 8, 8));
+			Assert.That(ImageUtils.ConstrainImage(withinLimits, 8, 8), Is.True);
-			Assert.AreSame(originalData, withinLimits.ImageData);
+			Assert.That(withinLimits.ImageData, Is.SameAs(originalData));
-			Assert.IsFalse(ImageUtils.ConstrainImage(landscape, 0, 8));
+			Assert.That(ImageUtils.ConstrainImage(landscape, 0, 8), Is.False);
-			Assert.IsFalse(ImageUtils.ConstrainImage(portrait, 8, 0));
+			Assert.That(ImageUtils.ConstrainImage(portrait, 8, 0), Is.False);
 		}
 
 		// --- Utilities ---

SacsCoreUnitTests/Standard/Base/Utils/ListUtil_Tester.cs

@@ -1,45 +1,42 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Utils;
 
 namespace Sarand.UnitTests.Core.Base.Utils
 {
-	[TestClass]
+	[TestFixture]
 	public class ListUtil_Tester
 	{
-		//-------------------------------------------------------------------
-		// Data members.
 
-		//-------------------------------------------------------------------
 		// Is Empty.
-		//-------------------------------------------------------------------
+
-		[TestMethod]
+		// --- Tests ---
+
+		[Test]
 		public void ListUtil_IsEmpty_Test()
 		{
 			List<String> values = new List<string>();
 
-			Assert.AreEqual(true, ListUtil.IsEmpty(values));
+			Assert.That(ListUtil.IsEmpty(values), Is.EqualTo(true));
-			Assert.AreEqual(true, values.IsEmpty());
+			Assert.That(values.IsEmpty(), Is.EqualTo(true));
 
 			for (int i = 0; i < 10; i++)
 				values.Add(i.ToString());
 
-			Assert.AreEqual(false, ListUtil.IsEmpty(values));
+			Assert.That(ListUtil.IsEmpty(values), Is.EqualTo(false));
-			Assert.AreEqual(false, values.IsEmpty());
+			Assert.That(values.IsEmpty(), Is.EqualTo(false));
 
 			values.Clear();
 
-			Assert.AreEqual(true, ListUtil.IsEmpty(values));
+			Assert.That(ListUtil.IsEmpty(values), Is.EqualTo(true));
-			Assert.AreEqual(true, values.IsEmpty());
+			Assert.That(values.IsEmpty(), Is.EqualTo(true));
 		}
 
-		//-------------------------------------------------------------------
 		// Randomise.
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void ListUtil_Randomise_Test()
 		{
 			// Assume that randomising a list of 100 values highly unlikely to result in same sequence!
@@ -54,7 +51,7 @@ namespace Sarand.UnitTests.Core.Base.Utils
 					values.Add(i.ToString());
 
 				for (int i = 0; i < itemsInList; i++)
-					Assert.AreEqual(i.ToString(), values[i]);
+					Assert.That(values[i], Is.EqualTo(i.ToString()));
 
 				values = values.Randomise();
 				//Debug.WriteLine($"{SysUtil.Fn} Values: {values.Concat(",")}");
@@ -68,10 +65,10 @@ namespace Sarand.UnitTests.Core.Base.Utils
 						break;
 					}
 				}
-				Assert.AreEqual(false, originalSequence);
+				Assert.That(originalSequence, Is.EqualTo(false));
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Base/Utils/NewtonsoftJsonUtil_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Sarand.Net.Standard.Base.Bus;
@@ -9,9 +9,11 @@ using System.Collections.Generic;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Utils
 {
-	[TestClass]
+	[TestFixture]
 	public class NewtonsoftJsonUtil_Tester
 	{
+		// --- Definitions ---
+
 		private class JsonData
 		{
 			public string Name { get; set; }
@@ -22,7 +24,7 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 
 		// --- Serialization ---
 
-		[TestMethod]
+		[Test]
 		public void SerializeObject_HandlesObjectsArraysNullsAndSettings()
 		{
 			JsonData data = new JsonData { Name = "alpha", Count = 3, Optional = null };
@@ -31,13 +33,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 			string objectJson = NewtonsoftJsonUtil.SerializeObject(data, settings);
 			string arrayJson = NewtonsoftJsonUtil.SerializeObject(new[] { 1, 2, 3 });
 
-			StringAssert.Contains(objectJson, "\"Name\":\"alpha\"");
+			Assert.That(objectJson, Does.Contain("\"Name\":\"alpha\""));
-			Assert.IsFalse(objectJson.Contains("Optional"));
+			Assert.That(objectJson.Contains("Optional"), Is.False);
-			Assert.AreEqual("[1,2,3]", arrayJson);
+			Assert.That(arrayJson, Is.EqualTo("[1,2,3]"));
-			Assert.AreEqual("null", NewtonsoftJsonUtil.SerializeObject(null));
+			Assert.That(NewtonsoftJsonUtil.SerializeObject(null), Is.EqualTo("null"));
 		}
 
-		[TestMethod]
+		[Test]
 		public void SysIdJsonConverter_RoundTripsValidAndInvalidValues()
 		{
 			string validJson = JsonConvert.SerializeObject(new SysId(42));
@@ -46,54 +48,54 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 			SysId validId = JsonConvert.DeserializeObject<SysId>(validJson);
 			SysId invalidId = JsonConvert.DeserializeObject<SysId>(invalidJson);
 
-			Assert.AreEqual("42", validJson);
+			Assert.That(validJson, Is.EqualTo("42"));
-			Assert.AreEqual("0", invalidJson);
+			Assert.That(invalidJson, Is.EqualTo("0"));
-			Assert.AreEqual(42, validId.ToInt());
+			Assert.That(validId.ToInt(), Is.EqualTo(42));
-			Assert.IsFalse(SysId.IsValid(invalidId));
+			Assert.That(SysId.IsValid(invalidId), Is.False);
-			Assert.IsFalse(SysId.IsValid(JsonConvert.DeserializeObject<SysId>("null")));
+			Assert.That(SysId.IsValid(JsonConvert.DeserializeObject<SysId>("null")), Is.False);
 		}
 
 		// --- Parsing ---
 
-		[TestMethod]
+		[Test]
 		public void ParseJsonMethods_ParseTokensObjectsAndArrays()
 		{
 			JToken token = NewtonsoftJsonUtil.ParseJsonToken("123");
 			JObject jsonObject = NewtonsoftJsonUtil.ParseJsonObject("{\"name\":\"alpha\",\"nested\":{\"enabled\":true}}");
 			JArray jsonArray = NewtonsoftJsonUtil.ParseJsonArray("[1,2,3]");
 
-			Assert.AreEqual(123, token.Value<int>());
+			Assert.That(token.Value<int>(), Is.EqualTo(123));
-			Assert.AreEqual("alpha", jsonObject["name"].Value<string>());
+			Assert.That(jsonObject["name"].Value<string>(), Is.EqualTo("alpha"));
-			Assert.IsTrue(jsonObject["nested"]["enabled"].Value<bool>());
+			Assert.That(jsonObject["nested"]["enabled"].Value<bool>(), Is.True);
-			CollectionAssert.AreEqual(new[] { 1, 2, 3 }, jsonArray.ToObject<int[]>());
+			Assert.That(jsonArray.ToObject<int[]>(), Is.EqualTo(new[] { 1, 2, 3 }));
 		}
 
-		[TestMethod]
+		[Test]
 		public void ParseJsonMethods_ReportInvalidInputWithoutThrowing()
 		{
-			Assert.IsNull(NewtonsoftJsonUtil.ParseJsonToken("{", out Exception tokenException));
+			Assert.That(NewtonsoftJsonUtil.ParseJsonToken("{", out Exception tokenException), Is.Null);
-			Assert.IsNotNull(tokenException);
+			Assert.That(tokenException, Is.Not.Null);
-			Assert.IsNull(NewtonsoftJsonUtil.ParseJsonObject("[]", out Exception objectException));
+			Assert.That(NewtonsoftJsonUtil.ParseJsonObject("[]", out Exception objectException), Is.Null);
-			Assert.IsNotNull(objectException);
+			Assert.That(objectException, Is.Not.Null);
-			Assert.IsNull(NewtonsoftJsonUtil.ParseJsonArray("{}", out Exception arrayException));
+			Assert.That(NewtonsoftJsonUtil.ParseJsonArray("{}", out Exception arrayException), Is.Null);
-			Assert.IsNotNull(arrayException);
+			Assert.That(arrayException, Is.Not.Null);
-			Assert.ThrowsExactly<JsonReaderException>(() => NewtonsoftJsonUtil.ParseJsonToken("{"));
+			Assert.Throws<JsonReaderException>(() => NewtonsoftJsonUtil.ParseJsonToken("{"));
 		}
 
-		[TestMethod]
+		[Test]
 		public void DeserializeJsonObject_ProvidesDynamicPropertyAccess()
 		{
 			dynamic data = SacsJsonHelper.DeserializeJsonObject("{\"name\":\"alpha\",\"count\":3,\"items\":[\"a\",\"b\"]}");
 
-			Assert.AreEqual("alpha", (string)data.name);
+			Assert.That((string)data.name, Is.EqualTo("alpha"));
-			Assert.AreEqual(3, (int)data.count);
+			Assert.That((int)data.count, Is.EqualTo(3));
-			Assert.AreEqual("b", (string)data.items[1]);
+			Assert.That((string)data.items[1], Is.EqualTo("b"));
-			Assert.IsNull(SacsJsonHelper.DeserializeJsonObject("null"));
+			Assert.That((object)SacsJsonHelper.DeserializeJsonObject("null"), Is.Null);
 		}
 
 		// --- Deep Copy ---
 
-		[TestMethod]
+		[Test]
 		public void DeepCopy_CreatesIndependentNestedCollectionsAndReplacesConstructorValues()
 		{
 			JsonData source = new JsonData { Name = "source", Count = 2 };
@@ -103,12 +105,12 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 			JsonData copy = SerializableUtil.DeepCopy(source);
 			copy.Values.Add("copy only");
 
-			Assert.AreNotSame(source, copy);
+			Assert.That(copy, Is.Not.SameAs(source));
-			Assert.AreNotSame(source.Values, copy.Values);
+			Assert.That(copy.Values, Is.Not.SameAs(source.Values));
-			CollectionAssert.AreEqual(new[] { "one", "two" }, source.Values);
+			Assert.That(source.Values, Is.EqualTo(new[] { "one", "two" }));
-			CollectionAssert.AreEqual(new[] { "one", "two", "copy only" }, copy.Values);
+			Assert.That(copy.Values, Is.EqualTo(new[] { "one", "two", "copy only" }));
-			Assert.IsNull(SerializableUtil.DeepCopy<JsonData>(null));
+			Assert.That(SerializableUtil.DeepCopy<JsonData>(null), Is.Null);
-			Assert.AreEqual(String.Empty, SerializableUtil.ToJson<JsonData>(null));
+			Assert.That(SerializableUtil.ToJson<JsonData>(null), Is.Empty);
 		}
 
 		// --- The End ---

SacsCoreUnitTests/Standard/Base/Utils/SerializableUtil_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Utils;
 using System;
 using System.Collections.Generic;
@@ -8,11 +8,11 @@ using System.Threading.Tasks;
 
 namespace Sacs.UnitTests.Net.Standard.Base.Utils
 {
-	[TestClass]
+	[TestFixture]
 	public class SerializableUtil_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Definitions ---
-		// Definitions.
+
 		[Serializable]
 		private class TestData
 		{
@@ -29,14 +29,13 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 			}
 		}
 
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data members.
+
 		private Random random = new Random();
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		// Deep Copy.
+
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SerializableUtil_DeepCopy()
 		{
 			// Clone test data.
@@ -44,23 +43,23 @@ namespace Sacs.UnitTests.Net.Standard.Base.Utils
 			TestData data_DeepCopy = SerializableUtil.DeepCopy(data);
 
 			// Verify results.
-			Assert.AreEqual(true, data_DeepCopy is TestData);
+			Assert.That(data_DeepCopy is TestData, Is.EqualTo(true));
-			Assert.AreEqual(data.stringValue, data_DeepCopy.stringValue);
+			Assert.That(data_DeepCopy.stringValue, Is.EqualTo(data.stringValue));
-			Assert.AreEqual(data.longValue, data_DeepCopy.longValue);
+			Assert.That(data_DeepCopy.longValue, Is.EqualTo(data.longValue));
 
 			// Clone test data A.
 			TestDataA dataA = new TestDataA();
 			TestDataA dataA_DeepCopy = SerializableUtil.DeepCopy(dataA);
 
 			// Verify results.
-			Assert.AreEqual(true, dataA_DeepCopy is TestData);
+			Assert.That(dataA_DeepCopy is TestData, Is.EqualTo(true));
-			Assert.AreEqual(true, dataA_DeepCopy is TestDataA);
+			Assert.That(dataA_DeepCopy is TestDataA, Is.EqualTo(true));
-			Assert.AreEqual(dataA.stringValue, dataA_DeepCopy.stringValue);
+			Assert.That(dataA_DeepCopy.stringValue, Is.EqualTo(dataA.stringValue));
-			Assert.AreEqual(dataA.longValue, dataA_DeepCopy.longValue);
+			Assert.That(dataA_DeepCopy.longValue, Is.EqualTo(dataA.longValue));
-			Assert.AreNotEqual(data.stringValue, dataA_DeepCopy.stringValue);
+			Assert.That(dataA_DeepCopy.stringValue, Is.Not.EqualTo(data.stringValue));
-			Assert.AreNotEqual(data.longValue, dataA_DeepCopy.longValue);
+			Assert.That(dataA_DeepCopy.longValue, Is.Not.EqualTo(data.longValue));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Base/Utils/StringListUtil_Tester.cs

@@ -1,27 +1,28 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Utils;
 
 namespace Sarand.UnitTests.Core.Base.Utils
 {
-	[TestClass]
+	[TestFixture]
 	public class StringListUtil_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data members.
+
 		private Random random = new Random();
-		//-------------------------------------------------------------------
+
-		[TestMethod]
+		// --- Tests ---
+
+		[Test]
 		public void StringList_CreateList ()
 		{
 			List<String> values = StringListUtil.CreateList("ABC",3);
-			Assert.AreEqual(3, values.Count);
+			Assert.That(values.Count, Is.EqualTo(3));
-			Assert.AreEqual("ABC,ABC,ABC", values.Concat(","));
+			Assert.That(values.Concat(","), Is.EqualTo("ABC,ABC,ABC"));
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void StringList_RemoveBlanks ()
 		{
 			List<String> values = new List<string>();
@@ -31,15 +32,15 @@ namespace Sarand.UnitTests.Core.Base.Utils
 			values.Add("B");
 			values.Add("");
 			values.Add("C");
-			Assert.AreEqual(6, values.Count);
+			Assert.That(values.Count, Is.EqualTo(6));
 
 			// Remove blanks without trimming.
 			values.RemoveBlanks(false);
-			Assert.AreEqual(4, values.Count);
+			Assert.That(values.Count, Is.EqualTo(4));
 
 			// Remove blanks with trimming.
 			values.RemoveBlanks(true);
-			Assert.AreEqual(3, values.Count);
+			Assert.That(values.Count, Is.EqualTo(3));
 
 			// Only blanks in list.
 			values.Clear();
@@ -48,12 +49,11 @@ namespace Sarand.UnitTests.Core.Base.Utils
 			values.Add("");
 			values.Add(" ");
 			values.Add("");
-			Assert.AreEqual(5, values.Count);
+			Assert.That(values.Count, Is.EqualTo(5));
 			values.RemoveBlanks();
-			Assert.AreEqual(0, values.Count);
+			Assert.That(values.Count, Is.EqualTo(0));
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void StringList_RemoveDuplicatesCI ()
 		{
 			List<String> values = new List<string>();
@@ -63,50 +63,48 @@ namespace Sarand.UnitTests.Core.Base.Utils
 			values.Add("B");
 			values.Add("b");
 			values.Add("C");
-			Assert.AreEqual(6, values.Count);
+			Assert.That(values.Count, Is.EqualTo(6));
-			Assert.AreEqual("C,A,C,B,B,C", values.Concat(",").ToUpper());
+			Assert.That(values.Concat(",").ToUpper(), Is.EqualTo("C,A,C,B,B,C"));
 
 			// Remove blanks without trimming.
 			values.RemoveDuplicatesCI();
-			Assert.AreEqual(3, values.Count);
+			Assert.That(values.Count, Is.EqualTo(3));
-			Assert.AreEqual("C,A,B", values.Concat(","));
+			Assert.That(values.Concat(","), Is.EqualTo("C,A,B"));
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void StringList_Split ()
 		{
 			// Simple delimiter.
 			List<String> values = StringListUtil.Split("A:B:C",":");
-			Assert.AreEqual(3, values.Count);
+			Assert.That(values.Count, Is.EqualTo(3));
-			Assert.AreEqual("A,B,C", values.Concat(","));
+			Assert.That(values.Concat(","), Is.EqualTo("A,B,C"));
 
 			// Simple delimiter, null value.
 			values = StringListUtil.Split(null, ":");
-			Assert.AreEqual(0, values.Count);
+			Assert.That(values.Count, Is.EqualTo(0));
-			Assert.AreEqual("", values.Concat(","));
+			Assert.That(values.Concat(","), Is.Empty);
 
 			// Simple delimiter, empty value.
 			values = StringListUtil.Split("", ":");
-			Assert.AreEqual(1, values.Count);
+			Assert.That(values.Count, Is.EqualTo(1));
-			Assert.AreEqual("", values.Concat(","));
+			Assert.That(values.Concat(","), Is.Empty);
 
 			// Null delimiter.
 			values = StringListUtil.Split("A:B:C", null);
-			Assert.AreEqual(1, values.Count);
+			Assert.That(values.Count, Is.EqualTo(1));
-			Assert.AreEqual("A:B:C", values.Concat(","));
+			Assert.That(values.Concat(","), Is.EqualTo("A:B:C"));
 
 			// Blank delimiter.
 			values = StringListUtil.Split("A:B:C", "");
-			Assert.AreEqual(1, values.Count);
+			Assert.That(values.Count, Is.EqualTo(1));
-			Assert.AreEqual("A:B:C", values.Concat(","));
+			Assert.That(values.Concat(","), Is.EqualTo("A:B:C"));
 
 			// Blank values.
 			values = StringListUtil.Split("A::B: :C:::", ":", true, true);
-			Assert.AreEqual(3, values.Count);
+			Assert.That(values.Count, Is.EqualTo(3));
-			Assert.AreEqual("A,B,C", values.Concat(","));
+			Assert.That(values.Concat(","), Is.EqualTo("A,B,C"));
 		}
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void StringList_Concat ()
 		{
 			List<String> values = new List<string>();
@@ -117,12 +115,13 @@ namespace Sarand.UnitTests.Core.Base.Utils
 			values.Add("");
 			values.Add("C");
 			values.Add(" ");
-			Assert.AreEqual(7, values.Count);
+			Assert.That(values.Count, Is.EqualTo(7));
-			Assert.AreEqual(",A,,B,,C,", values.Concat(","));
+			Assert.That(values.Concat(","), Is.EqualTo(",A,,B,,C,"));
-			Assert.AreEqual(",A, ,B,,C, ", values.Concat(",", "", "", false, false));
+			Assert.That(values.Concat(",", "", "", false, false), Is.EqualTo(",A, ,B,,C, "));
-			Assert.AreEqual(",A,,B,,C,", values.Concat(",", "", "", true, false));
+			Assert.That(values.Concat(",", "", "", true, false), Is.EqualTo(",A,,B,,C,"));
-			Assert.AreEqual("A,B,C", values.Concat(",", "", "", true, true));
+			Assert.That(values.Concat(",", "", "", true, true), Is.EqualTo("A,B,C"));
 		}
-		//-------------------------------------------------------------------
+
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Base/Utils/StringUtil_Tester.cs

@@ -1,12 +1,12 @@
 using System;
 using System.Linq;
 using System.Text.RegularExpressions;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Utils;
 
 namespace Sarand.UnitTests.Core.Base.Utils
 {
-	[TestClass]
+	[TestFixture]
 	public class StringUtil_Tester
 	{
 		// --- Data Members ---
@@ -15,204 +15,204 @@ namespace Sarand.UnitTests.Core.Base.Utils
 
 		// --- Empty and Blank Values ---
 
-		[TestMethod]
+		[Test]
 		public void StringUtil_IsEmpty()
 		{
 			// Leading spaces.
-			Assert.AreEqual(true, StringUtil.IsEmpty(null));
+			Assert.That(StringUtil.IsEmpty(null), Is.EqualTo(true));
-			Assert.AreEqual(true, StringUtil.IsEmpty(""));
+			Assert.That(StringUtil.IsEmpty(""), Is.EqualTo(true));
-			Assert.AreEqual(false, StringUtil.IsEmpty(" "));
+			Assert.That(StringUtil.IsEmpty(" "), Is.EqualTo(false));
-			Assert.AreEqual(false, StringUtil.IsEmpty("A"));
+			Assert.That(StringUtil.IsEmpty("A"), Is.EqualTo(false));
-			Assert.AreEqual(false, StringUtil.IsEmpty("Abc"));
+			Assert.That(StringUtil.IsEmpty("Abc"), Is.EqualTo(false));
-			Assert.AreEqual(true, "".IsEmpty());
+			Assert.That("".IsEmpty(), Is.EqualTo(true));
-			Assert.AreEqual(false, "Abc".IsEmpty());
+			Assert.That("Abc".IsEmpty(), Is.EqualTo(false));
 		}
 
-		[TestMethod]
+		[Test]
 		public void StringUtil_IsBlank()
 		{
 			// Leading spaces.
-			Assert.AreEqual(true, StringUtil.IsBlank(null));
+			Assert.That(StringUtil.IsBlank(null), Is.EqualTo(true));
-			Assert.AreEqual(true, StringUtil.IsBlank(""));
+			Assert.That(StringUtil.IsBlank(""), Is.EqualTo(true));
-			Assert.AreEqual(true, StringUtil.IsBlank(" "));
+			Assert.That(StringUtil.IsBlank(" "), Is.EqualTo(true));
-			Assert.AreEqual(true, StringUtil.IsBlank("    "));
+			Assert.That(StringUtil.IsBlank("    "), Is.EqualTo(true));
-			Assert.AreEqual(true, StringUtil.IsBlank(" \n\t "));
+			Assert.That(StringUtil.IsBlank(" \n\t "), Is.EqualTo(true));
-			Assert.AreEqual(false, StringUtil.IsBlank("A"));
+			Assert.That(StringUtil.IsBlank("A"), Is.EqualTo(false));
-			Assert.AreEqual(false, StringUtil.IsBlank("Abc"));
+			Assert.That(StringUtil.IsBlank("Abc"), Is.EqualTo(false));
-			Assert.AreEqual(true, "".IsBlank());
+			Assert.That("".IsBlank(), Is.EqualTo(true));
-			Assert.AreEqual(true, " ".IsBlank());
+			Assert.That(" ".IsBlank(), Is.EqualTo(true));
-			Assert.AreEqual(false, "Abc".IsBlank());
+			Assert.That("Abc".IsBlank(), Is.EqualTo(false));
 		}
 
 		// --- Regular Expression Matching ---
 
-		[TestMethod]
+		[Test]
 		public void StringUtil_IsMatch()
 		{
 			// IsMatch.
-			Assert.AreEqual(true, "ABCDEF".IsMatch("ABCDEF"));
+			Assert.That("ABCDEF".IsMatch("ABCDEF"), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatch("^ABCDEF$"));
+			Assert.That("ABCDEF".IsMatch("^ABCDEF$"), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatchCI("AbCdEf"));
+			Assert.That("ABCDEF".IsMatchCI("AbCdEf"), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatchCI("^AbCdEf$"));
+			Assert.That("ABCDEF".IsMatchCI("^AbCdEf$"), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatch("^ABC"));
+			Assert.That("ABCDEF".IsMatch("^ABC"), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatchCI("AbC"));
+			Assert.That("ABCDEF".IsMatchCI("AbC"), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatch("CDE"));
+			Assert.That("ABCDEF".IsMatch("CDE"), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatchCI("cDe"));
+			Assert.That("ABCDEF".IsMatchCI("cDe"), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatch("CDE", System.Text.RegularExpressions.RegexOptions.None));
+			Assert.That("ABCDEF".IsMatch("CDE", System.Text.RegularExpressions.RegexOptions.None), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatch(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)));
+			Assert.That("ABCDEF".IsMatch(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)), Is.EqualTo(true));
-			Assert.AreEqual(true, "ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)));
+			Assert.That("ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)), Is.EqualTo(true));
 
 			// IsMatch with escaped content.
-			Assert.AreEqual(true, "ABC\\sDEF".IsMatch("\\\\s"));
+			Assert.That("ABC\\sDEF".IsMatch("\\\\s"), Is.EqualTo(true));
-			Assert.AreEqual(true, "AB(CD)EF".IsMatch("(..)"));
+			Assert.That("AB(CD)EF".IsMatch("(..)"), Is.EqualTo(true));
-			Assert.AreEqual(true, "AB(CD)EF".IsMatch("\\(CD\\)"));
+			Assert.That("AB(CD)EF".IsMatch("\\(CD\\)"), Is.EqualTo(true));
 
 			// Not match.
-			Assert.AreEqual(false, "ABCDEF".IsMatch("cDe"));
+			Assert.That("ABCDEF".IsMatch("cDe"), Is.EqualTo(false));
-			Assert.AreEqual(false, "ABCDEF".IsMatchCI("eFg"));
+			Assert.That("ABCDEF".IsMatchCI("eFg"), Is.EqualTo(false));
-			Assert.AreEqual(false, "ABCDEF".IsMatch("cDe", System.Text.RegularExpressions.RegexOptions.None));
+			Assert.That("ABCDEF".IsMatch("cDe", System.Text.RegularExpressions.RegexOptions.None), Is.EqualTo(false));
-			Assert.AreEqual(false, "ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)));
+			Assert.That("ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)), Is.EqualTo(false));
 		}
 
-		[TestMethod]
+		[Test]
 		public void StringUtil_Match()
 		{
 			// Match.
-			Assert.AreEqual("CDE", "ABCDEF".GetMatch("CDE"));
+			Assert.That("ABCDEF".GetMatch("CDE"), Is.EqualTo("CDE"));
-			Assert.AreEqual("CDE", "ABCDEF".GetMatchCI("cDe"));
+			Assert.That("ABCDEF".GetMatchCI("cDe"), Is.EqualTo("CDE"));
-			Assert.AreEqual("CDE", "ABCDEF".Match("CDE", System.Text.RegularExpressions.RegexOptions.None).Value);
+			Assert.That("ABCDEF".Match("CDE", System.Text.RegularExpressions.RegexOptions.None).Value, Is.EqualTo("CDE"));
-			Assert.AreEqual("CDE", "ABCDEF".Match(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Value);
+			Assert.That("ABCDEF".Match(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Value, Is.EqualTo("CDE"));
-			Assert.AreEqual("CDE", "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Value);
+			Assert.That("ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Value, Is.EqualTo("CDE"));
 
 			// Match with escaped content.
-			Assert.AreEqual(" ", "ABC DEF".GetMatch("\\s"));
+			Assert.That("ABC DEF".GetMatch("\\s"), Is.EqualTo(" "));
-			Assert.AreEqual("\\s", "ABC\\sDEF".GetMatch("\\\\s"));
+			Assert.That("ABC\\sDEF".GetMatch("\\\\s"), Is.EqualTo("\\s"));
-			Assert.AreEqual("AB", "AB(CD)EF".GetMatch("(..)"));
+			Assert.That("AB(CD)EF".GetMatch("(..)"), Is.EqualTo("AB"));
-			Assert.AreEqual("(CD)", "AB(CD)EF".GetMatch("\\(..\\)"));
+			Assert.That("AB(CD)EF".GetMatch("\\(..\\)"), Is.EqualTo("(CD)"));
-			Assert.AreEqual("(CD)", "AB(CD)EF".GetMatch("\\(CD\\)"));
+			Assert.That("AB(CD)EF".GetMatch("\\(CD\\)"), Is.EqualTo("(CD)"));
 
 			// Not match.
-			Assert.AreEqual(null, "ABCDEF".GetMatch("cDe"));
+			Assert.That("ABCDEF".GetMatch("cDe"), Is.EqualTo(null));
-			Assert.AreEqual(null, "ABCDEF".GetMatch("eFg"));
+			Assert.That("ABCDEF".GetMatch("eFg"), Is.EqualTo(null));
-			Assert.AreEqual("", "ABCDEF".Match("cDe", System.Text.RegularExpressions.RegexOptions.None).Value);
+			Assert.That("ABCDEF".Match("cDe", System.Text.RegularExpressions.RegexOptions.None).Value, Is.Empty);
-			Assert.AreEqual("", "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Value);
+			Assert.That("ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Value, Is.Empty);
 		}
 
-		[TestMethod]
+		[Test]
 		public void StringUtil_Matches()
 		{
 			// Match.
-			Assert.AreEqual(1, "ABCDEF".GetMatches("CDE").Count);
+			Assert.That("ABCDEF".GetMatches("CDE").Count, Is.EqualTo(1));
-			Assert.AreEqual(1, "ABCDEF".GetMatchesCI("cDe").Count);
+			Assert.That("ABCDEF".GetMatchesCI("cDe").Count, Is.EqualTo(1));
-			Assert.AreEqual(1, "ABCDEF".Matches("CDE", System.Text.RegularExpressions.RegexOptions.None).Count);
+			Assert.That("ABCDEF".Matches("CDE", System.Text.RegularExpressions.RegexOptions.None).Count, Is.EqualTo(1));
-			Assert.AreEqual(1, "ABCDEF".Matches(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Count);
+			Assert.That("ABCDEF".Matches(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Count, Is.EqualTo(1));
-			Assert.AreEqual(1, "ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Count);
+			Assert.That("ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Count, Is.EqualTo(1));
 
 			// Match with escaped content.
-			Assert.AreEqual(1, "ABC DEF".GetMatchesCI("\\s").Count);
+			Assert.That("ABC DEF".GetMatchesCI("\\s").Count, Is.EqualTo(1));
-			Assert.AreEqual(1, "ABC\\sDEF".GetMatchesCI("\\\\s").Count);
+			Assert.That("ABC\\sDEF".GetMatchesCI("\\\\s").Count, Is.EqualTo(1));
-			Assert.AreEqual(4, "AB(CD)EF".GetMatchesCI("(..)").Count);
+			Assert.That("AB(CD)EF".GetMatchesCI("(..)").Count, Is.EqualTo(4));
-			Assert.AreEqual("D)", "AB(CD)EF".GetMatchesCI("(..)")[2]);
+			Assert.That("AB(CD)EF".GetMatchesCI("(..)")[2], Is.EqualTo("D)"));
-			Assert.AreEqual(1, "AB(CD)EF".GetMatchesCI("\\(..\\)").Count);
+			Assert.That("AB(CD)EF".GetMatchesCI("\\(..\\)").Count, Is.EqualTo(1));
-			Assert.AreEqual(1, "AB(CD)EF".GetMatchesCI("\\(CD\\)").Count);
+			Assert.That("AB(CD)EF".GetMatchesCI("\\(CD\\)").Count, Is.EqualTo(1));
 
 			// Not match.
-			Assert.AreEqual(0, "ABCDEF".GetMatches("cDe").Count);
+			Assert.That("ABCDEF".GetMatches("cDe").Count, Is.EqualTo(0));
-			Assert.AreEqual(0, "ABCDEF".GetMatches("eFg").Count);
+			Assert.That("ABCDEF".GetMatches("eFg").Count, Is.EqualTo(0));
-			Assert.AreEqual(0, "ABCDEF".Matches("cDe", System.Text.RegularExpressions.RegexOptions.None).Count);
+			Assert.That("ABCDEF".Matches("cDe", System.Text.RegularExpressions.RegexOptions.None).Count, Is.EqualTo(0));
-			Assert.AreEqual(0, "ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Count);
+			Assert.That("ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Count, Is.EqualTo(0));
 		}
 
-		[TestMethod]
+		[Test]
 		public void StringUtil_MatchCount()
 		{
 			// Match.
-			Assert.AreEqual(1, "ABCDEF".GetMatchCount("CDE"));
+			Assert.That("ABCDEF".GetMatchCount("CDE"), Is.EqualTo(1));
-			Assert.AreEqual(1, "ABCDEF".MatchesCount(new Regex("CDE")));
+			Assert.That("ABCDEF".MatchesCount(new Regex("CDE")), Is.EqualTo(1));
-			Assert.AreEqual(2, "ABCDEFGHICDEJKL".GetMatchCount("CDE"));
+			Assert.That("ABCDEFGHICDEJKL".GetMatchCount("CDE"), Is.EqualTo(2));
-			Assert.AreEqual(2, "ABCDEFGHICDEJKL".MatchesCount(new Regex("CDE")));
+			Assert.That("ABCDEFGHICDEJKL".MatchesCount(new Regex("CDE")), Is.EqualTo(2));
 		}
 
 		// --- Padding ---
 
-		[TestMethod]
+		[Test]
 		public void StringUtil_PadLeft()
 		{
 			// Leading spaces.
-			Assert.AreEqual("   ", "".PadLeft(3, ' '));
+			Assert.That("".PadLeft(3, ' '), Is.EqualTo("   "));
-			Assert.AreEqual("  A", "A".PadLeft(3, ' '));
+			Assert.That("A".PadLeft(3, ' '), Is.EqualTo("  A"));
-			Assert.AreEqual(" AB", "AB".PadLeft(3, ' '));
+			Assert.That("AB".PadLeft(3, ' '), Is.EqualTo(" AB"));
-			Assert.AreEqual("ABC", "ABC".PadLeft(3, ' '));
+			Assert.That("ABC".PadLeft(3, ' '), Is.EqualTo("ABC"));
-			Assert.AreEqual("ABCD", "ABCD".PadLeft(3, ' '));
+			Assert.That("ABCD".PadLeft(3, ' '), Is.EqualTo("ABCD"));
 
 			// Leading zeroes.
-			Assert.AreEqual("00", "".PadLeft(2, '0'));
+			Assert.That("".PadLeft(2, '0'), Is.EqualTo("00"));
-			Assert.AreEqual("01", "1".PadLeft(2, '0'));
+			Assert.That("1".PadLeft(2, '0'), Is.EqualTo("01"));
-			Assert.AreEqual("123", "123".PadLeft(3, '0'));
+			Assert.That("123".PadLeft(3, '0'), Is.EqualTo("123"));
-			Assert.AreEqual("0123", "123".PadLeft(4, '0'));
+			Assert.That("123".PadLeft(4, '0'), Is.EqualTo("0123"));
-			Assert.AreEqual("00123", "123".PadLeft(5, '0'));
+			Assert.That("123".PadLeft(5, '0'), Is.EqualTo("00123"));
 		}
-		[TestMethod]
+		[Test]
 		public void StringUtil_PadRight()
 		{
 			// Leading spaces.
-			Assert.AreEqual("   ", "".PadRight(3, ' '));
+			Assert.That("".PadRight(3, ' '), Is.EqualTo("   "));
-			Assert.AreEqual("A  ", "A".PadRight(3, ' '));
+			Assert.That("A".PadRight(3, ' '), Is.EqualTo("A  "));
-			Assert.AreEqual("AB ", "AB".PadRight(3, ' '));
+			Assert.That("AB".PadRight(3, ' '), Is.EqualTo("AB "));
-			Assert.AreEqual("ABC", "ABC".PadRight(3, ' '));
+			Assert.That("ABC".PadRight(3, ' '), Is.EqualTo("ABC"));
-			Assert.AreEqual("ABCD", "ABCD".PadRight(3, ' '));
+			Assert.That("ABCD".PadRight(3, ' '), Is.EqualTo("ABCD"));
 
 			// Trailing zeroes.
-			Assert.AreEqual("00", "".PadRight(2, '0'));
+			Assert.That("".PadRight(2, '0'), Is.EqualTo("00"));
-			Assert.AreEqual("10", "1".PadRight(2, '0'));
+			Assert.That("1".PadRight(2, '0'), Is.EqualTo("10"));
-			Assert.AreEqual("12", "12".PadRight(2, '0'));
+			Assert.That("12".PadRight(2, '0'), Is.EqualTo("12"));
-			Assert.AreEqual("123", "123".PadRight(3, '0'));
+			Assert.That("123".PadRight(3, '0'), Is.EqualTo("123"));
-			Assert.AreEqual("1230", "123".PadRight(4, '0'));
+			Assert.That("123".PadRight(4, '0'), Is.EqualTo("1230"));
-			Assert.AreEqual("12300", "123".PadRight(5, '0'));
+			Assert.That("123".PadRight(5, '0'), Is.EqualTo("12300"));
 		}
 
 		// --- Safe Substrings ---
 
-		[TestMethod]
+		[Test]
 		public void StringUtil_SubstringSafe()
 		{
-			Assert.AreEqual("", StringUtil.SubstringSafe(null, 0));
+			Assert.That(StringUtil.SubstringSafe(null, 0), Is.Empty);
-			Assert.AreEqual("", StringUtil.SubstringSafe("", 0));
+			Assert.That(StringUtil.SubstringSafe("", 0), Is.Empty);
-			Assert.AreEqual("", "".SubstringSafe(0));
+			Assert.That("".SubstringSafe(0), Is.Empty);
 
 			// Right portion from start position.
-			Assert.AreEqual("abc", "abc".SubstringSafe(-3));
+			Assert.That("abc".SubstringSafe(-3), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", "abc".SubstringSafe(-2));
+			Assert.That("abc".SubstringSafe(-2), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", "abc".SubstringSafe(-1));
+			Assert.That("abc".SubstringSafe(-1), Is.EqualTo("abc"));
-			Assert.AreEqual("abc", "abc".SubstringSafe(0));
+			Assert.That("abc".SubstringSafe(0), Is.EqualTo("abc"));
-			Assert.AreEqual("bc", "abc".SubstringSafe(1));
+			Assert.That("abc".SubstringSafe(1), Is.EqualTo("bc"));
-			Assert.AreEqual("c", "abc".SubstringSafe(2));
+			Assert.That("abc".SubstringSafe(2), Is.EqualTo("c"));
-			Assert.AreEqual("", "abc".SubstringSafe(3));
+			Assert.That("abc".SubstringSafe(3), Is.Empty);
 
 			// Zero length.
-			Assert.AreEqual("", StringUtil.SubstringSafe(null, 0, 0));
+			Assert.That(StringUtil.SubstringSafe(null, 0, 0), Is.Empty);
-			Assert.AreEqual("", StringUtil.SubstringSafe("", 0, 0));
+			Assert.That(StringUtil.SubstringSafe("", 0, 0), Is.Empty);
-			Assert.AreEqual("", "".SubstringSafe(0, 0));
+			Assert.That("".SubstringSafe(0, 0), Is.Empty);
-			Assert.AreEqual("", "abc".SubstringSafe(-1, 0));
+			Assert.That("abc".SubstringSafe(-1, 0), Is.Empty);
-			Assert.AreEqual("", "abc".SubstringSafe(0, 0));
+			Assert.That("abc".SubstringSafe(0, 0), Is.Empty);
-			Assert.AreEqual("", "abc".SubstringSafe(1, 0));
+			Assert.That("abc".SubstringSafe(1, 0), Is.Empty);
-			Assert.AreEqual("", "abc".SubstringSafe(2, 0));
+			Assert.That("abc".SubstringSafe(2, 0), Is.Empty);
-			Assert.AreEqual("", "abc".SubstringSafe(3, 0));
+			Assert.That("abc".SubstringSafe(3, 0), Is.Empty);
-			Assert.AreEqual("", "abc".SubstringSafe(4, 0));
+			Assert.That("abc".SubstringSafe(4, 0), Is.Empty);
 
 			// Mid portion.
-			Assert.AreEqual("abc", "abcde".SubstringSafe(0, 3));
+			Assert.That("abcde".SubstringSafe(0, 3), Is.EqualTo("abc"));
-			Assert.AreEqual("bcd", "abcde".SubstringSafe(1, 3));
+			Assert.That("abcde".SubstringSafe(1, 3), Is.EqualTo("bcd"));
-			Assert.AreEqual("cde", "abcde".SubstringSafe(2, 3));
+			Assert.That("abcde".SubstringSafe(2, 3), Is.EqualTo("cde"));
 
 			// Excessive length.
-			Assert.AreEqual("abcde", "abcde".SubstringSafe(-1, 12));
+			Assert.That("abcde".SubstringSafe(-1, 12), Is.EqualTo("abcde"));
-			Assert.AreEqual("abcde", "abcde".SubstringSafe(0, 12));
+			Assert.That("abcde".SubstringSafe(0, 12), Is.EqualTo("abcde"));
-			Assert.AreEqual("bcde", "abcde".SubstringSafe(1, 12));
+			Assert.That("abcde".SubstringSafe(1, 12), Is.EqualTo("bcde"));
-			Assert.AreEqual("cde", "abcde".SubstringSafe(2, 12));
+			Assert.That("abcde".SubstringSafe(2, 12), Is.EqualTo("cde"));
-			Assert.AreEqual("de", "abcde".SubstringSafe(3, 12));
+			Assert.That("abcde".SubstringSafe(3, 12), Is.EqualTo("de"));
-			Assert.AreEqual("e", "abcde".SubstringSafe(4, 12));
+			Assert.That("abcde".SubstringSafe(4, 12), Is.EqualTo("e"));
-			Assert.AreEqual("", "abcde".SubstringSafe(5, 12));
+			Assert.That("abcde".SubstringSafe(5, 12), Is.Empty);
 		}
 		// --- The End ---
 	}

SacsCoreUnitTests/Standard/Base/Utils/SysUtil_Tester.cs

@@ -1,111 +1,102 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Reflection;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Base.Utils;
 
 namespace Sarand.UnitTests.Core.Base.Utils
 {
-	[TestClass]
+	[TestFixture]
 	public class SysUtil_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data members.
+
 		private static readonly String ClassName_GeneratedMemberName_Prefix = "<";
 		private static readonly String ClassName_CompilerGeneratedClass = ClassName_GeneratedMemberName_Prefix + ">c";
 
-		//-------------------------------------------------------------------
 		// Calling code class name.
-		//-------------------------------------------------------------------
+
-		[TestMethod]
+		// --- Tests ---
+
+		[Test]
 		public void SysUtil_GetCallerClassName_Test()
 		{
 			// Leading spaces.
-			Assert.AreNotEqual(null, SysUtil.GetCallerClassName());
+			Assert.That(SysUtil.GetCallerClassName(), Is.Not.EqualTo(null));
-			Assert.AreNotEqual("", SysUtil.GetCallerClassName());
+			Assert.That(SysUtil.GetCallerClassName(), Is.Not.Empty);
-			Assert.AreEqual("SysUtil_Tester", SysUtil.GetCallerClassName());
+			Assert.That(SysUtil.GetCallerClassName(), Is.EqualTo("SysUtil_Tester"));
 
 			// Compiler generated context.
 			Func<string> temp = () => { return SysUtil.GetCallerClassName(); };
-			Assert.AreEqual(ClassName_CompilerGeneratedClass, temp());
+			Assert.That(temp(), Is.EqualTo(ClassName_CompilerGeneratedClass));
 
 			// Anonymous function.
-			Assert.AreEqual(ClassName_CompilerGeneratedClass, ((Func<string>)(() => SysUtil.GetCallerClassName()))());
+			Assert.That(((Func<string>)(() => SysUtil.GetCallerClassName()))(), Is.EqualTo(ClassName_CompilerGeneratedClass));
-			Assert.AreEqual(ClassName_CompilerGeneratedClass, new Func<string>(() => SysUtil.GetCallerClassName())());
+			Assert.That(new Func<string>(() => SysUtil.GetCallerClassName())(), Is.EqualTo(ClassName_CompilerGeneratedClass));
 		}
 
-		//-------------------------------------------------------------------
 		// Calling code function name.
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SysUtil_GetCallerMemberName_Test()
 		{
 			// Leading spaces.
-			Assert.AreNotEqual(null, SysUtil.GetCallerMemberName());
+			Assert.That(SysUtil.GetCallerMemberName(), Is.Not.EqualTo(null));
-			Assert.AreNotEqual("", SysUtil.GetCallerMemberName());
+			Assert.That(SysUtil.GetCallerMemberName(), Is.Not.Empty);
-			Assert.AreEqual("SysUtil_GetCallerMemberName_Test", SysUtil.GetCallerMemberName());
+			Assert.That(SysUtil.GetCallerMemberName(), Is.EqualTo("SysUtil_GetCallerMemberName_Test"));
-			Assert.AreEqual(nameof(SysUtil_GetCallerMemberName_Test), SysUtil.GetCallerMemberName());
+			Assert.That(SysUtil.GetCallerMemberName(), Is.EqualTo(nameof(SysUtil_GetCallerMemberName_Test)));
-			Assert.AreEqual(MethodBase.GetCurrentMethod().Name, SysUtil.GetCallerMemberName());
+			Assert.That(SysUtil.GetCallerMemberName(), Is.EqualTo(MethodBase.GetCurrentMethod().Name));
 
 			// Compiler generated context.
 			Func<string> temp = () => { return SysUtil.GetCallerMemberName(); };
-			Assert.AreEqual(MethodBase.GetCurrentMethod().Name, temp());
+			Assert.That(temp(), Is.EqualTo(MethodBase.GetCurrentMethod().Name));
 
 			// Anonymous function.
-			Assert.AreEqual(MethodBase.GetCurrentMethod().Name, ((Func<string>)(() => SysUtil.GetCallerMemberName()))());
+			Assert.That(((Func<string>)(() => SysUtil.GetCallerMemberName()))(), Is.EqualTo(MethodBase.GetCurrentMethod().Name));
-			Assert.AreEqual(MethodBase.GetCurrentMethod().Name, new Func<string>(() => SysUtil.GetCallerMemberName())());
+			Assert.That(new Func<string>(() => SysUtil.GetCallerMemberName())(), Is.EqualTo(MethodBase.GetCurrentMethod().Name));
 		}
 
-		//-------------------------------------------------------------------
 		// Calling code file path.
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SysUtil_GetCallerFilePath_Test()
 		{
 			// Leading spaces.
-			Assert.AreNotEqual(null, SysUtil.GetCallerFilePath());
+			Assert.That(SysUtil.GetCallerFilePath(), Is.Not.EqualTo(null));
-			Assert.AreNotEqual("", SysUtil.GetCallerFilePath());
+			Assert.That(SysUtil.GetCallerFilePath(), Is.Not.Empty);
-			Assert.AreEqual(@"D:\Sarand\Projects\Users\AHoward\VS2022\Common-VS\Workspace\SacsCoreUnitTests\Standard\Base\Utils\SysUtil_Tester.cs", SysUtil.GetCallerFilePath());
+			Assert.That(SysUtil.GetCallerFilePath(), Is.EqualTo(@"D:\Sarand\Projects\Users\AHoward\VS2022\Common-VS\Workspace\SacsCoreUnitTests\Standard\Base\Utils\SysUtil_Tester.cs"));
-			Assert.AreEqual(true, SysUtil.GetCallerFilePath().EndsWith("SysUtil_Tester.cs"));
+			Assert.That(SysUtil.GetCallerFilePath().EndsWith("SysUtil_Tester.cs"), Is.EqualTo(true));
 		}
 
-		//-------------------------------------------------------------------
 		// Calling code line number.
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SysUtil_GetCallerLineNumber_Test()
 		{
 			// Leading spaces.
-			Assert.AreNotEqual(0, SysUtil.GetCallerLineNumber());
+			Assert.That(SysUtil.GetCallerLineNumber(), Is.Not.EqualTo(0));
-			Assert.AreEqual((new StackFrame(0, true)).GetFileLineNumber(), SysUtil.GetCallerLineNumber());
+			Assert.That(SysUtil.GetCallerLineNumber(), Is.EqualTo((new StackFrame(0, true)).GetFileLineNumber()));
 		}
 
-		//-------------------------------------------------------------------
 		// Calling code file path.
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SysUtil_GetCallerClassMethod_Test()
 		{
 			// Leading spaces.
-			Assert.AreNotEqual(null, SysUtil.GetCallerClassMethod());
+			Assert.That(SysUtil.GetCallerClassMethod(), Is.Not.EqualTo(null));
-			Assert.AreNotEqual("", SysUtil.GetCallerClassMethod());
+			Assert.That(SysUtil.GetCallerClassMethod(), Is.Not.Empty);
-			Assert.AreEqual(GetType().Name + "." + MethodBase.GetCurrentMethod().Name, SysUtil.GetCallerClassMethod());
+			Assert.That(SysUtil.GetCallerClassMethod(), Is.EqualTo(GetType().Name + "." + MethodBase.GetCurrentMethod().Name));
-			Assert.AreEqual(nameof(SysUtil_Tester) + "." + nameof(SysUtil_GetCallerClassMethod_Test), SysUtil.GetCallerClassMethod());
+			Assert.That(SysUtil.GetCallerClassMethod(), Is.EqualTo(nameof(SysUtil_Tester) + "." + nameof(SysUtil_GetCallerClassMethod_Test)));
 		}
 
-		//-------------------------------------------------------------------
 		// Calling code file path.
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void SysUtil_Fn_Test()
 		{
 			// Leading spaces.
-			Assert.AreNotEqual(null, SysUtil.Fn);
+			Assert.That(SysUtil.Fn, Is.Not.EqualTo(null));
-			Assert.AreNotEqual("", SysUtil.Fn);
+			Assert.That(SysUtil.Fn, Is.Not.Empty);
-			Assert.AreEqual(GetType().Name + "." + MethodBase.GetCurrentMethod().Name, SysUtil.Fn);
+			Assert.That(SysUtil.Fn, Is.EqualTo(GetType().Name + "." + MethodBase.GetCurrentMethod().Name));
-			Assert.AreEqual(nameof(SysUtil_Tester) + "." + nameof(SysUtil_Fn_Test), SysUtil.Fn);
+			Assert.That(SysUtil.Fn, Is.EqualTo(nameof(SysUtil_Tester) + "." + nameof(SysUtil_Fn_Test)));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
 }

SacsCoreUnitTests/Standard/Proc/Excel/SaMsSpreadsheet_POI_Tester.cs

@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using NPOI.HSSF.UserModel;
 using Sarand.Net.Standard.Base.Core;
 using Sarand.Net.Standard.Proc.Excel;
@@ -7,74 +7,74 @@ using System.IO;
 
 namespace Sacs.UnitTests.Net.Standard.Proc.Excel
 {
-	[TestClass]
+	[TestFixture]
 	public class SaMsSpreadsheet_POI_Tester
 	{
 		// --- Workbook Lifecycle ---
 
-		[TestMethod]
+		[Test]
 		public void CreateWorkbook_CreatesDefaultWorksheet()
 		{
 			using (SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI())
 			{
-				Assert.IsTrue(spreadsheet.CreateWorkbook());
+				Assert.That(spreadsheet.CreateWorkbook(), Is.True);
-				Assert.IsTrue(spreadsheet.IsWorkbookValid());
+				Assert.That(spreadsheet.IsWorkbookValid(), Is.True);
-				Assert.IsTrue(spreadsheet.IsWorksheetValid());
+				Assert.That(spreadsheet.IsWorksheetValid(), Is.True);
-				Assert.AreEqual((uint)1, spreadsheet.WorksheetCount);
+				Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)1));
-				Assert.AreEqual((uint)1, spreadsheet.WorksheetPos);
+				Assert.That(spreadsheet.WorksheetPos, Is.EqualTo((uint)1));
-				Assert.AreEqual("Sheet1", spreadsheet.WorksheetName);
+				Assert.That(spreadsheet.WorksheetName, Is.EqualTo("Sheet1"));
 			}
 		}
 
-		[TestMethod]
+		[Test]
 		public void CloseWorkbook_InvalidatesWorkbookAndWorksheet()
 		{
 			using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
 			{
-				Assert.IsTrue(spreadsheet.CloseWorkbook());
+				Assert.That(spreadsheet.CloseWorkbook(), Is.True);
-				Assert.IsFalse(spreadsheet.IsWorkbookValid());
+				Assert.That(spreadsheet.IsWorkbookValid(), Is.False);
-				Assert.IsFalse(spreadsheet.IsWorksheetValid());
+				Assert.That(spreadsheet.IsWorksheetValid(), Is.False);
 			}
 		}
 
 		// --- Worksheet Operations ---
 
-		[TestMethod]
+		[Test]
 		public void WorksheetOperations_AddOpenRenameAndRemoveWorksheets()
 		{
 			using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
 			{
 				spreadsheet.WorksheetName = "Primary";
-				Assert.IsTrue(spreadsheet.AddWorksheet("Secondary"));
+				Assert.That(spreadsheet.AddWorksheet("Secondary"), Is.True);
-				Assert.AreEqual((uint)2, spreadsheet.WorksheetCount);
+				Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)2));
-				Assert.AreEqual("Secondary", spreadsheet.WorksheetName);
+				Assert.That(spreadsheet.WorksheetName, Is.EqualTo("Secondary"));
 
-				Assert.IsTrue(spreadsheet.OpenWorksheet(" primary "));
+				Assert.That(spreadsheet.OpenWorksheet(" primary "), Is.True);
-				Assert.AreEqual((uint)1, spreadsheet.WorksheetPos);
+				Assert.That(spreadsheet.WorksheetPos, Is.EqualTo((uint)1));
-				Assert.AreEqual("Primary", spreadsheet.WorksheetName);
+				Assert.That(spreadsheet.WorksheetName, Is.EqualTo("Primary"));
 
-				Assert.IsTrue(spreadsheet.RemoveWorksheet(2));
+				Assert.That(spreadsheet.RemoveWorksheet(2), Is.True);
-				Assert.AreEqual((uint)1, spreadsheet.WorksheetCount);
+				Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)1));
 			}
 		}
 
-		[TestMethod]
+		[Test]
 		public void SetWorksheetCount_AddsAndRemovesWorksheets()
 		{
 			using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
 			{
-				Assert.IsTrue(spreadsheet.SetWorksheetCount(3));
+				Assert.That(spreadsheet.SetWorksheetCount(3), Is.True);
-				Assert.AreEqual((uint)3, spreadsheet.WorksheetCount);
+				Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)3));
 
-				Assert.IsTrue(spreadsheet.SetWorksheetCount(1));
+				Assert.That(spreadsheet.SetWorksheetCount(1), Is.True);
-				Assert.AreEqual((uint)1, spreadsheet.WorksheetCount);
+				Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)1));
-				Assert.AreEqual((uint)1, spreadsheet.WorksheetPos);
+				Assert.That(spreadsheet.WorksheetPos, Is.EqualTo((uint)1));
 			}
 		}
 
 		// --- Workbook Round Trips ---
 
-		[TestMethod]
+		[Test]
 		public void GetDocumentData_RoundTripPreservesCellValuesAndFormula()
 		{
 			DateTime expectedDate = new DateTime(2026, 9, 12, 14, 30, 0);
@@ -86,49 +86,49 @@ namespace Sacs.UnitTests.Net.Standard.Proc.Excel
 			byte[] workbookData;
 			using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
 			{
-				Assert.IsTrue(spreadsheet.SetCellValue(1, 1, new DataValue("Heading"), null));
+				Assert.That(spreadsheet.SetCellValue(1, 1, new DataValue("Heading"), null), Is.True);
-				Assert.IsTrue(spreadsheet.SetCellValue(1, 2, new DataValue("Text value"), null));
+				Assert.That(spreadsheet.SetCellValue(1, 2, new DataValue("Text value"), null), Is.True);
-				Assert.IsTrue(spreadsheet.SetCellValue(2, 2, new DataValue(42L), null));
+				Assert.That(spreadsheet.SetCellValue(2, 2, new DataValue(42L), null), Is.True);
-				Assert.IsTrue(spreadsheet.SetCellValue(3, 2, new DataValue(12.5), null));
+				Assert.That(spreadsheet.SetCellValue(3, 2, new DataValue(12.5), null), Is.True);
-				Assert.IsTrue(spreadsheet.SetCellValue(4, 2, new DataValue(true), null));
+				Assert.That(spreadsheet.SetCellValue(4, 2, new DataValue(true), null), Is.True);
-				Assert.IsTrue(spreadsheet.SetCellValue(5, 2, new DataValue(expectedDate), dateStyle));
+				Assert.That(spreadsheet.SetCellValue(5, 2, new DataValue(expectedDate), dateStyle), Is.True);
-				Assert.IsTrue(spreadsheet.SetCellFormula(6, 2, "B2+C2", null));
+				Assert.That(spreadsheet.SetCellFormula(6, 2, "B2+C2", null), Is.True);
 				workbookData = spreadsheet.GetDocumentData();
 			}
 
-			Assert.IsNotNull(workbookData);
+			Assert.That(workbookData, Is.Not.Null);
-			Assert.IsTrue(workbookData.Length > 0);
+			Assert.That(workbookData.Length > 0, Is.True);
 
 			using (SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI())
 			{
-				Assert.IsTrue(spreadsheet.OpenWorkbook(workbookData));
+				Assert.That(spreadsheet.OpenWorkbook(workbookData), Is.True);
-				Assert.IsTrue(spreadsheet.OpenWorksheet(1));
+				Assert.That(spreadsheet.OpenWorksheet(1), Is.True);
-				Assert.AreEqual("Text value", spreadsheet.GetCellText(1, 2));
+				Assert.That(spreadsheet.GetCellText(1, 2), Is.EqualTo("Text value"));
-				Assert.AreEqual(42L, spreadsheet.GetCellValue(2, 2).AsLong());
+				Assert.That(spreadsheet.GetCellValue(2, 2).AsLong(), Is.EqualTo(42L));
-				Assert.AreEqual(12.5, spreadsheet.GetCellValue(3, 2).AsDouble(), 0.000001);
+				Assert.That(spreadsheet.GetCellValue(3, 2).AsDouble(), Is.EqualTo(12.5).Within(0.000001));
-				Assert.AreEqual("TRUE", spreadsheet.GetCellText(4, 2).ToUpperInvariant());
+				Assert.That(spreadsheet.GetCellText(4, 2).ToUpperInvariant(), Is.EqualTo("TRUE"));
-				Assert.AreEqual(expectedDate, spreadsheet.GetCellValue(5, 2).AsDateTime());
+				Assert.That(spreadsheet.GetCellValue(5, 2).AsDateTime(), Is.EqualTo(expectedDate));
-				Assert.AreEqual("B2+C2", spreadsheet.GetCellFormula(6, 2));
+				Assert.That(spreadsheet.GetCellFormula(6, 2), Is.EqualTo("B2+C2"));
 			}
 		}
 
-		[TestMethod]
+		[Test]
 		public void GetCellValue_TextCellReturnsStringDataValue()
 		{
 			using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
 			{
-				Assert.IsTrue(spreadsheet.SetCellValue(1, 1, new DataValue("Text value"), null));
+				Assert.That(spreadsheet.SetCellValue(1, 1, new DataValue("Text value"), null), Is.True);
-				Assert.AreEqual("Text value", spreadsheet.GetCellValue(1, 1).AsString());
+				Assert.That(spreadsheet.GetCellValue(1, 1).AsString(), Is.EqualTo("Text value"));
 			}
 		}
 
-		[TestMethod]
+		[Test]
 		public void OpenWorkbook_StreamReadsFromStartRegardlessOfPosition()
 		{
 			byte[] workbookData;
 			using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
 			{
-				Assert.IsTrue(spreadsheet.SetCellValue(1, 1, new DataValue("Stream value"), null));
+				Assert.That(spreadsheet.SetCellValue(1, 1, new DataValue("Stream value"), null), Is.True);
 				workbookData = spreadsheet.GetDocumentData();
 			}
 
@@ -136,39 +136,39 @@ namespace Sacs.UnitTests.Net.Standard.Proc.Excel
 			using (SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI())
 			{
 				stream.Position = stream.Length;
-				Assert.IsTrue(spreadsheet.OpenWorkbook(stream));
+				Assert.That(spreadsheet.OpenWorkbook(stream), Is.True);
-				Assert.IsTrue(spreadsheet.OpenWorksheet(1));
+				Assert.That(spreadsheet.OpenWorksheet(1), Is.True);
-				Assert.AreEqual("Stream value", spreadsheet.GetCellText(1, 1));
+				Assert.That(spreadsheet.GetCellText(1, 1), Is.EqualTo("Stream value"));
 			}
 		}
 
-		[TestMethod]
+		[Test]
 		public void OpenWorkbook_LegacyXlsDataCanBeReadAndReserialized()
 		{
 			byte[] workbookData = CreateLegacyWorkbookData();
 
 			using (SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI())
 			{
-				Assert.IsTrue(spreadsheet.OpenWorkbook(workbookData));
+				Assert.That(spreadsheet.OpenWorkbook(workbookData), Is.True);
-				Assert.IsTrue(spreadsheet.OpenWorksheet("Legacy"));
+				Assert.That(spreadsheet.OpenWorksheet("Legacy"), Is.True);
-				Assert.AreEqual("Legacy value", spreadsheet.GetCellValue(1, 1).AsString());
+				Assert.That(spreadsheet.GetCellValue(1, 1).AsString(), Is.EqualTo("Legacy value"));
-				Assert.AreEqual(17L, spreadsheet.GetCellValue(2, 1).AsLong());
+				Assert.That(spreadsheet.GetCellValue(2, 1).AsLong(), Is.EqualTo(17L));
 
 				byte[] roundTripData = spreadsheet.GetDocumentData();
-				Assert.IsNotNull(roundTripData);
+				Assert.That(roundTripData, Is.Not.Null);
 
 				using (SaMsSpreadsheet_POI reopened = new SaMsSpreadsheet_POI())
 				{
-					Assert.IsTrue(reopened.OpenWorkbook(roundTripData));
+					Assert.That(reopened.OpenWorkbook(roundTripData), Is.True);
-					Assert.IsTrue(reopened.OpenWorksheet("Legacy"));
+					Assert.That(reopened.OpenWorksheet("Legacy"), Is.True);
-					Assert.AreEqual("Legacy value", reopened.GetCellValue(1, 1).AsString());
+					Assert.That(reopened.GetCellValue(1, 1).AsString(), Is.EqualTo("Legacy value"));
 				}
 			}
 		}
 
 		// --- Formatting and Dimensions ---
 
-		[TestMethod]
+		[Test]
 		public void DimensionsAndActiveCell_RoundTripPreservesValues()
 		{
 			byte[] workbookData;
@@ -176,8 +176,8 @@ namespace Sacs.UnitTests.Net.Standard.Proc.Excel
 			double expectedRowHeight;
 			using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
 			{
-				Assert.IsTrue(spreadsheet.SetColWidth(2, 120, SaExcelLogicalUnit.Pixel));
+				Assert.That(spreadsheet.SetColWidth(2, 120, SaExcelLogicalUnit.Pixel), Is.True);
-				Assert.IsTrue(spreadsheet.SetRowHeight(3, 24, SaExcelLogicalUnit.Point));
+				Assert.That(spreadsheet.SetRowHeight(3, 24, SaExcelLogicalUnit.Point), Is.True);
 				spreadsheet.SetActiveCell(2, 3);
 				expectedColWidth = spreadsheet.GetColWidth(2, SaExcelLogicalUnit.Pixel);
 				expectedRowHeight = spreadsheet.GetRowHeight(3, SaExcelLogicalUnit.Point);
@@ -186,18 +186,18 @@ namespace Sacs.UnitTests.Net.Standard.Proc.Excel
 
 			using (SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI())
 			{
-				Assert.IsTrue(spreadsheet.OpenWorkbook(workbookData));
+				Assert.That(spreadsheet.OpenWorkbook(workbookData), Is.True);
-				Assert.IsTrue(spreadsheet.OpenWorksheet(1));
+				Assert.That(spreadsheet.OpenWorksheet(1), Is.True);
-				Assert.AreEqual(expectedColWidth, spreadsheet.GetColWidth(2, SaExcelLogicalUnit.Pixel), 0.1);
+				Assert.That(spreadsheet.GetColWidth(2, SaExcelLogicalUnit.Pixel), Is.EqualTo(expectedColWidth).Within(0.1));
-				Assert.AreEqual(expectedRowHeight, spreadsheet.GetRowHeight(3, SaExcelLogicalUnit.Point), 0.1);
+				Assert.That(spreadsheet.GetRowHeight(3, SaExcelLogicalUnit.Point), Is.EqualTo(expectedRowHeight).Within(0.1));
-				Assert.AreEqual((uint)2, spreadsheet.ActiveColPos);
+				Assert.That(spreadsheet.ActiveColPos, Is.EqualTo((uint)2));
-				Assert.AreEqual((uint)3, spreadsheet.ActiveRowPos);
+				Assert.That(spreadsheet.ActiveRowPos, Is.EqualTo((uint)3));
 			}
 		}
 
 		// --- File Persistence ---
 
-		[TestMethod]
+		[Test]
 		public void SaveDocument_FileRoundTripPreservesWorkbook()
 		{
 			String testDirectory = CreateTestDirectory();
@@ -208,18 +208,18 @@ namespace Sacs.UnitTests.Net.Standard.Proc.Excel
 				using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
 				{
 					spreadsheet.WorksheetName = "Saved";
-					Assert.IsTrue(spreadsheet.SetCellValue(1, 1, new DataValue("Saved value"), null));
+					Assert.That(spreadsheet.SetCellValue(1, 1, new DataValue("Saved value"), null), Is.True);
-					Assert.IsTrue(spreadsheet.SaveDocument(workbookPath, (int)SaXlFileFormat.OpenXMLWorkbook, true));
+					Assert.That(spreadsheet.SaveDocument(workbookPath, (int)SaXlFileFormat.OpenXMLWorkbook, true), Is.True);
 				}
 
-				Assert.IsTrue(File.Exists(workbookPath));
+				Assert.That(File.Exists(workbookPath), Is.True);
-				Assert.IsTrue(new FileInfo(workbookPath).Length > 0);
+				Assert.That(new FileInfo(workbookPath).Length > 0, Is.True);
 
 				using (SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI())
 				{
-					Assert.IsTrue(spreadsheet.OpenWorkbook(workbookPath));
+					Assert.That(spreadsheet.OpenWorkbook(workbookPath), Is.True);
-					Assert.IsTrue(spreadsheet.OpenWorksheet("Saved"));
+					Assert.That(spreadsheet.OpenWorksheet("Saved"), Is.True);
-					Assert.AreEqual("Saved value", spreadsheet.GetCellText(1, 1));
+					Assert.That(spreadsheet.GetCellText(1, 1), Is.EqualTo("Saved value"));
 				}
 			}
 			finally
@@ -234,7 +234,7 @@ namespace Sacs.UnitTests.Net.Standard.Proc.Excel
 		private static SaMsSpreadsheet_POI CreateSpreadsheet()
 		{
 			SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI();
-			Assert.IsTrue(spreadsheet.CreateWorkbook());
+			Assert.That(spreadsheet.CreateWorkbook(), Is.True);
 			return spreadsheet;
 		}
 

SacsCoreUnitTests/Standard/Proc/Excel/SaMsSpreadsheet_Tester.cs

@@ -1,42 +1,41 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using Sarand.Net.Standard.Proc.Excel;
 using System;
 
 namespace Sacs.UnitTests.Net.Standard.Proc.Excel
 {
-	[TestClass]
+	[TestFixture]
 	public class SaMsSpreadsheet_Tester
 	{
-		//-------------------------------------------------------------------
+		// --- Data Members ---
-		// Data members.
+
 		private Random random = new Random();
 
-		//-------------------------------------------------------------------
+		// --- Tests ---
-		// GetPosForColId.
+
-		//-------------------------------------------------------------------
+		[Test]
-		[TestMethod]
 		public void GetPosForColId_IsEmpty()
 		{
-			Assert.AreEqual(1, SaMsSpreadsheet.GetPosForColId("A"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("A"), Is.EqualTo(1));
-			Assert.AreEqual(1, SaMsSpreadsheet.GetPosForColId("a"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("a"), Is.EqualTo(1));
-			Assert.AreEqual(2, SaMsSpreadsheet.GetPosForColId("B"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("B"), Is.EqualTo(2));
-			Assert.AreEqual(3, SaMsSpreadsheet.GetPosForColId("C"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("C"), Is.EqualTo(3));
-			Assert.AreEqual(24, SaMsSpreadsheet.GetPosForColId("X"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("X"), Is.EqualTo(24));
-			Assert.AreEqual(25, SaMsSpreadsheet.GetPosForColId("Y"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("Y"), Is.EqualTo(25));
-			Assert.AreEqual(26, SaMsSpreadsheet.GetPosForColId("Z"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("Z"), Is.EqualTo(26));
-			Assert.AreEqual(27, SaMsSpreadsheet.GetPosForColId("AA"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("AA"), Is.EqualTo(27));
-			Assert.AreEqual(28, SaMsSpreadsheet.GetPosForColId("AB"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("AB"), Is.EqualTo(28));
-			Assert.AreEqual(29, SaMsSpreadsheet.GetPosForColId("AC"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("AC"), Is.EqualTo(29));
-			Assert.AreEqual(128, SaMsSpreadsheet.GetPosForColId("DX"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("DX"), Is.EqualTo(128));
-			Assert.AreEqual(155, SaMsSpreadsheet.GetPosForColId("EY"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("EY"), Is.EqualTo(155));
-			Assert.AreEqual(182, SaMsSpreadsheet.GetPosForColId("FZ"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("FZ"), Is.EqualTo(182));
 
 			// Invalid.
-			Assert.AreEqual(0, SaMsSpreadsheet.GetPosForColId(""));
+			Assert.That(SaMsSpreadsheet.GetPosForColId(""), Is.EqualTo(0));
-			Assert.AreEqual(0, SaMsSpreadsheet.GetPosForColId("1"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("1"), Is.EqualTo(0));
-			Assert.AreEqual(0, SaMsSpreadsheet.GetPosForColId("A1"));
+			Assert.That(SaMsSpreadsheet.GetPosForColId("A1"), Is.EqualTo(0));
 		}
 
-		//-------------------------------------------------------------------
+		// --- The End ---
 	}
 }

docs/component-reviews.md

@@ -15,7 +15,7 @@ Last updated: 2026-09-14
 | `SacsStandardBase/Base/Utils/ImageUtils.cs` | ImageSharp wrapper | Covered for package upgrades | 2026-09-14 | Extend the suite when adding formats or changing resize policy. | Five in-memory tests cover PNG and JPEG metadata, invalid and truncated input, SVG recognition, format-preserving encoding, proportional landscape and portrait resizing, no-upscale behavior, and invalid constraints. |
 | `SacsStandardBase` JSON utilities and `SysId` converter | Newtonsoft.Json integration | Covered for package upgrades | 2026-09-14 | Retain the suite for future Newtonsoft.Json updates. | Six tests cover objects, arrays, nulls, serializer settings, valid and invalid parsing paths, dynamic access, `SysId` conversion, independent deep copies, nested collections, and constructor-value replacement. |
 | `SacsStandardDbas` provider and parameter creation | Microsoft.Data.SqlClient and registry integration | Initial package-upgrade coverage complete | 2026-09-14 | Expand into configured database integration tests before the planned SqlClient major upgrade. | Four database-free tests cover SQL versus forced ODBC connection selection, connection strings, values and nulls, explicit integer and binary types, SQL `DateTime2`, ODBC `DateTime`, precision normalization, and sentinel dates. The redundant Registry 5.0.0 package was removed; .NET 10 supplies the APIs and `NU1510` is gone. |
-| `SacsCoreUnitTests` | Test SDK, MSTest, and coverage tooling | Current; coverage verified | 2026-09-14 | Preserve the analyzer-clean build and explicit coverage validation during future test-tool upgrades. | Uses Microsoft.NET.Test.Sdk 18.10.0, MSTest 4.4.0, and coverlet collector 10.0.1. The MSTest 4 migration corrected 39 reversed expected/actual assertions; all 126 tests pass without MSTest analyzer warnings, and the optional validation coverage mode verifies a non-empty Cobertura report. |
+| `SacsCoreUnitTests` | Test framework, SDK, and coverage tooling | Migrated to NUnit; coverage verified | 2026-09-15 | Use NUnit constraint assertions with `Assert.That` wherever possible. | Uses Microsoft.NET.Test.Sdk 18.10.0, NUnit 4.6.1, NUnit3TestAdapter 6.3.0, NUnit.Analyzers 4.15.0, and coverlet collector 10.0.1. All 126 tests use NUnit's constraint assertion model, pass under NUnit, and produce a non-empty Cobertura report in the optional validation coverage mode. |
 | `SacsMobileXamarin` | Migration disposition | Isolated; retained for reference | 2026-09-10 | Keep outside the supported build unless a separately scoped resurrection or migration is approved. | Source is unchanged and available through `SaCommonVS.LegacyXamarin.sln`; see `docs/legacy-xamarin.md`. |
 | [`SacsMobileMaui`](../SacsMobileMaui/docs/component-reviews.md) | Project | .NET 10 migration complete; tracked in project docs | 2026-09-11 | Validate Apple targets on a Mac and continue API cleanup in the project tracker. | The shared project and both active mobile consumers target .NET 10. Windows runtime smoke tests pass, and Windows and Android Debug builds complete with zero errors. |
 | `SacsStandardBase/Base/Procs/SaProcess_Base.cs` | Class | In progress | 2026-09-09 | Complete the Process Base actions recorded in `topics.md`; review derived processes separately for cooperative polling. | Lifecycle state ownership and cancellation lock ordering were changed. Five focused tests pass. Remaining concerns include mixed sync/async execution, durable cancellation outcome, cancellation exception handling, disposal, and status synchronization. |

docs/topics.md

@@ -44,6 +44,7 @@ Last updated: 2026-09-14
 
 | Topic | Date noted | Date started | Date completed | Outcome |
 |---|---|---|---|---|
+| Migrate Common tests from MSTest to NUnit | 2026-09-14 | 2026-09-14 | 2026-09-15 | Replaced MSTest with NUnit 4.6.1, NUnit3TestAdapter 6.3.0, and NUnit.Analyzers 4.15.0. Converted all 27 fixtures and 126 tests to NUnit's constraint-style `Assert.That` model, removed unused MSTest `TestContext` template scaffolding, and brought every migrated fixture into line with the repository's section-comment convention. Full Common and downstream BusinessMgr validation, including coverage collection, passes. |
 | Modernise Common test tooling and coverage collection | 2026-09-14 | 2026-09-14 | 2026-09-14 | Updated Microsoft.NET.Test.Sdk from 16.5.0 to 18.10.0, MSTest adapter and framework from 2.1.0 to 4.4.0, and coverlet collector from 1.2.0 to 10.0.1 with private-assets metadata. Replaced legacy exception assertions, corrected the `TestContext` property, and fixed 39 reversed expected/actual assertions identified by the MSTest 4 analyzers. All 126 Common tests, 11 BusinessMgr Control tests, and 13 BusinessMgr Portal tests pass. The validation scripts offer `-CollectCoverage`, which verifies non-empty Cobertura reports across Common and both BusinessMgr suites. |
 | Remove redundant Microsoft.Win32.Registry package | 2026-09-10 | 2026-09-14 | 2026-09-14 | Removed the direct 5.0.0 package reference from `SacsStandardDbas`; .NET 10 supplies the required registry APIs. Common and BusinessMgr restore, build, and all 126 Common, 11 Control, and 13 Portal tests pass. The `NU1510` warning no longer appears. |
 | Apply low-risk Common package patches and regression coverage | 2026-09-14 | 2026-09-14 | 2026-09-14 | Updated Microsoft.Data.SqlClient from 5.2.2 to 5.2.3, Newtonsoft.Json from 13.0.3 to 13.0.4, and SixLabors.ImageSharp from 3.1.11 to 3.1.12. Added 15 in-memory tests covering image recognition, encoding and resizing; JSON serialization, parsing, dynamic access, `SysId` conversion and deep copying; and SQL/ODBC provider selection and command parameters. The Common solution builds with zero errors; all 126 Common tests, 11 BusinessMgr Control tests, and 13 BusinessMgr Portal tests pass. Existing warnings are unchanged. |